diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index cd0f880..ae9dd20 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -12,21 +12,21 @@ jobs: - uses: actions/checkout@v4 - uses: dtolnay/rust-toolchain@stable - name: cargo check - run: cargo check --all-targets --all-features -p eric-sdk + run: cargo check --all-targets -p eric-sdk --features eric-bindings-no-build clippy: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: dtolnay/rust-toolchain@stable - - name: cargo clippy - run: cargo clippy --all-features --all-targets -p eric-sdk -- -D warnings + - name: cargo clippy -- -D warnings + run: cargo clippy --all-targets -p eric-sdk --features eric-bindings-no-build -- -D warnings doc: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: dtolnay/rust-toolchain@stable - name: cargo doc - run: cargo doc --no-deps --all-features -p eric-sdk + run: cargo doc --no-deps -p eric-sdk --features eric-bindings-no-build fmt: runs-on: ubuntu-latest steps: @@ -49,11 +49,11 @@ jobs: - uses: actions/checkout@v4 - uses: dtolnay/rust-toolchain@stable - name: cargo test --lib - run: cargo test --lib -p eric-sdk + run: cargo test --lib -p eric-sdk --features eric-bindings-no-build doc-test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: dtolnay/rust-toolchain@stable - name: cargo test --doc - run: cargo test --locked --doc -p eric-sdk + run: cargo test --locked --doc -p eric-sdk --features eric-bindings-no-build diff --git a/.gitignore b/.gitignore index 23d1a80..48a75f8 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,7 @@ # Eric **/eric.log +**/*.pdf # Environment **/.env diff --git a/Cargo.lock b/Cargo.lock index 953a309..a72bec1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -89,6 +89,11 @@ dependencies = [ [[package]] name = "eric-sdk" version = "0.1.0" +dependencies = [ + "anyhow", + "eric-bindings", + "roxmltree", +] [[package]] name = "errno" @@ -249,6 +254,12 @@ version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b" +[[package]] +name = "roxmltree" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97" + [[package]] name = "rustc-hash" version = "1.1.0" diff --git a/Cargo.toml b/Cargo.toml index 29c85d8..8300598 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,7 +8,6 @@ resolver = "2" [workspace.package] authors = ["quambene "] edition = "2021" -version = "0.1.0" readme = "README.md" license = "Apache-2.0" homepage = "https://github.com/quambene/eric-rs" diff --git a/README.md b/README.md index bf62947..851d1b2 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,9 @@ # Eric -[![latest version](https://img.shields.io/crates/v/eric-bindings.svg)](https://crates.io/crates/eric-bindings) -[![documentation](https://docs.rs/eric-bindings/badge.svg)](https://docs.rs/eric-bindings) +[![latest version](https://img.shields.io/crates/v/eric-bindings.svg?label=eric-bindings)](https://crates.io/crates/eric-bindings) +[![documentation](https://img.shields.io/docsrs/eric-bindings?label=eric-bindings)](https://docs.rs/eric-bindings) +[![latest version](https://img.shields.io/crates/v/eric-sdk.svg?label=eric-sdk)](https://crates.io/crates/eric-sdk) +[![documentation](https://img.shields.io/docsrs/eric-sdk?label=eric-sdk)](https://docs.rs/eric-sdk) [![build status](https://github.com/quambene/eric-rs/actions/workflows/ci.yml/badge.svg)](https://github.com/quambene/eric-rs/actions/workflows/ci.yml) Rust bindings and SDK for the ELSTER Rich Client (ERiC) @@ -12,6 +14,11 @@ Rust bindings and SDK for the ELSTER Rich Client (ERiC) - [Rust bindings](#rust-bindings) - [Generate bindings](#generate-bindings) - [Test bindings](#test-bindings) +- [Eric SDK](#eric-sdk) + - [Usage](#usage) + - [Supported Eric versions](#supported-eric-versions) + - [Test SDK](#test-sdk) +- [Changelog](#changelog) ## What is ELSTER? @@ -19,7 +26,7 @@ Elster (short for _Elektronische Steuererklärung_) is a project by the German t ## What is ERiC? -ERiC is a C library that is integrated into a tax application. ERiC checks the data supplied by the tax application for plausibility, and transmits the data encrypted to the computing center of the respective tax administration. +ERiC is a shared C library that is integrated into a tax application. ERiC checks the data supplied by the tax application for plausibility, and transmits the data encrypted to the computing center of the respective tax administration. ## Requirements @@ -35,8 +42,8 @@ apt install llvm-dev libclang-dev clang ### Generate bindings -The environment variables `LIBRARY_NAME`, `LIBRARY_PATH`, `HEADER_FILE`, and -`PLUGIN_PATH` are expected. For example: +To generate the bindings, `eric-bindings` expects the environment variables `LIBRARY_NAME`, `LIBRARY_PATH`, `HEADER_FILE`, and +`PLUGIN_PATH`. For example: ``` bash LIBRARY_NAME=ericapi @@ -48,7 +55,7 @@ PLUGIN_PATH=ERiC-38.1.6.0-Linux-x86_64/ERiC-38.1.6.0/Linux-x86_64/lib/plugins2 The bindings have to be generated on-the-fly for your specific platform and architecture: ``` bash -cargo build -p eric-bindings # Build bindings in debug mode +cargo build -p eric-bindings ``` The bindings are generated in `target/debug/build/eric-bindings-/out/bindings.rs`. @@ -62,3 +69,39 @@ cargo test -p eric-bindings --lib ``` Logs are written to `eric.log` in the current directory. + +## Eric SDK + +`eric-sdk` supports single-threaded Eric instances. + +### Usage + +To use `eric-sdk`, add the path of the shared C library (e.g. to `LD_LIBRARY_PATH` on Linux). + +To send the xml file, the path and password of the Elster certificate has to be provided via environment variables `CERTIFICATE_PATH` and `CERTIFICATE_PASSWORD`. + +### Supported Eric versions + +| Rust SDK | Eric | +| -------- | -------- | +| 0.1.0 | 38.1.6.0 | + +### Test SDK + +``` bash +# Run unit tests +cargo test -p eric-sdk -- --test-threads=1 + +# Run integration tests +cargo test -p eric-sdk --test '*' -- --test-threads=1 + +# Run external tests +cargo test -p eric-sdk --test '*' --features external-test -- --test-threads=1 +``` + +## Changelog + +The `eric-rs` repository contains multiple crates with separate changelogs: + +- `eric-bindings`: [view changelog](https://github.com/quambene/eric-rs/blob/main/eric-bindings/CHANGELOG.md) +- `eric-sdk`: [view changelog](https://github.com/quambene/eric-rs/blob/main/eric-sdk/CHANGELOG.md) diff --git a/CHANGELOG.md b/eric-bindings/CHANGELOG.md similarity index 87% rename from CHANGELOG.md rename to eric-bindings/CHANGELOG.md index b17d12e..acd720d 100644 --- a/CHANGELOG.md +++ b/eric-bindings/CHANGELOG.md @@ -4,6 +4,7 @@ - added - changed + - Rename feature from `docs-rs` to `no-build` - removed ## v0.1.2 (2024-08-03) diff --git a/eric-bindings/Cargo.toml b/eric-bindings/Cargo.toml index d25490a..d3b3591 100644 --- a/eric-bindings/Cargo.toml +++ b/eric-bindings/Cargo.toml @@ -8,19 +8,19 @@ license.workspace = true homepage.workspace = true repository.workspace = true description = "Rust bindings for the ELSTER Rich Client (ERiC)" -documentation = "https://docs.rs/eric_bindings" +documentation = "https://docs.rs/eric-bindings" keywords = ["eric", "bindings", "taxes", "accounting"] categories = ["external-ffi-bindings"] build = "build.rs" -exclude = ["src/bindings/bindings_eric_38_1_6_0_linux_x86_64.rs"] +exclude = ["src/bindings/bindings_eric_39_6_4_0_linux_x86_64.rs"] [package.metadata.docs.rs] -features = ["docs-rs"] +features = ["no-build"] [features] # This feature is used to publish the documentation for `eric-bindings`. -docs-rs = [] +no-build = [] [lib] path = "src/lib.rs" diff --git a/eric-bindings/build.rs b/eric-bindings/build.rs index b3a0f9d..88c57fe 100644 --- a/eric-bindings/build.rs +++ b/eric-bindings/build.rs @@ -1,7 +1,7 @@ use std::io; fn main() -> io::Result<()> { - #[cfg(not(feature = "docs-rs"))] + #[cfg(not(feature = "no-build"))] { use std::{ env, diff --git a/eric-bindings/src/bindings/mod.rs b/eric-bindings/src/bindings/mod.rs index a2cf120..b304d13 100644 --- a/eric-bindings/src/bindings/mod.rs +++ b/eric-bindings/src/bindings/mod.rs @@ -1 +1 @@ -pub mod bindings_eric_39_6_4_0_linux_x86_64; +pub mod bindings_eric_38_1_6_0_linux_x86_64; diff --git a/eric-bindings/src/lib.rs b/eric-bindings/src/lib.rs index 78d8881..5990b08 100644 --- a/eric-bindings/src/lib.rs +++ b/eric-bindings/src/lib.rs @@ -5,12 +5,12 @@ // TODO: extern block uses type u128, which is not FFI-safe #![allow(improper_ctypes)] -#[cfg(feature = "docs-rs")] +#[cfg(feature = "no-build")] mod bindings; -#[cfg(feature = "docs-rs")] -pub use bindings::bindings_eric_39_6_4_0_linux_x86_64::*; +#[cfg(feature = "no-build")] +pub use bindings::bindings_eric_38_1_6_0_linux_x86_64::*; -#[cfg(not(feature = "docs-rs"))] +#[cfg(not(feature = "no-build"))] include!(concat!(env!("OUT_DIR"), "/bindings.rs")); #[cfg(test)] diff --git a/eric-sdk/CHANGELOG.md b/eric-sdk/CHANGELOG.md new file mode 100644 index 0000000..c39dfd8 --- /dev/null +++ b/eric-sdk/CHANGELOG.md @@ -0,0 +1,13 @@ + + +## Unreleased + +- added +- changed +- removed + +## v0.1.0 (2024-08-04) + +- added + - Validate and send xml + - Support Eric v38.1.6.0 diff --git a/eric-sdk/Cargo.toml b/eric-sdk/Cargo.toml index 64e8fd4..b05ccfa 100644 --- a/eric-sdk/Cargo.toml +++ b/eric-sdk/Cargo.toml @@ -3,11 +3,29 @@ name = "eric-sdk" version = "0.1.0" authors.workspace = true edition.workspace = true +readme.workspace = true +license.workspace = true +homepage.workspace = true +repository.workspace = true +description = "Rust SDK for the ELSTER Rich Client (ERiC)" +documentation = "https://docs.rs/eric-sdk" +keywords = ["eric", "sdk", "taxes", "accounting"] +categories = ["finance"] [lib] path = "src/lib.rs" name = "eric_sdk" +[package.metadata.docs.rs] +features = ["eric-bindings-no-build"] + +[features] +eric-bindings-no-build = ["eric-bindings/no-build"] +external-test = [] + [dependencies] +eric-bindings = { version = "0.1.2", path = "../eric-bindings" } +anyhow = { workspace = true } [dev-dependencies] +roxmltree = "0.20.0" diff --git a/eric-sdk/src/certificate.rs b/eric-sdk/src/certificate.rs new file mode 100644 index 0000000..3fcff1e --- /dev/null +++ b/eric-sdk/src/certificate.rs @@ -0,0 +1,42 @@ +use crate::error_code::ErrorCode; +use anyhow::anyhow; +use eric_bindings::{EricCloseHandleToCertificate, EricGetHandleToCertificate}; +use std::{ffi::CStr, ptr}; + +pub struct Certificate { + pub handle: u32, +} + +impl Certificate { + pub fn new(path: &CStr) -> Result { + println!("Preparing certificate '{}'", path.to_str()?); + + let mut handle = 0; + let pin_support = ptr::null::() as *mut u32; + + // SAFETY: path.as_ptr() is not dangling as path is allocated in struct CertificateConfig and path is not moved as a reference to the CString is given + let error_code = + unsafe { EricGetHandleToCertificate(&mut handle, pin_support, path.as_ptr()) }; + + match error_code { + x if x == ErrorCode::ERIC_OK as i32 => Ok(Certificate { handle }), + error_code => Err(anyhow!("Can't create certificate: {}", error_code)), + } + } + + // TODO: check validity of certificate + // unsafe { EricHoleZertifikatseigenschaften() } +} + +impl Drop for Certificate { + fn drop(&mut self) { + println!("Cleaning up certificate"); + + let error_code = unsafe { EricCloseHandleToCertificate(self.handle) }; + + match error_code { + x if x == ErrorCode::ERIC_OK as i32 => (), + error_code => panic!("Can't drop certificate handle: {}", error_code), + } + } +} diff --git a/eric-sdk/src/config.rs b/eric-sdk/src/config.rs new file mode 100644 index 0000000..782b76f --- /dev/null +++ b/eric-sdk/src/config.rs @@ -0,0 +1,113 @@ +use crate::{certificate::Certificate, utils::ToCString, Preview, ProcessingFlag}; +use eric_bindings::{eric_druck_parameter_t, eric_verschluesselungs_parameter_t}; +use std::{ + ffi::{CStr, CString}, + path::Path, + ptr, +}; + +pub struct CertificateConfig { + // allocate path as CString + _path: CString, + // allocate password as CString + pub(crate) password: CString, + pub(crate) certificate: Certificate, + pub(crate) certificate_parameter: CertificateParameter, +} + +impl CertificateConfig { + pub fn new(path: &str, password: &str) -> Result { + let path = Path::new(path).try_to_cstring()?; + let password = password.try_to_cstring()?; + let certificate = Certificate::new(&path)?; + let certificate_parameter = CertificateParameter::new(&certificate, &password); + + Ok(Self { + _path: path, + password, + certificate, + certificate_parameter, + }) + } +} + +// CertificateParameter is a wrapper type to keep C memory alignment for eric_verschluesselungs_parameter_t +#[derive(Debug)] +#[repr(C)] +pub(crate) struct CertificateParameter { + inner: eric_verschluesselungs_parameter_t, +} + +impl CertificateParameter { + pub(crate) fn new(certificate: &Certificate, password: &CStr) -> Self { + let certificate_parameter = eric_verschluesselungs_parameter_t { + abrufCode: ptr::null(), + // SAFETY: password.as_ptr() is not dangling as password is allocated in struct CertificateConfig and password is not moved as a reference to the CString is given + pin: password.as_ptr(), + version: 2, + zertifikatHandle: certificate.handle, + }; + + Self { + inner: certificate_parameter, + } + } + + pub fn as_ptr(&self) -> *const eric_verschluesselungs_parameter_t { + &self.inner + } +} + +#[derive(Debug)] +pub struct PrintConfig { + // allocate pdf path as CString + pub(crate) pdf_path: CString, + pub(crate) print_parameter: PrintParameter, +} + +impl PrintConfig { + pub fn new(pdf_path: &str, processing_flag: &ProcessingFlag) -> Result { + let pdf_path = Path::new(pdf_path).try_to_cstring()?; + let print_parameter = PrintParameter::new(&pdf_path, processing_flag); + + Ok(Self { + pdf_path, + print_parameter, + }) + } +} + +// PrintParameter is a wrapper type to keep C memory alignment for eric_druck_parameter_t +#[derive(Debug)] +#[repr(C)] +pub(crate) struct PrintParameter { + inner: eric_druck_parameter_t, +} + +impl PrintParameter { + pub(crate) fn new(pdf_path: &CStr, processing_flag: &ProcessingFlag) -> Self { + let print_parameter = eric_druck_parameter_t { + version: 2, + vorschau: match processing_flag { + ProcessingFlag::Validate => Preview::Yes as u32, + ProcessingFlag::Print => Preview::Yes as u32, + _ => Preview::No as u32, + }, + ersteSeite: 0, + duplexDruck: 0, + // SAFETY: pdf_path.as_ptr() is not dangling as pdf_path is + // allocated in struct PrintConfig and pdf_path is not moved as a + // reference to the CString is given. + pdfName: pdf_path.as_ptr(), + fussText: ptr::null(), + }; + + Self { + inner: print_parameter, + } + } + + pub fn as_ptr(&self) -> *const eric_druck_parameter_t { + &self.inner + } +} diff --git a/eric-sdk/src/eric.rs b/eric-sdk/src/eric.rs new file mode 100644 index 0000000..52d798e --- /dev/null +++ b/eric-sdk/src/eric.rs @@ -0,0 +1,224 @@ +use crate::{ + config::{CertificateConfig, PrintConfig}, + error_code::ErrorCode, + response::{EricResponse, ResponseBuffer}, + utils::ToCString, + ProcessingFlag, +}; +use anyhow::{anyhow, Context}; +use eric_bindings::{EricBearbeiteVorgang, EricBeende, EricDekodiereDaten, EricInitialisiere}; +use std::{ + env::{self}, + path::Path, + ptr, +}; + +/// A structure to manage the Eric instance from the shared C library. +/// +/// Use [`Eric::new`] to initialize Eric. Closes Eric when dropped. +pub struct Eric; + +impl Eric { + /// Initializes a single-threaded eric instance. + pub fn new(log_path: &Path) -> Result { + println!("Initializing eric"); + + let plugin_path = + env::var("PLUGIN_PATH").context("Missing environment variable 'PLUGIN_PATH'")?; + let plugin_path = Path::new(&plugin_path); + + println!("Setting plugin path '{}'", plugin_path.display()); + println!("Setting log path '{}'", log_path.display()); + println!("Logging to '{}'", log_path.join("eric.log").display()); + + let plugin_path = plugin_path.try_to_cstring()?; + let log_path = log_path.try_to_cstring()?; + + let error_code = unsafe { EricInitialisiere(plugin_path.as_ptr(), log_path.as_ptr()) }; + + match error_code { + x if x == ErrorCode::ERIC_OK as i32 => Ok(Eric), + error_code => Err(anyhow!("Can't init eric: {}", error_code)), + } + } + + /// Validates an XML file for a specific taxonomy. + /// + /// Optionally, a confirmation is printed to `pdf_path`. + pub fn validate( + &self, + xml: String, + taxonomy_type: &str, + taxonomy_version: &str, + pdf_path: Option<&str>, + ) -> Result { + let processing_flag: ProcessingFlag; + let type_version = format!("{}_{}", taxonomy_type, taxonomy_version); + let print_config = if let Some(pdf_path) = pdf_path { + processing_flag = ProcessingFlag::Print; + Some(PrintConfig::new(pdf_path, &processing_flag)?) + } else { + processing_flag = ProcessingFlag::Validate; + None + }; + Self::process(xml, type_version, processing_flag, print_config, None, None) + } + + /// Sends an XML file for a specific taxonomy to the tax authorities. + /// + /// The Elster certificate is provided via environment variables + /// `CERTIFICATE_PATH` and `CERTIFICATE_PASSWORD`. + /// + /// Optionally, a confirmation is printed to `pdf_path`. + pub fn send( + &self, + xml: String, + taxonomy_type: &str, + taxonomy_version: &str, + pdf_path: Option<&str>, + ) -> Result { + let certificate_path = env::var("CERTIFICATE_PATH") + .context("Missing environment variable 'CERTIFICATE_PATH'")?; + let certificate_password = env::var("CERTIFICATE_PASSWORD") + .context("Missing environment variable 'CERTIFICATE_PASSWORD'")?; + + let processing_flag: ProcessingFlag; + let type_version = format!("{}_{}", taxonomy_type, taxonomy_version); + let print_config = if let Some(pdf_path) = pdf_path { + processing_flag = ProcessingFlag::SendAndPrint; + Some(PrintConfig::new(pdf_path, &processing_flag)?) + } else { + processing_flag = ProcessingFlag::Send; + None + }; + let certificate_config = CertificateConfig::new(&certificate_path, &certificate_password)?; + Self::process( + xml, + type_version, + processing_flag, + print_config, + Some(certificate_config), + None, + ) + } + + #[allow(dead_code)] + fn decrypt( + &self, + encrypted_file: &str, + certificate_config: CertificateConfig, + ) -> Result { + let encrypted_data = encrypted_file.try_to_cstring()?; + let response_buffer = ResponseBuffer::new()?; + + let error_code = unsafe { + EricDekodiereDaten( + certificate_config.certificate.handle, + certificate_config.password.as_ptr(), + encrypted_data.as_ptr(), + response_buffer.as_ptr(), + ) + }; + + Ok(error_code) + } + + fn process( + xml: String, + type_version: String, + processing_flag: ProcessingFlag, + print_config: Option, + certificate_config: Option, + transfer_code: Option, + ) -> Result { + println!("Processing xml file"); + + match processing_flag { + ProcessingFlag::Validate => println!("Validating xml file"), + ProcessingFlag::Print => println!("Validating xml file"), + ProcessingFlag::Send => println!("Sending xml file"), + ProcessingFlag::SendAndPrint => println!("Send and print"), + ProcessingFlag::CheckHints => println!("Check hints"), + } + + let xml = xml.try_to_cstring()?; + let type_version = type_version.try_to_cstring()?; + + // Transfer_code should be NULL except for data retrieval; if + // transfer_code is not NULL in the other cases, it will be ignored + let transfer_code = match transfer_code { + Some(mut code) => &mut code, + None => ptr::null::() as *mut u32, + }; + + match &print_config { + Some(print_config) => println!( + "Printing confirmation to file '{}'", + print_config.pdf_path.to_str()? + ), + None => (), + } + + let validation_response_buffer = ResponseBuffer::new()?; + let server_response_buffer = ResponseBuffer::new()?; + + let error_code = unsafe { + EricBearbeiteVorgang( + xml.as_ptr(), + type_version.as_ptr(), + processing_flag.into_u32(), + // SAFETY: match a reference of print_config; otherwise + // print_config is moved, and print_parameter.as_ptr() would be + // dangling + match &print_config { + Some(el) => el.print_parameter.as_ptr(), + None => ptr::null(), + }, + // SAFETY: match a reference of certificate_config; otherwise + // certificate_config is moved, and + // certificate_parameter.as_ptr() would be dangling + match &certificate_config { + Some(el) => el.certificate_parameter.as_ptr(), + None => ptr::null(), + }, + transfer_code, + validation_response_buffer.as_ptr(), + server_response_buffer.as_ptr(), + ) + }; + + // TODO: EricHoleFehlerText() for error code + + let transfer_code = unsafe { transfer_code.as_ref() }; + + if let Some(code) = transfer_code { + println!("Transfer code: {}", code) + } + + let validation_response = validation_response_buffer.read()?; + // TODO: parse server response via EricGetErrormessagesFromXMLAnswer() + let server_response = server_response_buffer.read()?; + let response = EricResponse::new( + error_code, + validation_response.to_string(), + server_response.to_string(), + ); + + Ok(response) + } +} + +impl Drop for Eric { + fn drop(&mut self) { + println!("Closing eric"); + + // TODO: implement EricEntladePlugins + + let error_code = unsafe { EricBeende() }; + + match error_code { + x if x == ErrorCode::ERIC_OK as i32 => (), + error_code => panic!("Can't close eric: {}", error_code), + } + } +} diff --git a/eric-sdk/src/error_code.rs b/eric-sdk/src/error_code.rs new file mode 100644 index 0000000..170de50 --- /dev/null +++ b/eric-sdk/src/error_code.rs @@ -0,0 +1,1084 @@ +#![allow(non_camel_case_types)] + +/// Represents the available error codes. +pub enum ErrorCode { + /** + * [0] Verarbeitung fehlerfrei. + */ + ERIC_OK = 0, + + /** + * [610001001] Verarbeitung fehlerhaft, keine genaueren Informationen vorhanden. Details stehen ggf. im Logfile (eric.log). + */ + ERIC_GLOBAL_UNKNOWN = 610001001, + + /** + * [610001002] Fehler während der Plausibilitätsprüfung, Datensatz nicht plausibel. Zur Ermittlung der fehlgeschlagenen Plausibiltätsprüfungen muss der Rückgabepuffer (Parameter "rueckgabeXmlPuffer") ausgewertet werden. + */ + ERIC_GLOBAL_PRUEF_FEHLER = 610001002, + + /** + * [610001003] Hinweise während der Plausibilitätsprüfung, Datensatz ist aber plausibel. Zur Ermittlung der anzuzeigenden Hinweise muss der Rückgabepuffer (Parameter "rueckgabeXmlPuffer") ausgewertet werden. + */ + ERIC_GLOBAL_HINWEISE = 610001003, + + /** + * [610001007] Keine Klartextfehlermeldung vorhanden. + */ + ERIC_GLOBAL_FEHLERMELDUNG_NICHT_VORHANDEN = 610001007, + + /* + * [610001008] Für den übergebenen Wert sind keine Daten vorhanden. + */ + ERIC_GLOBAL_KEINE_DATEN_VORHANDEN = 610001008, + + /** + * [610001013] Es ist nicht genügend Arbeitsspeicher vorhanden. + */ + ERIC_GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER = 610001013, + + /** + * [610001014] Datei nicht gefunden. + */ + ERIC_GLOBAL_DATEI_NICHT_GEFUNDEN = 610001014, + + /** + * [610001016] Für dieses Verfahren/diese Datenart ist eine Bearbeitung mit der angegebenen HerstellerID nicht erlaubt. + */ + ERIC_GLOBAL_HERSTELLER_ID_NICHT_ERLAUBT = 610001016, + + /** + * [610001017] Ungültiger Zustand. + */ + ERIC_GLOBAL_ILLEGAL_STATE = 610001017, + + /** + * [610001018] Die aufgerufene Funktion ist nicht erlaubt. + */ + ERIC_GLOBAL_FUNKTION_NICHT_ERLAUBT = 610001018, + + /** + * [610001019] Für dieses Verfahren/diese Datenart/diese Test-HerstellerID/diese ERiC-Einstellungen sind Echtfälle nicht erlaubt. + */ + ERIC_GLOBAL_ECHTFALL_NICHT_ERLAUBT = 610001019, + + /** + * [610001020] Der Versand von Echtfällen (= Fällen ohne gesetzten Testmerker) ist mit einer BETA-Version nicht möglich. + */ + ERIC_GLOBAL_NO_VERSAND_IN_BETA_VERSION = 610001020, + + /** + * [610001025] Der übergebene Testmerker ist für das angegebene Verfahren nicht zulässig. + */ + ERIC_GLOBAL_TESTMERKER_UNGUELTIG = 610001025, + + /** + * [610001026] Der zu versendende Datensatz ist zu groß. + */ + ERIC_GLOBAL_DATENSATZ_ZU_GROSS = 610001026, + + /** + * [610001027] Der Verschlüsselungsparameter darf nur bei authentifiziertem Versand angegeben werden. + */ + ERIC_GLOBAL_VERSCHLUESSELUNGS_PARAMETER_NICHT_ERLAUBT = 610001027, + + /** + * [610001028] Bei der angegebenen Versandart sind nur Portal-Zertifikate erlaubt. + */ + ERIC_GLOBAL_NUR_PORTALZERTIFIKAT_ERLAUBT = 610001028, + + /** + * [610001029] Für die übermittelte Datenart ist die Angabe eines Abrufcodes nicht zulässig, daher muss für den Abrufcode der Wert NULL übergeben werden. + */ + ERIC_GLOBAL_ABRUFCODE_NICHT_ERLAUBT = 610001029, + + /** + * [610001030] Es ist ein Fehler bei der Umwandlung nach XML aufgetreten. + */ + ERIC_GLOBAL_ERROR_XML_CREATE = 610001030, + + /** + * [610001031] Die Größe des Textpuffers kann nicht verändert werden. + */ + ERIC_GLOBAL_TEXTPUFFERGROESSE_FIX = 610001031, + + /** + * [610001032] Interner Fehler aufgetreten. Details stehen ggf. im Logfile (eric.log). + */ + ERIC_GLOBAL_INTERNER_FEHLER = 610001032, + + /** + * [610001033] Bei einer arithmetischen Operation ist ein Fehler aufgetreten. Details stehen im Logile (eric.log) + */ + ERIC_GLOBAL_ARITHMETIKFEHLER = 610001033, + + /** + * [610001034] Ungültige Steuernummer. + */ + ERIC_GLOBAL_STEUERNUMMER_UNGUELTIG = 610001034, + + /** + * [610001035] Ungültige Steuernummer: Es werden 13 Stellen erwartet. + */ + ERIC_GLOBAL_STEUERNUMMER_FALSCHE_LAENGE = 610001035, + + /** + * [610001036] Ungültige Steuernummer: Es werden nur Ziffern erwartet. + */ + ERIC_GLOBAL_STEUERNUMMER_NICHT_NUMERISCH = 610001036, + + /** + * [610001037] Ungültige Landesnummer. + */ + ERIC_GLOBAL_LANDESNUMMER_UNBEKANNT = 610001037, + + /** + * [610001038] Ungültige Bundesfinanzamtsnummer. + */ + ERIC_GLOBAL_BUFANR_UNBEKANNT = 610001038, + + /** + * [610001039] Ungültige Bundesfinanzamtsnummer. + */ + ERIC_GLOBAL_LANDESNUMMER_BUFANR = 610001039, + + /** + * [610001040] Ein Puffer-Handle wurde mehrfach übergeben. + */ + ERIC_GLOBAL_PUFFER_ZUGRIFFSKONFLIKT = 610001040, + + /** + * [610001041] Es wurde versucht, einen Puffer über die maximal mögliche Länge hinaus zu beschreiben. + */ + ERIC_GLOBAL_PUFFER_UEBERLAUF = 610001041, + + /** + * [610001042] Die übergebene Datenartversion ist unbekannt. Beachten Sie bitte, dass die Datenartversion case-sensitive ist. + */ + ERIC_GLOBAL_DATENARTVERSION_UNBEKANNT = 610001042, + + /** + * [610001044] Die übergebene Datenartversion passt nicht zum Eingangs-XML. Details stehen ggf. im Logfile (eric.log). + */ + ERIC_GLOBAL_DATENARTVERSION_XML_INKONSISTENT = 610001044, + + /** + * [610001045] Das Plugin 'commonData' konnte nicht geladen werden oder bietet einen benötigten Service nicht an. Details stehen im Logfile (eric.log). + */ + ERIC_GLOBAL_COMMONDATA_NICHT_VERFUEGBAR = 610001045, + + /** + * [610001046] Beim Schreiben in die Protokolldatei ist eine Ausnahme aufgetreten. + */ + ERIC_GLOBAL_LOG_EXCEPTION = 610001046, + + /** + * [610001047] Für diese Datenart darf im TransferHeader kein TransportSchluessel angegeben werden. + */ + ERIC_GLOBAL_TRANSPORTSCHLUESSEL_NICHT_ERLAUBT = 610001047, + + /** + * [610001048] Der übergebene öffentliche Schlüssel kann nicht eingelesen werden. + */ + ERIC_GLOBAL_OEFFENTLICHER_SCHLUESSEL_UNGUELTIG = 610001048, + + /** + * [610001049] Der Typ des im TransferHeader angegebenen Transportschlüssels ist für diese Datenart nicht erlaubt. + */ + ERIC_GLOBAL_TRANSPORTSCHLUESSEL_TYP_FALSCH = 610001049, + + /** + * [610001050] Das übergebene Puffer-Handle wurde nicht mit der vorliegenden Instanz erzeugt. + */ + ERIC_GLOBAL_PUFFER_UNGLEICHER_INSTANZ = 610001050, + + /** + * [610001051] Das Element "Vorsatz" enthält ungültige Werte, Details stehen im Logfile (eric.log). + */ + ERIC_GLOBAL_VORSATZ_UNGUELTIG = 610001051, + + /** + * [610001053] Auf eine Datei konnte nicht in gewünschter Weise zugegriffen werden. Details stehen im Logile (eric.log) + */ + ERIC_GLOBAL_DATEIZUGRIFF_VERWEIGERT = 610001053, + + /** + * [610001080] Die übergebene Instanz ist gleich NULL oder bereits freigegeben worden. + */ + ERIC_GLOBAL_UNGUELTIGE_INSTANZ = 610001080, + + /** + * [610001081] Der Singlethread-ERiC wurde nicht mit EricInitialisiere initialisiert. + */ + ERIC_GLOBAL_NICHT_INITIALISIERT = 610001081, + + /** + * [610001082] Der Singlethread-ERiC wurde bereits mit EricInitialisiere initialisiert. + */ + ERIC_GLOBAL_MEHRFACHE_INITIALISIERUNG = 610001082, + + /** + * [610001083] Der angeforderte ERiC-Instanz konnte nicht erstellt werden. Details stehen ggf. im Logfile (eric.log). + */ + ERIC_GLOBAL_FEHLER_INITIALISIERUNG = 610001083, + + /** + * [610001102] Unbekannter Parameterfehler. + */ + ERIC_GLOBAL_UNKNOWN_PARAMETER_ERROR = 610001102, + + /** + * [610001108] Defekter Nutzdatensatz. + */ + ERIC_GLOBAL_CHECK_CORRUPTED_NDS = 610001108, + + /** + * [610001206] Verschlüsselter/authentifizierter Versand gewünscht, aber keine notwendigen Verschlüsselungsparameter angegeben. + */ + ERIC_GLOBAL_VERSCHLUESSELUNGS_PARAMETER_NICHT_ANGEGEBEN = 610001206, + + /** + * [610001209] Es ist mehr als ein Versandflag angegeben. + */ + ERIC_GLOBAL_SEND_FLAG_MEHR_ALS_EINES = 610001209, + + /** + * [610001218] Die übergebene Kombination von Bearbeitungsflags ist nicht erlaubt. + */ + ERIC_GLOBAL_UNGUELTIGE_FLAG_KOMBINATION = 610001218, + + /** + * [610001220] Der Erste-Seite-Druck ist nur für Steuerberater bei nicht-authentifizierten Einkommenssteuerfällen ab Veranlagungszeitraum 2010 ohne Versandanforderung erlaubt. + */ + ERIC_GLOBAL_ERSTE_SEITE_DRUCK_NICHT_UNTERSTUETZT = 610001220, + + /** + * [610001222] Die angegebenen Parameter sind ungültig oder unvollständig. + */ + ERIC_GLOBAL_UNGUELTIGER_PARAMETER = 610001222, + + /** + * [610001224] Für das angegebene Verfahren wird der Druck nicht unterstützt. + */ + ERIC_GLOBAL_DRUCK_FUER_VERFAHREN_NICHT_ERLAUBT = 610001224, + + /** + * [610001225] Die Versandart ist für die angegebene Datenartversion nicht erlaubt. + */ + ERIC_GLOBAL_VERSAND_ART_NICHT_UNTERSTUETZT = 610001225, + + /** + * [610001226] Die Version eines der angegebenen Parameter ist ungültig. + */ + ERIC_GLOBAL_UNGUELTIGE_PARAMETER_VERSION = 610001226, + + /** + * [610001227] Für das Verfahren Datenabholung wurde ein illegales Transferhandle angegeben. + */ + ERIC_GLOBAL_TRANSFERHANDLE = 610001227, + + /** + * [610001228] Die Initialisierung eines Plugins ist fehlgeschlagen. + */ + ERIC_GLOBAL_PLUGININITIALISIERUNG = 610001228, + + /** + * [610001229] Die Versionen der im Logfile genannten ERiC-Dateien sind nicht kompatibel. (Siehe eric.log.) + */ + ERIC_GLOBAL_INKOMPATIBLE_VERSIONEN = 610001229, + + /** + * [610001230] Das im XML-Element "" angegebene Verschlüsselungsverfahren wird vom ERiC nicht unterstützt. + */ + ERIC_GLOBAL_VERSCHLUESSELUNGSVERFAHREN_NICHT_UNTERSTUETZT = 610001230, + + /** + * [610001231] Der Aufruf eine API-Funktion des ERiCs darf erst dann erfolgen, wenn ein vorheriger Aufruf zurückgekehrt ist. + */ + ERIC_GLOBAL_MEHRFACHAUFRUFE_NICHT_UNTERSTUETZT = 610001231, + + /** + * [610001404] Das Bundesland/Finanzamt mit der angegebenen Nummer nimmt bei der angegebenen Steuerart am ELSTER-Verfahren nicht teil. + */ + ERIC_GLOBAL_UTI_COUNTRY_NOT_SUPPORTED = 610001404, + + /** + * [610001501] Ungültige IBAN: IBAN muss aus zweistelligem Ländercode gefolgt von zweistelliger Prüfziffer gefolgt von der Basic Bank Account Number bestehen. + */ + ERIC_GLOBAL_IBAN_FORMALER_FEHLER = 610001501, + + /** + * [610001502] Ungültige IBAN: Der angegebene Ländercode ist ungültig oder wird aktuell im ELSTER-Verfahren nicht unterstützt. + */ + ERIC_GLOBAL_IBAN_LAENDERCODE_FEHLER = 610001502, + + /** + * [610001503] Ungültige IBAN: Die angegebene IBAN entspricht nicht dem für das angegebene Land definierten formalen Aufbau der IBAN oder die IBAN ist unzulässig. + */ + ERIC_GLOBAL_IBAN_LANDESFORMAT_FEHLER = 610001503, + + /** + * [610001504] Ungültige IBAN: Die Prüfziffernberechnung zur angegebenen IBAN führt zu einer abweichenden Prüfziffer. + */ + ERIC_GLOBAL_IBAN_PRUEFZIFFER_FEHLER = 610001504, + + /** + * [610001510] Ungültiger BIC: Der formale Aufbau des angegeben BIC ist ungültig. + */ + ERIC_GLOBAL_BIC_FORMALER_FEHLER = 610001510, + + /** + * [610001511] Ungültiger BIC: Der angegebene Ländercode ist ungültig oder wird aktuell im ELSTER-Verfahren nicht unterstützt. + */ + ERIC_GLOBAL_BIC_LAENDERCODE_FEHLER = 610001511, + + /** + * [610001519] Die angegebene Zulassungsnummer entspricht nicht den Längenvorgaben. Es sind maximal 6 Stellen erlaubt. + */ + ERIC_GLOBAL_ZULASSUNGSNUMMER_ZU_LANG = 610001519, + + /** + * [610001525] Die übergebene IDNummer ist ungültig. + */ + ERIC_GLOBAL_IDNUMMER_UNGUELTIG = 610001525, + + /** + * [610001526] Es wurde der Parameter NULL übergeben. + */ + ERIC_GLOBAL_NULL_PARAMETER = 610001526, + + /** + * [610001527] Das übergebene Einheitswert-Aktenzeichen ist ungültig. + */ + ERIC_GLOBAL_EWAZ_UNGUELTIG = 610001527, + + /** + * [610001528] Das übergebene Landeskürzel ist unbekannt oder leer. + */ + ERIC_GLOBAL_EWAZ_LANDESKUERZEL_UNBEKANNT = 610001528, + + /** + * [610001851] Update des ERiC erforderlich. Starten Sie nun das Update. + */ + ERIC_GLOBAL_UPDATE_NECESSARY = 610001851, + + /** + * [610001860] Ungültiger Name für Einstellung. + */ + ERIC_GLOBAL_EINSTELLUNG_NAME_UNGUELTIG = 610001860, + + /** + * [610001861] Ungültiger Wert für Einstellung. + */ + ERIC_GLOBAL_EINSTELLUNG_WERT_UNGUELTIG = 610001861, + + /** + * [610001862] Fehler beim Dekodieren. + */ + ERIC_GLOBAL_ERR_DEKODIEREN = 610001862, + + /** + * [610001863] Die aufgerufene Funktion wird nicht unterstützt. + */ + ERIC_GLOBAL_FUNKTION_NICHT_UNTERSTUETZT = 610001863, + + /** + * [610001865] Fehler im übergebenen EDS-XML: In den Sammeldaten wurde ein Nutzdatenticket für mehrere Steuerfälle verwendet. Für jeden Steuerfall muss jedoch ein eigenes Nutzdatenticket angegeben werden. + */ + ERIC_GLOBAL_NUTZDATENTICKETS_NICHT_EINDEUTIG = 610001865, + + /** + * [610001866] Fehler im übergebenen EDS-XML: Bei den Sammeldaten wurden unterschiedliche Versionen des Nutzdaten-Headers verwendet. Innerhalb einer Datenlieferung ist jedoch nur eine Nutzdaten-Header-Version zulässig. + */ + ERIC_GLOBAL_NUTZDATENHEADERVERSIONEN_UNEINHEITLICH = 610001866, + + /** + * [610001867] Fehler im übergebenen EDS-XML: Es wurden Fälle für mehrere Bundesländer angegeben. Innerhalb einer Datenlieferung dürfen jedoch nur Fälle für ein Bundesland angegeben werden. + */ + ERIC_GLOBAL_BUNDESLAENDER_UNEINHEITLICH = 610001867, + + /** + * [610001868] Fehler im übergebenen EDS-XML: Es wurden Fälle für unterschiedliche Jahre angegeben. Innerhalb einer Datenlieferung dürfen jedoch nur Fälle für ein und dasselbe Jahr angegeben werden. + */ + ERIC_GLOBAL_ZEITRAEUME_UNEINHEITLICH = 610001868, + + /** + * [610001869] Fehler im übergebenen EDS-XML: Der Inhalt des Nutzdaten-Elements "" ist für diese Datenart nicht korrekt. + */ + ERIC_GLOBAL_NUTZDATENHEADER_EMPFAENGER_NICHT_KORREKT = 610001869, + + /** + * [610101200] Allgemeiner Kommunikationsfehler. + */ + ERIC_TRANSFER_COM_ERROR = 610101200, + + /** + * [610101201] Dieser Vorgang wird von der aufgerufenen Funktion nicht unterstützt. + */ + ERIC_TRANSFER_VORGANG_NICHT_UNTERSTUETZT = 610101201, + + /** + * [610101210] Fehler im Transferheader. Der ELSTER-Annahmeserver hat einen Fehler zurückgemeldet. Bitte werten Sie die Serverantwort aus. + */ + ERIC_TRANSFER_ERR_XML_THEADER = 610101210, + + /** + * [610101251] Es wurden ungültige Parameter übergeben. + */ + ERIC_TRANSFER_ERR_PARAM = 610101251, + + /** + * [610101253] Im XML-String konnte der Text "" nicht gefunden werden. + */ + ERIC_TRANSFER_ERR_DATENTEILENDNOTFOUND = 610101253, + + /** + * [610101255] Im XML-String konnte der Text "" nicht gefunden werden. + */ + ERIC_TRANSFER_ERR_BEGINDATENLIEFERANT = 610101255, + + /** + * [610101256] Im XML-String konnte der Text "" nicht gefunden werden. + */ + ERIC_TRANSFER_ERR_ENDDATENLIEFERANT = 610101256, + + /** + * [610101257] Im XML-String konnte der Text "" nicht gefunden werden. + */ + ERIC_TRANSFER_ERR_BEGINTRANSPORTSCHLUESSEL = 610101257, + + /** + * [610101258] Im XML-String konnte der Text "" nicht gefunden werden. + */ + ERIC_TRANSFER_ERR_ENDTRANSPORTSCHLUESSEL = 610101258, + + /** + * [610101259] Im XML-String konnte der Text "" nicht gefunden werden. + */ + ERIC_TRANSFER_ERR_BEGINDATENGROESSE = 610101259, + + /** + * [610101260] Im XML-String konnte der Text "" nicht gefunden werden. + */ + ERIC_TRANSFER_ERR_ENDDATENGROESSE = 610101260, + + /** + * [610101271] Beim Datenaustausch ist ein Fehler aufgetreten. + */ + ERIC_TRANSFER_ERR_SEND = 610101271, + + /** + * [610101274] Die Antwortdaten waren nicht PKCS#7-verschlüsselt. + */ + ERIC_TRANSFER_ERR_NOTENCRYPTED = 610101274, + + /** + * [610101276] Verbindung zum ProxyServer konnte nicht aufgebaut werden. + */ + ERIC_TRANSFER_ERR_PROXYCONNECT = 610101276, + + /** + * [610101278] Zu den Servern konnte keine Verbindung aufgebaut werden. + */ + ERIC_TRANSFER_ERR_CONNECTSERVER = 610101278, + + /** + * [610101279] Von der Clearingstelle konnte keine Antwort empfangen werden. + */ + ERIC_TRANSFER_ERR_NORESPONSE = 610101279, + + /** + * [610101280] Der Proxyserver erwartet Anmeldedaten. + */ + ERIC_TRANSFER_ERR_PROXYAUTH = 610101280, + + /** + * [610101282] Fehler bei der Initialisierung des Versands, Details stehen ggf. im Logfile (eric.log). + */ + ERIC_TRANSFER_ERR_SEND_INIT = 610101282, + + /** + * [610101283] Bei der Kommunikation mit dem Server kam es zu einer Zeitüberschreitung. + */ + ERIC_TRANSFER_ERR_TIMEOUT = 610101283, + + /** + * [610101284] Es wurde kein gültiger Port für den Proxy angegeben. + */ + ERIC_TRANSFER_ERR_PROXYPORT_INVALID = 610101284, + + /** + * [610101291] Sonstiger, nicht definierter Fehler aufgetreten. + */ + ERIC_TRANSFER_ERR_OTHER = 610101291, + + /** + * [610101292] Fehler im NutzdatenHeader. Der ELSTER-Annahmeserver hat einen Fehler zurückgemeldet. Bitte werten Sie die Serverantwort aus. Bei Sammeldaten sind alle Nutzdatenblöcke zu prüfen, um den fehlerhaften Datensatz identifizieren zu können. + */ + ERIC_TRANSFER_ERR_XML_NHEADER = 610101292, + + /** + * [610101293] Das XML liegt im falschen Encoding vor. + */ + ERIC_TRANSFER_ERR_XML_ENCODING = 610101293, + + /** + * [610101294] Im XML-String konnte der Text "" nicht gefunden werden. + */ + ERIC_TRANSFER_ERR_ENDSIGUSER = 610101294, + + /** + * [610101295] Im XML-String konnte ein Tag nicht gefunden werden. + */ + ERIC_TRANSFER_ERR_XMLTAG_NICHT_GEFUNDEN = 610101295, + + /** + * [610101297] Das XML-Element "" konnte nicht gelesen werden. + */ + ERIC_TRANSFER_ERR_DATENTEILFEHLER = 610101297, + + /** + * [610101500] Es konnte kein Ad Hoc-Zertifikat fuer den Personalausweis oder den Aufenthaltstitel erzeugt bzw. gefunden werden, Details stehen ggf. im Logfile (eric.log). + */ + ERIC_TRANSFER_EID_ZERTIFIKATFEHLER = 610101500, + + /** + * [610101510] Für die Identifikationsnummer des Benutzers existiert kein Konto bei ELSTER. + */ + ERIC_TRANSFER_EID_KEINKONTO = 610101510, + + /** + * [610101511] Dem Benutzer konnte keine eindeutige Identifikationsnummer zugeordnet werden. + */ + ERIC_TRANSFER_EID_IDNRNICHTEINDEUTIG = 610101511, + + /** + * [610101512] Das nPA-Servlet konnte keine Verbindung zum eID-Server aufbauen. + */ + ERIC_TRANSFER_EID_SERVERFEHLER = 610101512, + + /** + * [610101520] Der eID-Client ist nicht erreichbar. Wahrscheinlich wurde er nicht gestartet oder die übergebene lokale URL ist nicht korrekt + */ + ERIC_TRANSFER_EID_KEINCLIENT = 610101520, + + /** + * [610101521] Der eID-Client hat einen Fehler gemeldet. Details zu dem Fehler finden Sie im Log des eID-Clients oder ggf. im ERiC Logfile (eric.log). + */ + ERIC_TRANSFER_EID_CLIENTFEHLER = 610101521, + + /** + * [610101522] Es konnten nicht alle benötigten Datenfelder des Personalausweises ausgelesen werden. Bitte prüfen Sie über die Funktion "Selbstauskunft" des eID-Clients, ob folgende Daten von Ihrem Personalausweis korrekt bereitgestellt werden: Familienname, Vorname(n), Geburtsdatum, Anschrift (mit Postleitzahl) und Dokumentenart. + */ + ERIC_TRANSFER_EID_FEHLENDEFELDER = 610101522, + + /** + * [610101523] Das Auslesen der Daten aus dem Personalausweis wurde vom Anwender abgebrochen. + */ + ERIC_TRANSFER_EID_IDENTIFIKATIONABGEBROCHEN = 610101523, + + /** + * [610101524] Der Personalausweis wird von einem anderen Vorgang blockiert. Beenden Sie den anderen Vorgang und versuchen Sie es dann erneut. + */ + ERIC_TRANSFER_EID_NPABLOCKIERT = 610101524, + + /** + * [610201016] Fehler bei der Schlüsselerzeugung. + */ + ERIC_CRYPT_ERROR_CREATE_KEY = 610201016, + + /** + * [610201101] eSigner: Ungültiges Token Handle. + */ + ERIC_CRYPT_E_INVALID_HANDLE = 610201101, + + /** + * [610201102] eSigner: Zu viele Sessions geöffnet. + */ + ERIC_CRYPT_E_MAX_SESSION = 610201102, + + /** + * [610201103] eSigner: Überlastung. + */ + ERIC_CRYPT_E_BUSY = 610201103, + + /** + * [610201104] eSigner: Speicherzuordnungsfehler. + */ + ERIC_CRYPT_E_OUT_OF_MEM = 610201104, + + /** + * [610201105] eSigner: Ungültiger PSE Pfad. + */ + ERIC_CRYPT_E_PSE_PATH = 610201105, + + /** + * [610201106] eSigner: Es wurde ein falsches Passwort bzw. eine falsche PIN angegeben. + */ + ERIC_CRYPT_E_PIN_WRONG = 610201106, + + /** + * [610201107] eSigner: Das Passwort bzw. die PIN ist gesperrt. + */ + ERIC_CRYPT_E_PIN_LOCKED = 610201107, + + /** + * [610201108] eSigner: Fehler beim Lesen des PKCS#7-Objekts. + */ + ERIC_CRYPT_E_P7_READ = 610201108, + + /** + * [610201109] eSigner: Fehler beim PKCS#7 Dekodieren. + */ + ERIC_CRYPT_E_P7_DECODE = 610201109, + + /** + * [610201110] eSigner: Entschlüsselungszertifikat nicht in Empfängerliste enthalten. + */ + ERIC_CRYPT_E_P7_RECIPIENT = 610201110, + + /** + * [610201111] eSigner: Fehler beim Lesen des PKCS#12-Objekts. + */ + ERIC_CRYPT_E_P12_READ = 610201111, + + /** + * [610201112] eSigner: Fehler beim Dekodieren des PKCS#12-Objekts. + */ + ERIC_CRYPT_E_P12_DECODE = 610201112, + + /** + * [610201113] eSigner: Fehler beim Zugriff auf Soft-PSE-Signaturschlüssel. + */ + ERIC_CRYPT_E_P12_SIG_KEY = 610201113, + + /** + * [610201114] eSigner: Fehler beim Zugriff auf Soft-PSE Entschlüsselungsschlüssel. + */ + ERIC_CRYPT_E_P12_ENC_KEY = 610201114, + + /** + * [610201115] eSigner: Fehler beim Zugriff auf Hard-Token Signaturschlüssel. + */ + ERIC_CRYPT_E_P11_SIG_KEY = 610201115, + + /** + * [610201116] eSigner: Fehler beim Zugriff auf Hard-Token Entschlüsselungsschlüssel. + */ + ERIC_CRYPT_E_P11_ENC_KEY = 610201116, + + /** + * [610201117] eSigner: Fehler beim Parsen der XML-Eingabedatei. + */ + ERIC_CRYPT_E_XML_PARSE = 610201117, + + /** + * [610201118] eSigner: Fehler beim Erzeugen des XML-Signaturasts. + */ + ERIC_CRYPT_E_XML_SIG_ADD = 610201118, + + /** + * [610201119] eSigner: XML-Signaturtag nicht vorhanden. + */ + ERIC_CRYPT_E_XML_SIG_TAG = 610201119, + + /** + * [610201120] eSigner: Fehler bei XML-Signaturerzeugung. + */ + ERIC_CRYPT_E_XML_SIG_SIGN = 610201120, + + /** + * [610201121] eSigner: Parameter-Fehler, unbekanntes Encoding. + */ + ERIC_CRYPT_E_ENCODE_UNKNOWN = 610201121, + + /** + * [610201122] eSigner: Encoding-Fehler. + */ + ERIC_CRYPT_E_ENCODE_ERROR = 610201122, + + /** + * [610201123] eSigner: XML Initialisierungsfehler. + */ + ERIC_CRYPT_E_XML_INIT = 610201123, + + /** + * [610201124] eSigner: Fehler beim Verschlüsseln. + */ + ERIC_CRYPT_E_ENCRYPT = 610201124, + + /** + * [610201125] eSigner: Fehler beim Entschlüsseln. + */ + ERIC_CRYPT_E_DECRYPT = 610201125, + + /** + * [610201126] eSigner: Keine Signaturkarte eingesteckt (PKCS#11). + */ + ERIC_CRYPT_E_P11_SLOT_EMPTY = 610201126, + + /** + * [610201127] eSigner: Keine Signatur-/Verschlüsselungs-Zertifikate/-Schlüssel gefunden (PKCS#11). + */ + ERIC_CRYPT_E_NO_SIG_ENC_KEY = 610201127, + + /** + * [610201128] eSigner: PKCS11 bzw. PC/SC Library fehlt oder ist nicht ausführbar. + */ + ERIC_CRYPT_E_LOAD_DLL = 610201128, + + /** + * [610201129] eSigner: Der PC/SC Dienst ist nicht gestartet. + */ + ERIC_CRYPT_E_NO_SERVICE = 610201129, + + /** + * [610201130] eSigner: Unbekannte Ausnahme aufgetreten. + */ + ERIC_CRYPT_E_ESICL_EXCEPTION = 610201130, + + /** + * [610201144] eSigner: CA Tokentyp und interner Tokentyp stimmen nicht überein. + */ + ERIC_CRYPT_E_TOKEN_TYPE_MISMATCH = 610201144, + + /** + * [610201146] eSigner: Temporäres PKCS#12-Token kann nicht erzeugt werden. + */ + ERIC_CRYPT_E_P12_CREATE = 610201146, + + /** + * [610201147] eSigner: Zertifikatskette konnte nicht verifiziert werden. + */ + ERIC_CRYPT_E_VERIFY_CERT_CHAIN = 610201147, + + /** + * [610201148] eSigner: PKCS#11 Engine mit anderer Bibliothek belegt. + */ + ERIC_CRYPT_E_P11_ENGINE_LOADED = 610201148, + + /** + * [610201149] eSigner: Aktion vom Benutzer abgebrochen. + */ + ERIC_CRYPT_E_USER_CANCEL = 610201149, + + /** + * [610201200] Fehler beim Zugriff auf Zertifikat. + */ + ERIC_CRYPT_ZERTIFIKAT = 610201200, + + /** + * [610201201] Fehler bei Signaturerzeugung. + */ + ERIC_CRYPT_SIGNATUR = 610201201, + + /** + * [610201203] Das Format der PSE wird nicht unterstützt. + */ + ERIC_CRYPT_NICHT_UNTERSTUETZTES_PSE_FORMAT = 610201203, + + /** + * [610201205] Für die ausgewählte Operation muss ein Passwort bzw. eine PIN angegeben werden. + */ + ERIC_CRYPT_PIN_BENOETIGT = 610201205, + + /** + * [610201206] Das gewünschte Passwort ist nicht sicher genug (z.B. zu kurz). + */ + ERIC_CRYPT_PIN_STAERKE_NICHT_AUSREICHEND = 610201206, + + /** + * [610201208] Interner Fehler aufgetreten. Details stehen ggf. im Logfile (eric.log). + */ + ERIC_CRYPT_E_INTERN = 610201208, + + /** + * [610201209] Der angegebene Zertifikatspfad ist kein Verzeichnis. + */ + ERIC_CRYPT_ZERTIFIKATSPFAD_KEIN_VERZEICHNIS = 610201209, + + /** + * [610201210] Im angegebenen Verzeichnis existiert bereits ein Bestandteil eines ERiC-Zertifikats. + */ + ERIC_CRYPT_ZERTIFIKATSDATEI_EXISTIERT_BEREITS = 610201210, + + /** + * [610201211] Das gewünschte Passwort enthält ungültige Zeichen (z.B. Umlaute). + */ + ERIC_CRYPT_PIN_ENTHAELT_UNGUELTIGE_ZEICHEN = 610201211, + + /** + * [610201212] eSigner: Der Abrufcode besitzt eine falsche Struktur oder enthält ungültige Zeichen. + */ + ERIC_CRYPT_E_INVALID_PARAM_ABC = 610201212, + + /** + * [610201213] Das übergebene Zertifikat weist Inkonsistenzen auf und kann deswegen nicht verwendet werden. Bitte verwenden Sie ein anderes oder erzeugen und verwenden Sie ein neues Zertifikat. + */ + ERIC_CRYPT_CORRUPTED = 610201213, + + /** + * [610201214] Die aufgerufene Funktion unterstützt den neuen Personalausweis (nPA) und den elektronischen Aufenthaltstitel (eAT) nicht. + */ + ERIC_CRYPT_EIDKARTE_NICHT_UNTERSTUETZT = 610201214, + + /** + * [610201215] Es ist keine Karte/kein Stick eingesteckt + */ + ERIC_CRYPT_E_SC_SLOT_EMPTY = 610201215, + + /** + * [610201216] Kein unterstütztes Applet gefunden + */ + ERIC_CRYPT_E_SC_NO_APPLET = 610201216, + + /** + * [610201217] Fehler in der Kartensession + */ + ERIC_CRYPT_E_SC_SESSION = 610201217, + + /** + * [610201218] P11 Signaturzertifikat fehlt + */ + ERIC_CRYPT_E_P11_NO_SIG_CERT = 610201218, + + /** + * [610201219] P11 Der initiale Tokenzugriff ist fehlgeschlagen + */ + ERIC_CRYPT_E_P11_INIT_FAILED = 610201219, + + /** + * [610201220] P11 Verschlüsselungszertifikat fehlt + */ + ERIC_CRYPT_E_P11_NO_ENC_CERT = 610201220, + + /** + * [610201221] P12 Signaturzertifikat fehlt + */ + ERIC_CRYPT_E_P12_NO_SIG_CERT = 610201221, + + /** + * [610201222] P12 Verschlüsselungszertifikat fehlt + */ + ERIC_CRYPT_E_P12_NO_ENC_CERT = 610201222, + + /** + * [610201223] PC/SC Der Zugriff auf den Entschlüsselungsschlüssel ist fehlgeschlagen + */ + ERIC_CRYPT_E_SC_ENC_KEY = 610201223, + + /** + * [610201224] PC/SC Signaturzertifikat fehlt + */ + ERIC_CRYPT_E_SC_NO_SIG_CERT = 610201224, + + /** + * [610201225] PC/SC Verschlüsselungszertifikat fehlt + */ + ERIC_CRYPT_E_SC_NO_ENC_CERT = 610201225, + + /** + * [610201226] PC/SC Der initiale Tokenzugriff ist fehlgeschlagen + */ + ERIC_CRYPT_E_SC_INIT_FAILED = 610201226, + + /** + * [610201227] PC/SC Der Zugriff auf den Signaturschlüssel ist fehlgeschlagen + */ + ERIC_CRYPT_E_SC_SIG_KEY = 610201227, + + /** + * [610301001] Verarbeitung fehlerhaft, keine genaueren Informationen vorhanden. + */ + ERIC_IO_FEHLER = 610301001, + + /** + * [610301005] Der Dateiaufbau ist nicht korrekt. + */ + ERIC_IO_DATEI_INKORREKT = 610301005, + + /** + * [610301006] Fehler beim Parsen der Eingabedaten. Details stehen im Logfile (eric.log). + */ + ERIC_IO_PARSE_FEHLER = 610301006, + + /** + * [610301007] Die Generierung des Nutzdatensatzes ist fehlgeschlagen. + */ + ERIC_IO_NDS_GENERIERUNG_FEHLGESCHLAGEN = 610301007, + + /** + * [610301010] Interner Fehler, der Masterdatenservice ist nicht verfügbar. + */ + ERIC_IO_MASTERDATENSERVICE_NICHT_VERFUEGBAR = 610301010, + + /** + * [610301014] Es wurden ungültige Steuerzeichen im Nutzdatensatz gefunden. + */ + ERIC_IO_STEUERZEICHEN_IM_NDS = 610301014, + + /** + * [610301031] Die Versionsinformationen der ERiC-Bibliotheken konnten nicht ausgelesen werden. + */ + ERIC_IO_VERSIONSINFORMATIONEN_NICHT_GEFUNDEN = 610301031, + + /** + * [610301104] Der Wert im Transferheader-Element "Verfahren" wird vom verwendeten Reader nicht unterstützt. + */ + ERIC_IO_FALSCHES_VERFAHREN = 610301104, + + /** + * [610301105] Es wurde mehr als ein Steuerfall in der Eingabedatei gefunden. + */ + ERIC_IO_READER_MEHRFACHE_STEUERFAELLE = 610301105, + + /** + * [610301106] Es wurden unerwartete Elemente in der Eingabedatei gefunden, Details stehen ggf. im Logfile (eric.log). + */ + ERIC_IO_READER_UNERWARTETE_ELEMENTE = 610301106, + + /** + * [610301107] Es wurden formale Fehler in der Eingabedatei gefunden, Details stehen ggf. im Logfile (eric.log). + */ + ERIC_IO_READER_FORMALE_FEHLER = 610301107, + + /** + * [610301108] Die Eingabedaten lagen nicht im Encoding UTF-8 vor, oder es war kein Encoding spezifiziert. + */ + ERIC_IO_READER_FALSCHES_ENCODING = 610301108, + + /** + * [610301109] Es wurde mehr als ein "Nutzdaten"-Element in der Eingabedatei gefunden. + */ + ERIC_IO_READER_MEHRFACHE_NUTZDATEN_ELEMENTE = 610301109, + + /** + * [610301110] Es wurde mehr als ein Nutzdatenblock in der Eingabedatei gefunden. + */ + ERIC_IO_READER_MEHRFACHE_NUTZDATENBLOCK_ELEMENTE = 610301110, + + /** + * [610301111] Der im Transferheader-Element "Datenart" angegebene Wert ist unbekannt. + */ + ERIC_IO_UNBEKANNTE_DATENART = 610301111, + + /** + * [610301114] Ungültiger oder fehlender Wert für den Untersachbereich. + */ + ERIC_IO_READER_UNTERSACHBEREICH_UNGUELTIG = 610301114, + + /** + * [610301115] Es wurden zu viele Nutzdatenblöcke in der Eingabedatei gefunden. + */ + ERIC_IO_READER_ZU_VIELE_NUTZDATENBLOCK_ELEMENTE = 610301115, + + /** + * [610301150] Es wurden ungültige Steuerzeichen im TransferHeader-Element gefunden. + */ + ERIC_IO_READER_STEUERZEICHEN_IM_TRANSFERHEADER = 610301150, + + /** + * [610301151] Es wurden ungültige Steuerzeichen im NutzdatenHeader-Element gefunden. + */ + ERIC_IO_READER_STEUERZEICHEN_IM_NUTZDATENHEADER = 610301151, + + /** + * [610301152] Es wurden ungültige Steuerzeichen im Nutzdaten-Element gefunden. + */ + ERIC_IO_READER_STEUERZEICHEN_IN_DEN_NUTZDATEN = 610301152, + + /** + * [610301190] Ein Nutzdatenblock enthält zu viele Anhänge. Details stehen im Logfile (eric.log). + */ + ERIC_IO_READER_ZU_VIELE_ANHAENGE = 610301190, + + /** + * [610301191] Ein Anhang ist zu groß. Details stehen im Logfile (eric.log). + */ + ERIC_IO_READER_ANHANG_ZU_GROSS = 610301191, + + /** + * [610301192] Die Gesamtgröße aller Anhange in einem Nutzdatenblock ist zu groß. Details stehen im Logfile (eric.log). + */ + ERIC_IO_READER_ANHAENGE_ZU_GROSS = 610301192, + + /** + * [610301200] Es traten Fehler beim Validieren des XML auf. Details stehen im Logfile (eric.log). + */ + ERIC_IO_READER_SCHEMA_VALIDIERUNGSFEHLER = 610301200, + + /** + * [610301201] Eine XML-Entity konnte nicht aufgelöst werden. + */ + ERIC_IO_READER_UNBEKANNTE_XML_ENTITY = 610301201, + + /** + * [610301252] Im XML-String konnte der Text "" nicht gefunden werden. + */ + ERIC_IO_DATENTEILNOTFOUND = 610301252, + + /** + * [610301253] Im XML-String konnte der Text "" nicht gefunden werden. + */ + ERIC_IO_DATENTEILENDNOTFOUND = 610301253, + + /** + * [610301300] Falsche Übergabeparameter für die Funktion. + */ + ERIC_IO_UEBERGABEPARAMETER_FEHLERHAFT = 610301300, + + /** + * [610301400] Der Parameter enthält ungültige UTF-8 Multibytesequenzen. + */ + ERIC_IO_UNGUELTIGE_UTF8_SEQUENZ = 610301400, + + /** + * [610301401] Der Parameter enthält mindestens ein unzulässiges Zeichen. + */ + ERIC_IO_UNGUELTIGE_ZEICHEN_IN_PARAMETER = 610301401, + + /** + * [610501001] Verarbeitung fehlerhaft, keine genaueren Informationen vorhanden. + */ + ERIC_PRINT_INTERNER_FEHLER = 610501001, + + /** + * [610501002] Keine Druckvorlage für die angegebene Kombination aus Unterfallart und Veranlagungszeitraum gefunden. Bitte prüfen Sie die installierten Druckvorlagen. + */ + ERIC_PRINT_DRUCKVORLAGE_NICHT_GEFUNDEN = 610501002, + + /** + * [610501004] Es wurde ein falscher Dateipfad angegeben, es fehlen Zugriffsrechte oder die Datei wird aktuell von einer anderen Anwendung verwendet. + */ + ERIC_PRINT_UNGUELTIGER_DATEI_PFAD = 610501004, + + /** + * [610501007] ERiCPrint wurde nicht richtig initialisiert. Eventuell wurde ERiC nicht richtig initialisiert? + */ + ERIC_PRINT_INITIALISIERUNG_FEHLERHAFT = 610501007, + + /** + * [610501008] Das zu verwendende Format bzw. der Zielklient sind nicht bekannt. + */ + ERIC_PRINT_AUSGABEZIEL_UNBEKANNT = 610501008, + + /** + * [610501009] Der Beginn des Ausdruckprozesses schlug fehl. Eventuell konnten notwendige Ressourcen nicht allokiert werden. + */ + ERIC_PRINT_ABBRUCH_DRUCKVORBEREITUNG = 610501009, + + /** + * [610501010] Während der Ausgabe der Inhalte ist ein Fehler aufgetreten. + */ + ERIC_PRINT_ABBRUCH_GENERIERUNG = 610501010, + + /** + * [610501011] Die Kombination aus Unterfallart und Veranlagungszeitraum wird nicht unterstützt. + */ + ERIC_PRINT_STEUERFALL_NICHT_UNTERSTUETZT = 610501011, + + /** + * [610501012] Der übergebene Fußtext ist zu lang. + */ + ERIC_PRINT_FUSSTEXT_ZU_LANG = 610501012, +} diff --git a/eric-sdk/src/lib.rs b/eric-sdk/src/lib.rs index 8b13789..73bd7d4 100644 --- a/eric-sdk/src/lib.rs +++ b/eric-sdk/src/lib.rs @@ -1 +1,31 @@ +mod certificate; +mod config; +mod eric; +mod error_code; +mod response; +mod utils; +pub use eric::Eric; +pub use error_code::ErrorCode; +pub use response::EricResponse; + +#[derive(Debug, Clone, Copy)] +pub(crate) enum ProcessingFlag { + Validate = 2, + Send = 4, + Print = 32, + SendAndPrint = 36, + #[allow(dead_code)] + CheckHints = 128, +} + +impl ProcessingFlag { + pub fn into_u32(self) -> u32 { + self as u32 + } +} + +pub(crate) enum Preview { + Yes = 1, + No = 0, +} diff --git a/eric-sdk/src/response.rs b/eric-sdk/src/response.rs new file mode 100644 index 0000000..c3e21f4 --- /dev/null +++ b/eric-sdk/src/response.rs @@ -0,0 +1,67 @@ +use crate::error_code::ErrorCode; +use eric_bindings::{ + EricReturnBufferApi, EricRueckgabepufferErzeugen, EricRueckgabepufferFreigeben, + EricRueckgabepufferInhalt, +}; +use std::ffi::CStr; + +/// A structure which summarizes the response from the Eric instance. +#[derive(Debug)] +pub struct EricResponse { + /// The error code returned by the Eric instance. + pub error_code: i32, + /// The response when validating an XML file. + pub validation_response: String, + /// The response when an XML file is send to the tax authorities. + pub server_response: String, +} + +impl EricResponse { + pub fn new(error_code: i32, validation_response: String, server_response: String) -> Self { + Self { + error_code, + validation_response, + server_response, + } + } +} + +pub struct ResponseBuffer { + ctx: *mut EricReturnBufferApi, +} + +impl ResponseBuffer { + pub fn new() -> Result { + let response_buffer = unsafe { EricRueckgabepufferErzeugen() }; + + Ok(ResponseBuffer { + ctx: response_buffer, + }) + } + + pub fn as_ptr(&self) -> *mut EricReturnBufferApi { + self.ctx + } + + pub fn read(&self) -> Result<&str, anyhow::Error> { + let buffer = unsafe { + let ptr = EricRueckgabepufferInhalt(self.ctx); + CStr::from_ptr(ptr) + }; + + Ok(buffer.to_str()?) + } +} + +impl Drop for ResponseBuffer { + fn drop(&mut self) { + println!("Cleaning up response buffer"); + + let error_code = unsafe { EricRueckgabepufferFreigeben(self.ctx) }; + + match error_code { + x if x == ErrorCode::ERIC_OK as i32 => (), + error_code => panic!("Can't drop reponse buffer: {}", error_code), + } + } +} diff --git a/eric-sdk/src/utils.rs b/eric-sdk/src/utils.rs new file mode 100644 index 0000000..2f60a4c --- /dev/null +++ b/eric-sdk/src/utils.rs @@ -0,0 +1,45 @@ +use anyhow::Context; +use std::{ + ffi::{CString, OsStr}, + os::unix::prelude::OsStrExt, + path::{Path, PathBuf}, +}; + +pub trait ToCString { + fn try_to_cstring(self) -> Result; +} + +impl ToCString for String { + fn try_to_cstring(self) -> Result { + CString::new(self).context("Can't convert to CString") + } +} + +impl ToCString for &str { + fn try_to_cstring(self) -> Result { + CString::new(self).context("Can't convert to CString") + } +} + +impl ToCString for PathBuf { + fn try_to_cstring(self) -> Result { + self.to_str() + .context("Can't convert path to CString")? + .try_to_cstring() + } +} + +impl ToCString for &Path { + fn try_to_cstring(self) -> Result { + self.to_str() + .context("Can't convert path to CString")? + .try_to_cstring() + } +} + +impl ToCString for &OsStr { + fn try_to_cstring(self) -> Result { + // TODO: implement conversion for Windows and macOS + CString::new(self.as_bytes()).context("Can't convert OsStr to CString") + } +} diff --git a/eric-sdk/test_data/taxonomy/v6.5/SteuerbilanzAutoverkaeufer_PersG.xml b/eric-sdk/test_data/taxonomy/v6.5/SteuerbilanzAutoverkaeufer_PersG.xml new file mode 100644 index 0000000..61baced --- /dev/null +++ b/eric-sdk/test_data/taxonomy/v6.5/SteuerbilanzAutoverkaeufer_PersG.xml @@ -0,0 +1,1152 @@ + + + + ElsterBilanz + Bilanz + send-Auth + 700000004 + 00000 + Datenlieferant als String + + CMSEncryptedData + GZIP + + + xyz + + + + + 0001 + 5192 + + xyz + VX.Y + + Datenlieferant als String + + + + 20211231 + + + + + + 5192050001276 + + + 2021-12-31 + + + + + 5192050001276 + + + 2021-01-01 + 2021-12-31 + + + + + 5192050001276 + + + 2021-01-01 + 2021-12-31 + + + de-gaap-ci:table.kke.allKindsOfEquityAccounts + de-gaap-ci:dim_taxBal + + 0001 + + + + + + 5192050001276 + + + 2021-01-01 + 2021-12-31 + + + de-gaap-ci:table.kke.allKindsOfEquityAccounts.limitedPartners + de-gaap-ci:dim_taxBal + + 0001 + + + + + + 5192050001276 + + + 2021-01-01 + 2021-12-31 + + + de-gaap-ci:table.kke.allKindsOfEquityAccounts.limitedPartners.FK + de-gaap-ci:dim_taxBal + + 0001 + + + + + + 5192050001276 + + + 2021-01-01 + 2021-12-31 + + + de-gaap-ci:table.kke.allKindsOfEquityAccounts + de-gaap-ci:dim_taxBal + + 0002 + + + + + + 5192050001276 + + + 2021-01-01 + 2021-12-31 + + + de-gaap-ci:table.kke.allKindsOfEquityAccounts.unlimitedPartners + de-gaap-ci:dim_taxBal + + 0002 + + + + + + 5192050001276 + + + 2021-01-01 + 2021-12-31 + + + de-gaap-ci:table.kke.allKindsOfEquityAccounts.unlimitedPartners.VK + de-gaap-ci:dim_taxBal + + 0002 + + + + + + 5192050001276 + + + 2021-01-01 + 2021-12-31 + + + de-gaap-ci:bs.ass.fixAss + de-gaap-ci:dim_comBal + + + + iso4217:EUR + + + xbrli:pure + + 2021-04-30 + + + + + + + + + + + + + + + + false + + + + + + + + + + + + + + + + + + + + + + + + + Berlin + 2021-03-03 + 2021-01-01 + 2021-12-31 + 2021-12-31 + + + Muster Autoverkäufer + Firmensitz + Musterstraße + 1 + 11111 + Musterstadt + Sachsen + + + + + + + + + + + + + + 5192050001276 + + + + Muster Autoverkäufer + 0001 + + + + 123 + 5192050001276 + + + + + + 0 + 1 + + true + false + + + Hans Maier + 0002 + + + + 456 + 5192050001287 + + + + + 1 + 1 + + false + false + + + + + + + + + + 2020-01-01 + 2020-12-31 + 2020-12-31 + 26591.55 + -6167.32 + 59375.78 + 21465.58 + 41889.81 + -20424.23 + 92657.33 + 75171.36 + + 88688.63 + 57383.25 + + + 67227.44 + + + 67227.44 + 67227.44 + + + + -9844.19 + + + + -9844.19 + + + + + + + + + + + -9844.19 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 30645.00 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 30645.00 + 23381.00 + + + + + + + + + + 5166.00 + 5166.00 + + 2098.00 + 2098.00 + + 660.38 + + 88688.63 + 1700.00 + 1500.00 + 1500.00 + 1500.00 + + + + + 200.00 + 200.00 + + 59375.78 + + + + + + + + + + + + + + + + 59375.78 + + + + 59375.78 + 32784.23 + + + + + + 26591.55 + + + + + + + + 0.00 + 0.00 + + + + 0.00 + 0.00 + 0.00 + 15612.85 + 1000.00 + + + + + + 1000.00 + 9479.73 + 8558.73 + 921.00 + + + 1000.00 + 1000.00 + + + + + + + + + + 2133.12 + 2133.12 + + + + + + + 12000.00 + 12000.00 + 26791.55 + + + + + 487.45 + 287.45 + + + + + + + + + + + + + + + + + + + + + + + + + + + + 200.00 + + + + + + + + + + + + + + + + + + + + + + + + + + + -287.45 + + -287.45 + + + + + + + + 26591.55 + + + + + + + + + + 287.45 + + + + + 26791.55 + 27079.00 + + + + + + + 0.00 + + + + + + + + + + + + + + + + + + + + + + + + + + 26591.55 + 28787.08 + + + + + 2195.53 + 2195.53 + -3644.99 + + + 3741.99 + 3741.99 + 3741.99 + + + + + + 97.00 + 97.00 + 97.00 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 33353.07 + + 4847.41 + 4295.29 + 4295.29 + + + + 552.12 + + + 397.36 + + + + + + 397.36 + 154.76 + + 154.76 + + 61138.75 + 948546.62 + + 948546.62 + 897931.07 + 897931.07 + + + + + + 50615.55 + + + + + + 50615.55 + + + + + + 1002065.51 + + 1002065.51 + 1002065.51 + + + + 977865.51 + + + + 24200.00 + + + + + + + + + + + + + + + + + + 21437.07 + + + + + + + 14.66 + 580.23 + + + + + + + + + + + + + 592.44 + + 110.38 + + 1263.63 + 6783.49 + 6783.49 + + + + + + + + + + + 4412.85 + + + + + + + + + + 560.30 + + 7119.09 + + + + + + + + + 7619.86 + 6757.79 + + + + + 6757.79 + + 6757.79 + + + + + + 862.07 + + + + + + + + + + + + + + + + + + + + + + + 1501.20 + + 1224.00 + + + 1224.00 + + + 277.20 + + + + + 277.20 + + 277.20 + + 921.00 + 200.00 + 721.00 + + 28765.23 + 23563.78 + -1669.82 + -13412.00 + 19423.57 + 26921.89 + 15081.82 + 41144.01 + 28765.23 + 23563.78 + -1669.82 + -13412.00 + 19423.57 + 26921.89 + 15081.82 + 41144.01 + 28765.23 + 23563.78 + -1669.82 + -13412.00 + 19423.57 + 26921.89 + 15081.82 + 41144.01 + 30610.55 + 18326.03 + -4497.50 + -7012.23 + -19423.57 + 65735.44 + 11509.73 + 34027.35 + 30610.55 + 18326.03 + -4497.50 + -7012.23 + -19423.57 + 65735.44 + 11509.73 + 34027.35 + 30610.55 + 18326.03 + -4497.50 + -7012.23 + -19423.57 + 65735.44 + 11509.73 + 34027.35 + + + + + + + Eine Fussnote + + + + + list item + + + + + + + + + + + + + diff --git a/eric-sdk/tests/test_send.rs b/eric-sdk/tests/test_send.rs new file mode 100644 index 0000000..88fd5d2 --- /dev/null +++ b/eric-sdk/tests/test_send.rs @@ -0,0 +1,62 @@ +use anyhow::Context; +use eric_sdk::{Eric, ErrorCode}; +use roxmltree::Document; +use std::{env::current_dir, fs, path::Path}; + +#[test] +#[cfg_attr(not(feature = "external-test"), ignore)] +fn test_send() { + let log_path = current_dir().unwrap(); + let xml_path = Path::new("./test_data/taxonomy/v6.5/SteuerbilanzAutoverkaeufer_PersG.xml"); + let xml = fs::read_to_string(xml_path) + .context(format!("Can't read file: {}", xml_path.display())) + .unwrap(); + let taxonomy_type = "Bilanz"; + let taxonomy_version = "6.5"; + let pdf_path = None; + + let eric = Eric::new(&log_path).unwrap(); + + let res = eric.send(xml, taxonomy_type, taxonomy_version, pdf_path); + println!("{:#?}", res); + assert!(res.is_ok(), "{}", res.unwrap_err()); + + let response = res.unwrap(); + assert_eq!(response.error_code, ErrorCode::ERIC_OK as i32); + + let doc = Document::parse(&response.validation_response).unwrap(); + println!("Doc: {:#?}", doc); + let node = doc.descendants().find(|node| node.has_tag_name("Erfolg")); + assert!(node.is_some()); + let node = node.unwrap(); + assert_eq!(node.tag_name().name(), "Erfolg"); +} + +#[test] +#[cfg_attr(not(feature = "external-test"), ignore)] +fn test_send_and_print() { + let log_path = current_dir().unwrap(); + let xml_path = Path::new("./test_data/taxonomy/v6.5/SteuerbilanzAutoverkaeufer_PersG.xml"); + let xml = fs::read_to_string(xml_path) + .context(format!("Can't read file: {}", xml_path.display())) + .unwrap(); + let taxonomy_type = "Bilanz"; + let taxonomy_version = "6.5"; + let pdf_path = "ebilanz.pdf"; + + let eric = Eric::new(&log_path).unwrap(); + + let res = eric.send(xml, taxonomy_type, taxonomy_version, Some(pdf_path)); + println!("{:#?}", res); + assert!(res.is_ok(), "{}", res.unwrap_err()); + + let response = res.unwrap(); + assert_eq!(response.error_code, ErrorCode::ERIC_OK as i32); + + let doc = Document::parse(&response.validation_response).unwrap(); + println!("Doc: {:#?}", doc); + let node = doc.descendants().find(|node| node.has_tag_name("Erfolg")); + assert!(node.is_some()); + let node = node.unwrap(); + assert_eq!(node.tag_name().name(), "Erfolg"); +} diff --git a/eric-sdk/tests/test_validate.rs b/eric-sdk/tests/test_validate.rs new file mode 100644 index 0000000..9247cce --- /dev/null +++ b/eric-sdk/tests/test_validate.rs @@ -0,0 +1,64 @@ +use anyhow::Context; +use eric_sdk::{Eric, ErrorCode}; +use roxmltree::Document; +use std::{env::current_dir, fs, path::Path}; + +#[test] +fn test_validate() { + let log_path = current_dir().unwrap(); + let xml_path = Path::new("./test_data/taxonomy/v6.5/SteuerbilanzAutoverkaeufer_PersG.xml"); + let xml = fs::read_to_string(xml_path) + .context(format!("Can't read file: {}", xml_path.display())) + .unwrap(); + let taxonomy_type = "Bilanz"; + let taxonomy_version = "6.5"; + let pdf_path = None; + + let eric = Eric::new(&log_path).unwrap(); + + let res = eric.validate(xml, taxonomy_type, taxonomy_version, pdf_path); + println!("{:#?}", res); + assert!(res.is_ok(), "{}", res.unwrap_err()); + + let response = res.unwrap(); + assert_eq!(response.error_code, ErrorCode::ERIC_OK as i32); + + let doc = Document::parse(&response.validation_response).unwrap(); + println!("Doc: {:#?}", doc); + let node = doc.descendants().find(|node| node.has_tag_name("Erfolg")); + assert!(node.is_some()); + let node = node.unwrap(); + assert_eq!(node.tag_name().name(), "Erfolg"); + + assert!(response.server_response.is_empty()); +} + +#[test] +fn test_validate_and_print() { + let log_path = current_dir().unwrap(); + let xml_path = Path::new("./test_data/taxonomy/v6.5/SteuerbilanzAutoverkaeufer_PersG.xml"); + let xml = fs::read_to_string(xml_path) + .context(format!("Can't read file: {}", xml_path.display())) + .unwrap(); + let taxonomy_type = "Bilanz"; + let taxonomy_version = "6.5"; + let pdf_path = "ebilanz.pdf"; + + let eric = Eric::new(&log_path).unwrap(); + + let res = eric.validate(xml, taxonomy_type, taxonomy_version, Some(pdf_path)); + println!("{:#?}", res); + assert!(res.is_ok(), "{}", res.unwrap_err()); + + let response = res.unwrap(); + assert_eq!(response.error_code, ErrorCode::ERIC_OK as i32); + + let doc = Document::parse(&response.validation_response).unwrap(); + println!("Doc: {:#?}", doc); + let node = doc.descendants().find(|node| node.has_tag_name("Erfolg")); + assert!(node.is_some()); + let node = node.unwrap(); + assert_eq!(node.tag_name().name(), "Erfolg"); + + assert!(response.server_response.is_empty()); +}