From 080537fe6d18d03c217ff0f1a2bc6db05bb984ac Mon Sep 17 00:00:00 2001 From: theo Date: Wed, 4 Sep 2024 18:45:11 +0200 Subject: [PATCH] feat: define structure --- crates/services-sesam-vitale-sys/Cargo.toml | 2 + crates/services-sesam-vitale-sys/src/api.rs | 66 ++++ crates/services-sesam-vitale-sys/src/lib.rs | 66 +--- .../src/types/common.rs | 370 ++++++------------ .../src/types/configuration.rs | 137 +++++++ .../src/types/mod.rs | 4 +- .../src/types/serialization_types.rs | 248 ------------ .../src/types/types.rs | 45 --- 8 files changed, 334 insertions(+), 604 deletions(-) create mode 100644 crates/services-sesam-vitale-sys/src/api.rs create mode 100644 crates/services-sesam-vitale-sys/src/types/configuration.rs delete mode 100644 crates/services-sesam-vitale-sys/src/types/serialization_types.rs delete mode 100644 crates/services-sesam-vitale-sys/src/types/types.rs diff --git a/crates/services-sesam-vitale-sys/Cargo.toml b/crates/services-sesam-vitale-sys/Cargo.toml index c357ee8..674084d 100644 --- a/crates/services-sesam-vitale-sys/Cargo.toml +++ b/crates/services-sesam-vitale-sys/Cargo.toml @@ -2,8 +2,10 @@ name = "services-sesam-vitale-sys" version = "0.1.0" edition = "2021" +#links= "ssvlux64" [dependencies] bitvec = "1.0.1" deku = "0.17.0" libc = "0.2.155" +thiserror = "1.0.63" diff --git a/crates/services-sesam-vitale-sys/src/api.rs b/crates/services-sesam-vitale-sys/src/api.rs new file mode 100644 index 0000000..59d0e7d --- /dev/null +++ b/crates/services-sesam-vitale-sys/src/api.rs @@ -0,0 +1,66 @@ +use thiserror::Error; +use std::{ffi::CString, fmt, path::Path, ptr}; + +use crate::{bindings::{SSV_InitLIB2, SSV_TermLIB}, types::{common::read_from_buffer, configuration::Configuration}}; + +#[derive(Error, Debug)] +pub struct SesamVitaleError { + code: u16, +} + +impl fmt::Display for SesamVitaleError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "Got error code {} from SSV_LireConfig", self.code) + } +} + +pub fn init_library(sesam_ini_path: &Path) -> Result<(), SesamVitaleError> { + // TODO: better error handling + let path_str = sesam_ini_path.to_str().unwrap(); + let path_ptr = CString::new(path_str).expect("failed to create cstring"); + + let exit_code: u16 = unsafe { SSV_InitLIB2(path_ptr.as_ptr()) }; + if exit_code != 0 { + let error = SesamVitaleError { code: exit_code }; + return Err(error); + }; + + Ok(()) +} +pub fn close_library() -> Result<(), SesamVitaleError> { + let exit_code: u16 = unsafe { SSV_TermLIB() }; + if exit_code != 0 { + let error = SesamVitaleError { code: exit_code }; + return Err(error); + }; + + Ok(()) +} + +pub fn read_config() -> Result { + let mut buffer_ptr: *mut libc::c_void = ptr::null_mut(); + let mut size: libc::size_t = 0; + + let buffer_ptr_ptr: *mut *mut libc::c_void = &mut buffer_ptr; + let size_ptr: *mut libc::size_t = &mut size; + + // Need to add proper error handling -> return a result with error code pointing to an error + // enum + let exit_code: u16 = unsafe { SSV_LireConfig(buffer_ptr_ptr, size_ptr) }; + + if exit_code != 0 { + let error = SesamVitaleError { code: exit_code }; + return Err(error); + }; + + let buffer: &[u8] = unsafe { std::slice::from_raw_parts(buffer_ptr as *const u8, size) }; + + // TODO: Improve error handling + let configuration: Configuration = read_from_buffer(buffer).unwrap(); + + // TODO: Call library function for memory delocating + unsafe { libc::free(buffer_ptr) }; + + Ok(configuration) +} + diff --git a/crates/services-sesam-vitale-sys/src/lib.rs b/crates/services-sesam-vitale-sys/src/lib.rs index eb4782c..20f7fd8 100644 --- a/crates/services-sesam-vitale-sys/src/lib.rs +++ b/crates/services-sesam-vitale-sys/src/lib.rs @@ -1,70 +1,6 @@ +pub mod api; mod bindings; pub mod types; -use bindings::{SSV_InitLIB2, SSV_LireConfig, SSV_TermLIB}; -use std::{ffi::CString, fmt, path::Path, ptr}; -use types::serialization_types::{read_from_buffer, Configuration}; - -#[derive(Debug)] -pub struct SesamVitaleError { - code: u16, -} - -impl fmt::Display for SesamVitaleError { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "Got error code {} from SSV_LireConfig", self.code) - } -} - -pub fn init_library(sesam_ini_path: &Path) -> Result<(), SesamVitaleError> { - // TODO: better error handling - let path_str = sesam_ini_path.to_str().unwrap(); - let path_ptr = CString::new(path_str).expect("failed to create cstring"); - - let exit_code: u16 = unsafe { SSV_InitLIB2(path_ptr.as_ptr()) }; - if exit_code != 0 { - let error = SesamVitaleError { code: exit_code }; - return Err(error); - }; - - Ok(()) -} -pub fn close_library() -> Result<(), SesamVitaleError> { - let exit_code: u16 = unsafe { SSV_TermLIB() }; - if exit_code != 0 { - let error = SesamVitaleError { code: exit_code }; - return Err(error); - }; - - Ok(()) -} - -pub fn read_config() -> Result { - let mut buffer_ptr: *mut libc::c_void = ptr::null_mut(); - let mut size: libc::size_t = 0; - - let buffer_ptr_ptr: *mut *mut libc::c_void = &mut buffer_ptr; - let size_ptr: *mut libc::size_t = &mut size; - - // Need to add proper error handling -> return a result with error code pointing to an error - // enum - let exit_code: u16 = unsafe { SSV_LireConfig(buffer_ptr_ptr, size_ptr) }; - - if exit_code != 0 { - let error = SesamVitaleError { code: exit_code }; - return Err(error); - }; - - let buffer: &[u8] = unsafe { std::slice::from_raw_parts(buffer_ptr as *const u8, size) }; - - // TODO: Improve error handling - let configuration: Configuration = read_from_buffer(buffer).unwrap(); - - // TODO: Call library function for memory delocating - unsafe { libc::free(buffer_ptr) }; - - Ok(configuration) -} - #[cfg(test)] mod tests {} diff --git a/crates/services-sesam-vitale-sys/src/types/common.rs b/crates/services-sesam-vitale-sys/src/types/common.rs index 08ce7eb..11ca26a 100644 --- a/crates/services-sesam-vitale-sys/src/types/common.rs +++ b/crates/services-sesam-vitale-sys/src/types/common.rs @@ -1,264 +1,144 @@ -pub struct Identification { - value: T, - // Key to check the validity of the value - // TODO: implement checking algorithm - key: u8, +use crate::types::configuration::{ + ConfigurationHeader, PCSCReader, ReaderConfiguration, SESAMVitaleComponent, +}; + +use std::{error::Error, str::FromStr}; + +use bitvec::index::BitIdx; +use deku::{ + bitvec::{BitStore, Msb0}, + ctx::ByteSize, + deku_derive, + reader::{Reader, ReaderRet}, + DekuContainerRead, DekuError, DekuReader, +}; + +#[deku_derive(DekuRead)] +#[derive(Debug, Clone, PartialEq)] +pub(crate) struct NumericString(#[deku(map = "convert_from_data_field")] String); + +#[deku_derive(DekuRead)] +#[derive(Debug, Clone, PartialEq)] +pub(crate) struct AlphaNumericString(#[deku(map = "convert_from_data_field")] String); + +#[deku_derive(DekuRead)] +#[derive(Debug, Clone, PartialEq)] +pub(crate) struct BinaryData(#[deku(map = "extract_from_data_field")] Vec); + +#[deku_derive(DekuRead)] +#[derive(Debug, Clone, Copy, PartialEq)] +#[deku(endian = "big")] +pub(crate) struct GroupId(u16); + +trait MapToDekuParseError { + fn map_to_deku_parse_error(self) -> Result; } -pub type Byte = u8; - -pub(crate) enum IdentificationNationale { - NumeroAdeli(String), - NumeroEmployeeDansStructure(IdentificationStructure, String), - NumeroDRASS(String), - NumeroRPPS(String), - /// N° Etudiant Médecin type ADELI sur 9 caractères (information transmise par l’ANS) - NumeroEtudiantMedecin(String), +impl MapToDekuParseError for Result { + fn map_to_deku_parse_error(self) -> Result { + self.map_err(|e| DekuError::Parse(e.to_string().into())) + } } -pub(crate) enum TypeCarteProfessionnelSante { - /// Carte de Professionnel de Santé (CPS) - CarteDeProfessionnelSante, - /// Carte de Professionnel de Santé en Formation (CPF) - CarteDeProfessionnelSanteEnFormation, - /// Carte de Personnel d'Établissement de Santé (CDE/CPE) - CarteDePersonnelEtablissementSante, - /// Carte de Personnel Autorisé (CDA/CPA) - CarteDePersonnelAutorise, - /// Carte de Personne Morale - CarteDePersonneMorale, +fn read_size(reader: &mut Reader) -> Result { + let first_byte: u8 = u8::from_reader_with_ctx(reader, ())?; + + let is_length_expanded = first_byte.get_bit::(BitIdx::new(0).map_to_deku_parse_error()?); + + match is_length_expanded { + true => { + let size_of_data_size: ByteSize = ByteSize((first_byte & 0b0111_1111) as usize); + + if size_of_data_size.0 > 4 { + return Err(DekuError::Parse("Size of the length encoding is > 4, this is not normal. Probable parsing error".to_string().into())); + }; + + // maximum size of the buffer is 4, we use the offset to read values less than 4 bytes + let buffer: &mut [u8; 4] = &mut [0; 4]; + let write_offset = 4 - size_of_data_size.0; + + match reader.read_bytes(size_of_data_size.0, &mut buffer[write_offset..])? { + ReaderRet::Bits(_bit_vec) => Err(DekuError::Parse("Got bits when trying to read bytes -> reader is unaligned, this is not normal.".to_string().into())), + ReaderRet::Bytes => Ok(ByteSize(u32::from_be_bytes(*buffer) as usize)), + } + } + false => Ok(ByteSize(first_byte as usize)), + } } -pub(crate) enum CategorieCarteProfessionnelSante { - Reelle, - Test, - Demonstration, +// Using this as the map function asks deku to parse a datafield +// We then use the datafield and convert it to the corresponding value +pub(super) fn convert_from_data_field(data_field: DataField) -> Result +where + T: FromStr, + T::Err: Error, +{ + let text = String::from_utf8(data_field.data).map_to_deku_parse_error()?; + T::from_str(&text).map_to_deku_parse_error() } -pub(crate) enum CodeCivilite { - Adjudant, - Amiral, - Aspirant, - Aumônier, - Capitaine, - Cardinal, - Chanoine, - Colonel, - Commandant, - Commissaire, - Conseiller, - Directeur, - Docteur, - Douanier, - Epouxse, // Epoux(se) - Evêque, - Général, - Gouverneur, - Ingénieur, - Inspecteur, - Lieutenant, - Madame, - Mademoiselle, - Maître, - Maréchal, - Médecin, - Mesdames, - Mesdemoiselles, - Messieurs, - Monseigneur, - Monsieur, - NotreDame, - Pasteur, - Préfet, - Président, - Professeur, - Recteur, - Sergent, - SousPréfet, - Technicien, - Veuve, +pub(crate) fn extract_from_data_field(data_field: DataField) -> Result, DekuError> { + Ok(data_field.data) } -pub(crate) enum IdentificationStructure { - NumeroAdeliCabinet(String), - NumeroFINESS(String), - NumeroSIREN(String), - NumeroSIRET(String), - NumeroRPPSCabinet(String), +#[deku_derive(DekuRead)] +#[derive(Debug, PartialEq)] +pub(crate) struct DataField { + #[deku(reader = "read_size(deku::reader)")] + pub(crate) data_size: ByteSize, + + #[deku(bytes_read = "data_size.0")] + pub(crate) data: Vec, } -pub(crate) enum ModeExercice { - LiberalExploitantCommercant, // Libéral, exploitant, commerçant - Salarie, - Remplacant, - Benevole, +#[deku_derive(DekuRead)] +#[derive(Debug, PartialEq)] +pub(crate) struct BlockHeader { + pub(crate) group_id: GroupId, + + #[deku(reader = "read_size(deku::reader)")] + pub(crate) data_size: ByteSize, } -pub(crate) enum StatutExercice { - // TAB-Statuts géré par l’ANS il faut trouver la donnee - PLACEHOLDER(u8), +#[deku_derive(DekuRead)] +#[derive(Debug, PartialEq)] +pub(crate) struct DataBlock { + pub(crate) header: BlockHeader, + + #[deku(ctx = "header.group_id")] + pub(crate) inner: DataGroup, } -pub(crate) enum SecteurActivite { - EtablissementPublicDeSanté, - HopitauxMilitaires, - EtablissementPrivePSPH, // Participant au Service Public Hospitalier - EtablissementPriveNonPSPH, - DispensaireDeSoins, - AutresStructuresDeSoinsRelevantDuServiceDeSanteDesArmees, - CabinetIndividuel, - CabinetDeGroupe, - ExerciceEnSociete, - SecteurPrivePHTempsPlein, - TransportSanitaire, - EntrepriseDInterim, - EtablissementDeSoinsEtPrevention, - PreventionEtSoinsEnEntreprise, - SanteScolaireEtUniversitaire, - RecrutementEtGestionRH, - PMIPlanificationFamiliale, - EtablissementPourHandicapes, - ComMarketingConsultingMedia, - EtablissementPersonnesAgees, - EtablissementAideaLaFamille, - EtablissementDEnseignement, - EtablissementsDeProtectionDeLEnfance, - EtablissementsDHebergementEtDeReadaptation, - Recherche, - AssurancePrivee, - OrganismeDeSecuriteSociale, - MinistèreEtServicesDeconcentres, - CollectivitesTerritoriales, - AssociationsEtOrganitationsHumanitaire, - LaboratoireDeBiologieMedicale, - AutreEtablissementSanitaire, - ProductionCommercialisationGrosBienMedicaux, - CommerceDétailDeBiensMédicaux, - PharmacieDOfficine, - CentreDeDialyse, - ParaPharmacie, - AutreSecteurDActivité, - SecteurNonDefini, - CentreAntiCancer, - CentreDeTransfusionSanguine, - RépartitionDistribributionFabricationExploitationImportationMedicamentsEtDispositifsMédicaux, - IncendiesEtSecours, - EntreprisesIndustriellesEtTertiairesHorsIndustriesPharmaceutiques, - EntiteDUnTOM, - FabricationExploitationImportationMedicamentsEtDispositifsMedicaux, +#[deku_derive(DekuRead)] +#[derive(Debug, PartialEq)] +#[deku(ctx = "group_id: GroupId", id = "group_id.0")] +pub enum DataGroup { + #[deku(id = 60)] + ConfigurationHeader(ConfigurationHeader), + #[deku(id = 61)] + ReaderConfiguration(ReaderConfiguration), + #[deku(id = 64)] + SESAMVitaleComponent(SESAMVitaleComponent), + #[deku(id = 67)] + PCSCReader(PCSCReader), } +pub(crate) fn read_from_buffer(buffer: &[u8]) -> Result +where + T: TryFrom>, +{ + let mut data_blocks: Vec = Vec::new(); + let mut offset = 0; -pub(crate) type IdentificationFacturation = u32; -pub(crate) enum CodeConventionnel { - NonConventionne, - Conventionne, - ConventionneAvecDepassement, - ConventionneAvecHonorairesLibres, -} - -/// Code spécialité ou Code spécialité de l'exécutant -pub(crate) enum CodeSpecialite { - MedecineGenerale, - AnesthesieReanimation, - Cardiologie, - ChirurgieGenerale, - DermatologieEtVenerologie, - Radiologie, - GynecologieObstetrique, - GastroEnterologieEtHepatologie, - MedecineInterne, - NeuroChirurgie, - OtoRhinoLaryngologie, - Pediatrie, - Pneumologie, - Rhumatologie, - Ophtalmologie, - ChirurgieUrologique, - NeuroPsychiatrie, - Stomatologie, - ChirurgienDentiste, - ReanimationMedicale, - SageFemme, - SpecialisteEnMedecineGeneraleAvecDiplome, - SpecialisteEnMedecineGeneraleReconnuParLOrdre, - Infirmier, - Psychologue, - MasseurKinesitherapeute, - PedicurePodologue, - Orthophoniste, - Orthoptiste, - LaboratoireDAnalysesMedicales, - ReeducationReadaptationFonctionnelle, - Neurologie, - Psychiatrie, - Geriatrie, - Nephrologie, - ChirurgieDentaireSpecialiteODF, - AnatomoCytoPathologie, - MedecinBiologiste, - LaboratoirePolyvalent, - LaboratoireDAnatomoCytoPathologique, - ChirurgieOrthopediqueEtTraumatologie, - EndocrinologieEtMetabolisme, - ChirurgieInfantile, - ChirurgieMaxilloFaciale, - ChirurgieMaxilloFacialeEtStomatologie, - ChirurgiePlastiqueReconstructriceEtEsthetique, - ChirurgieThoraciqueEtCardioVasculaire, - ChirurgieVasculaire, - ChirurgieVisceraleEtDigestive, - PharmacieDOfficine, - PharmacieMutualiste, - ChirurgienDentisteSpecialiteCO, - ChirurgienDentisteSpecialiteMBD, - PrestataireDeTypeSociete, - PrestataireArtisan, - PrestataireDeTypeAssociation, - Orthesiste, - Opticien, - Audioprothesiste, - ÉpithesisteOculariste, - PodoOrthesiste, - Orthoprothesiste, - ChirurgieOrale, - GynecologieMedicale, - Hematologie, - MedecineNucleaire, - OncologieMedicale, - OncologieRadiotherapique, - PsychiatrieDeLEnfantEtDeLAdolescent, - Radiotherapie, - Obstetrique, - GenetiqueMedicale, - ObstetriqueEtGynecologieMedicale, - SantePubliqueEtMedecineSociale, - MedecineDesMaladiesInfectieusesEtTropicales, - MedecineLegaleEtExpertisesMedicales, - MedecineDUrgence, - MedecineVasculaire, - Allergologie, - InfirmierExercantEnPratiquesAvancees, // IPA -} - -/// Page 54 dictionnaires des donnees -/// donnees inutilises pour les pharmacies -pub(crate) enum CodeZoneTarifaire {} - -pub(crate) enum CodeZoneIK { - PasIndemniteKilometrique, - IndemnitesKilometriquesPlaine, - IndemnitesKilometriquesMontagne, -} - -pub(crate) enum CodeAgrement { - PasDAgrementRadio, - /// Agrément D ou agrément DDASS - AgrementDDASS, - /// Agrément A, B, C, E et F - AgrementABCEF, - /// Agrément G, H et J - AgrementGHJ, - AgrementK, - AgrementL, - AgrementM, + let mut remaining_buffer = buffer; + + while !remaining_buffer.is_empty() { + // TODO: properly handle errors + let (rest, data_block) = DataBlock::from_bytes((remaining_buffer, offset)).unwrap(); + + data_blocks.push(data_block); + + (remaining_buffer, offset) = rest; + } + + T::try_from(data_blocks) } diff --git a/crates/services-sesam-vitale-sys/src/types/configuration.rs b/crates/services-sesam-vitale-sys/src/types/configuration.rs new file mode 100644 index 0000000..185255f --- /dev/null +++ b/crates/services-sesam-vitale-sys/src/types/configuration.rs @@ -0,0 +1,137 @@ +use crate::types::common::DataBlock; +use std::{error::Error, fmt, vec::Vec}; + +use crate::types::common::convert_from_data_field; +use deku::{deku_derive, DekuReader}; + +use super::common::{AlphaNumericString, DataGroup}; + +#[deku_derive(DekuRead)] +#[derive(Debug, PartialEq)] +pub struct SSVVersionNumber(#[deku(map = "convert_from_data_field")] u16); + +#[deku_derive(DekuRead)] +#[derive(Debug, PartialEq)] +pub struct GALSSVersionNumber(#[deku(map = "convert_from_data_field")] u16); + +#[deku_derive(DekuRead)] +#[derive(Debug, PartialEq)] +pub struct PSSVersionNumber(#[deku(map = "convert_from_data_field")] u16); + +#[deku_derive(DekuRead)] +#[derive(Debug, PartialEq)] +pub struct ConfigurationHeader { + pub ssv_version: SSVVersionNumber, + pub galss_version: GALSSVersionNumber, + pub pss_version: PSSVersionNumber, +} + +#[deku_derive(DekuRead)] +#[derive(Debug, PartialEq)] +pub struct PCSCReaderName(AlphaNumericString); + +#[deku_derive(DekuRead)] +#[derive(Debug, PartialEq)] +pub struct CardType(#[deku(map = "convert_from_data_field")] u8); + +#[deku_derive(DekuRead)] +#[derive(Debug, PartialEq)] +pub struct PCSCReader { + pub name: PCSCReaderName, + pub card_type: CardType, +} + +#[deku_derive(DekuRead)] +#[derive(Debug, PartialEq)] +pub struct SESAMVitaleComponentID(#[deku(map = "convert_from_data_field")] u16); + +#[deku_derive(DekuRead)] +#[derive(Debug, PartialEq)] +pub struct SESAMVitaleComponentDescription(AlphaNumericString); + +#[deku_derive(DekuRead)] +#[derive(Debug, PartialEq)] +pub struct SESAMVitaleComponentVersion(AlphaNumericString); + +#[deku_derive(DekuRead)] +#[derive(Debug, PartialEq)] +pub struct SESAMVitaleComponent { + pub id: SESAMVitaleComponentID, + pub description: SESAMVitaleComponentDescription, + pub version: SESAMVitaleComponentVersion, +} + +#[deku_derive(DekuRead)] +#[derive(Debug, PartialEq)] +pub struct ReaderConfiguration {} + +#[derive(Debug)] +pub enum ConfigurationError { + MultipleConfigurationHeaders, + MissingConfigurationHeader, +} + +impl fmt::Display for ConfigurationError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + ConfigurationError::MultipleConfigurationHeaders => { + write!(f, "Multiple ConfigurationHeader blocks found") + } + ConfigurationError::MissingConfigurationHeader => { + write!(f, "Missing ConfigurationHeader block") + } + } + } +} + +impl Error for ConfigurationError {} + +#[derive(Debug)] +pub struct Configuration { + pub configuration_header: ConfigurationHeader, + pub reader_configurations: Vec, + pub sesam_vitale_components: Vec, + pub pcsc_readers: Vec, +} + +impl TryFrom> for Configuration { + type Error = ConfigurationError; + + fn try_from(data_blocks: Vec) -> Result { + let mut configuration_header: Option = None; + let mut reader_configurations: Vec = Vec::new(); + let mut sesam_vitale_components: Vec = Vec::new(); + let mut pcsc_readers: Vec = Vec::new(); + + for block in data_blocks { + match block.inner { + DataGroup::ConfigurationHeader(header) => { + if configuration_header.is_some() { + return Err(ConfigurationError::MultipleConfigurationHeaders); + } + configuration_header = Some(header); + } + DataGroup::ReaderConfiguration(configuration) => { + reader_configurations.push(configuration) + } + DataGroup::SESAMVitaleComponent(component) => { + sesam_vitale_components.push(component); + } + DataGroup::PCSCReader(reader) => { + pcsc_readers.push(reader); + } + } + } + let configuration_header = match configuration_header { + Some(header) => header, + None => return Err(ConfigurationError::MissingConfigurationHeader), + }; + + Ok(Self { + configuration_header, + reader_configurations, + sesam_vitale_components, + pcsc_readers, + }) + } +} diff --git a/crates/services-sesam-vitale-sys/src/types/mod.rs b/crates/services-sesam-vitale-sys/src/types/mod.rs index 3a27f29..5e3dc6e 100644 --- a/crates/services-sesam-vitale-sys/src/types/mod.rs +++ b/crates/services-sesam-vitale-sys/src/types/mod.rs @@ -1 +1,3 @@ -pub mod serialization_types; +pub mod common; +pub mod configuration; +pub mod droits_vitale; diff --git a/crates/services-sesam-vitale-sys/src/types/serialization_types.rs b/crates/services-sesam-vitale-sys/src/types/serialization_types.rs deleted file mode 100644 index 470f252..0000000 --- a/crates/services-sesam-vitale-sys/src/types/serialization_types.rs +++ /dev/null @@ -1,248 +0,0 @@ -use bitvec::index::BitIdx; -use std::{error::Error, fmt, str::FromStr, vec::Vec}; - -use deku::{ - bitvec::{BitStore, Msb0}, ctx::ByteSize, deku_derive, reader::{Reader, ReaderRet}, DekuContainerRead, DekuError, DekuReader -}; - -#[deku_derive(DekuRead)] -#[derive(Debug, Clone, Copy, PartialEq)] -#[deku(endian = "big")] -pub(crate) struct GroupId(u16); - -trait MapToDekuParseError { - fn map_to_deku_parse_error(self) -> Result; -} - -impl MapToDekuParseError for Result { - fn map_to_deku_parse_error(self) -> Result { - self.map_err(|e| DekuError::Parse(e.to_string().into())) - } -} - -#[deku_derive(DekuRead)] -#[derive(Debug, PartialEq)] -pub(crate) struct DataField { - #[deku(reader = "read_size(deku::reader)")] - pub(crate) data_size: ByteSize, - - #[deku(bytes_read = "data_size.0")] - pub(crate) data: Vec, -} - -#[deku_derive(DekuRead)] -#[derive(Debug, PartialEq)] -pub(crate) struct BlockHeader { - pub(crate) group_id: GroupId, - - #[deku(reader = "read_size(deku::reader)")] - pub(crate) data_size: ByteSize, -} - -#[deku_derive(DekuRead)] -#[derive(Debug, PartialEq)] -pub(crate) struct DataBlock { - pub(crate) header: BlockHeader, - - #[deku(ctx = "header.group_id")] - pub(crate) inner: DataGroup, -} - -fn read_size(reader: &mut Reader) -> Result { - let first_byte: u8 = u8::from_reader_with_ctx(reader, ())?; - - let is_length_expanded = first_byte.get_bit::(BitIdx::new(0).map_to_deku_parse_error()?); - - match is_length_expanded { - true => { - let size_of_data_size: ByteSize = ByteSize((first_byte & 0b0111_1111) as usize); - - if size_of_data_size.0 > 4 { - return Err(DekuError::Parse("Size of the length encoding is > 4, this is not normal. Probable parsing error".to_string().into())); - }; - - // maximum size of the buffer is 4, we use the offset to read values less than 4 bytes - let buffer: &mut [u8; 4] = &mut [0; 4]; - let write_offset = 4 - size_of_data_size.0; - - match reader.read_bytes(size_of_data_size.0, &mut buffer[write_offset..])? { - ReaderRet::Bits(_bit_vec) => Err(DekuError::Parse("Got bits when trying to read bytes -> reader is unaligned, this is not normal.".to_string().into())), - ReaderRet::Bytes => Ok(ByteSize(u32::from_be_bytes(*buffer) as usize)), - } - } - false => Ok(ByteSize(first_byte as usize)), - } -} - -// Using this as the map function asks deku to parse a datafield -// We then use the datafield and convert it to the corresponding value -fn convert_from_data_field(data_field: DataField) -> Result -where - T: FromStr, - T::Err: Error, -{ - let text = String::from_utf8(data_field.data).map_to_deku_parse_error()?; - T::from_str(&text).map_to_deku_parse_error() -} - -#[deku_derive(DekuRead)] -#[derive(Debug, PartialEq)] -pub struct SSVVersionNumber(#[deku(map = "convert_from_data_field")] u16); - -#[deku_derive(DekuRead)] -#[derive(Debug, PartialEq)] -pub struct GALSSVersionNumber(#[deku(map = "convert_from_data_field")] u16); - -#[deku_derive(DekuRead)] -#[derive(Debug, PartialEq)] -pub struct PSSVersionNumber(#[deku(map = "convert_from_data_field")] u16); - -#[deku_derive(DekuRead)] -#[derive(Debug, PartialEq)] -pub struct ConfigurationHeader { - pub ssv_version: SSVVersionNumber, - pub galss_version: GALSSVersionNumber, - pub pss_version: PSSVersionNumber, -} - -#[deku_derive(DekuRead)] -#[derive(Debug, PartialEq)] -pub struct PCSCReaderName(#[deku(map = "convert_from_data_field")] String); - -#[deku_derive(DekuRead)] -#[derive(Debug, PartialEq)] -pub struct CardType(#[deku(map = "convert_from_data_field")] u8); - -#[deku_derive(DekuRead)] -#[derive(Debug, PartialEq)] -pub struct PCSCReader { - pub name: PCSCReaderName, - pub card_type: CardType, -} - -#[deku_derive(DekuRead)] -#[derive(Debug, PartialEq)] -pub struct SESAMVitaleComponentID(#[deku(map = "convert_from_data_field")] u16); - -#[deku_derive(DekuRead)] -#[derive(Debug, PartialEq)] -pub struct SESAMVitaleComponentDescription(#[deku(map = "convert_from_data_field")] String); - -#[deku_derive(DekuRead)] -#[derive(Debug, PartialEq)] -pub struct SESAMVitaleComponentVersion(#[deku(map = "convert_from_data_field")] String); - -#[deku_derive(DekuRead)] -#[derive(Debug, PartialEq)] -pub struct SESAMVitaleComponent { - pub id: SESAMVitaleComponentID, - pub description: SESAMVitaleComponentDescription, - pub version: SESAMVitaleComponentVersion, -} - -#[deku_derive(DekuRead)] -#[derive(Debug, PartialEq)] -pub struct ReaderConfiguration {} - -#[deku_derive(DekuRead)] -#[derive(Debug, PartialEq)] -#[deku(ctx = "group_id: GroupId", id = "group_id.0")] -pub enum DataGroup { - #[deku(id = 60)] - ConfigurationHeader(ConfigurationHeader), - #[deku(id = 61)] - ReaderConfiguration(ReaderConfiguration), - #[deku(id = 64)] - SESAMVitaleComponent(SESAMVitaleComponent), - #[deku(id = 67)] - PCSCReader(PCSCReader), -} - -#[derive(Debug)] -pub enum ConfigurationError { - MultipleConfigurationHeaders, - MissingConfigurationHeader, -} - -impl fmt::Display for ConfigurationError { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - ConfigurationError::MultipleConfigurationHeaders => { - write!(f, "Multiple ConfigurationHeader blocks found") - } - ConfigurationError::MissingConfigurationHeader => { - write!(f, "Missing ConfigurationHeader block") - } - } - } -} - -impl Error for ConfigurationError {} - -#[derive(Debug)] -pub struct Configuration { - pub configuration_header: ConfigurationHeader, - pub reader_configurations: Vec, - pub sesam_vitale_components: Vec, - pub pcsc_readers: Vec, -} - -impl TryFrom> for Configuration { - type Error = ConfigurationError; - - fn try_from(data_blocks: Vec) -> Result { - let mut configuration_header: Option = None; - let mut reader_configurations: Vec = Vec::new(); - let mut sesam_vitale_components: Vec = Vec::new(); - let mut pcsc_readers: Vec = Vec::new(); - - for block in data_blocks { - match block.inner { - DataGroup::ConfigurationHeader(header) => { - if configuration_header.is_some() { - return Err(ConfigurationError::MultipleConfigurationHeaders); - } - configuration_header = Some(header); - } - DataGroup::ReaderConfiguration(configuration) => { - reader_configurations.push(configuration) - } - DataGroup::SESAMVitaleComponent(component) => { - sesam_vitale_components.push(component); - } - DataGroup::PCSCReader(reader) => { - pcsc_readers.push(reader); - } - } - } - let configuration_header = match configuration_header { - Some(header) => header, - None => return Err(ConfigurationError::MissingConfigurationHeader), - }; - - Ok(Self { - configuration_header, - reader_configurations, - sesam_vitale_components, - pcsc_readers, - }) - } -} - -pub(crate) fn read_from_buffer>>(buffer: &[u8]) -> Result{ - let mut data_blocks: Vec = Vec::new(); - let mut offset = 0; - - let mut remaining_buffer = buffer; - - while !remaining_buffer.is_empty() { - // TODO: properly handle errors - let (rest, data_block) = DataBlock::from_bytes((remaining_buffer, offset)).unwrap(); - - data_blocks.push(data_block); - - (remaining_buffer, offset) = rest; - }; - - T::try_from(data_blocks) -} diff --git a/crates/services-sesam-vitale-sys/src/types/types.rs b/crates/services-sesam-vitale-sys/src/types/types.rs deleted file mode 100644 index 7d26301..0000000 --- a/crates/services-sesam-vitale-sys/src/types/types.rs +++ /dev/null @@ -1,45 +0,0 @@ -pub(crate) use crate::types::common::IdentificationNationale; - -use super::common::{ - Byte, CategorieCarteProfessionnelSante, CodeAgrement, CodeCivilite, CodeConventionnel, - CodeSpecialite, CodeZoneIK, CodeZoneTarifaire, Identification, IdentificationFacturation, - IdentificationStructure, ModeExercice, SecteurActivite, StatutExercice, - TypeCarteProfessionnelSante, -}; - -pub(crate) struct CarteProfessionnelSante { - type_carte: TypeCarteProfessionnelSante, - categorie_carte: CategorieCarteProfessionnelSante, - professionnel_sante: ProfessionnelDeSante, -} - -struct ProfessionnelDeSante { - prenom: String, - nom: String, - code_civilite: CodeCivilite, - identification_nationale: Identification, - situations_execice: Vec, -} -struct StructureMedicale { - /// Nom Entreprise - raison_sociale: String, - identification: Identification, -} - -struct SituationDExercice { - /// Numéro identifiant la situation du PS parmi ses autres situations inscrites sur sa CPS - identifiant_situation: Byte, - mode_exercice: Option, - statut_exercice: Option, - secteur_activite: Option, - structure_d_exercice: Option, - identification_facturation: Identification, - identification_remplacant: Option>, - code_conventionnel: CodeConventionnel, - code_specialite: CodeSpecialite, - code_zone_tarifaire: CodeZoneTarifaire, - code_zone_ik: CodeZoneIK, - code_agrement: CodeAgrement, - habilite_signature_facture: bool, - habilite_signature_lot: bool, -}