qualia_core_db/specialized_libs/medical_computing/
privacy.rs

1use super::*;
2use serde::{Deserialize, Serialize};
3use std::collections::HashMap;
4
5/// Privacy protection
6pub struct PrivacyProtection {
7    encryption: EncryptionManager,
8    anonymization: AnonymizationEngine,
9    access_logging: AccessLogging,
10    consent_management: ConsentManagement,
11}
12
13/// Encryption manager
14pub struct EncryptionManager {
15    encryption_algorithms: HashMap<String, EncryptionAlgorithm>,
16    key_management: KeyManagement,
17    data_protection: DataProtection,
18}
19
20/// Encryption algorithms
21#[derive(Debug, Clone)]
22pub struct EncryptionAlgorithm {
23    pub algorithm_id: String,
24    pub algorithm_name: String,
25    pub algorithm_type: EncryptionType,
26    pub key_size: u32,
27    pub strength: EncryptionStrength,
28}
29
30/// Encryption types
31#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
32pub enum EncryptionType {
33    AES,
34    RSA,
35    ECC,
36    ChaCha20,
37    Custom(String),
38}
39
40/// Encryption strength
41#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
42pub enum EncryptionStrength {
43    Weak,
44    Moderate,
45    Strong,
46    Military,
47}
48
49/// Key management
50pub struct KeyManagement {
51    keys: HashMap<String, EncryptionKey>,
52    key_rotation: KeyRotation,
53    key_recovery: KeyRecovery,
54}
55
56/// Encryption keys
57#[derive(Debug, Clone)]
58pub struct EncryptionKey {
59    pub key_id: String,
60    pub key_type: KeyType,
61    pub key_value: Vec<u8>,
62    pub creation_date: u64,
63    pub expiry_date: Option<u64>,
64    pub usage_count: u64,
65}
66
67/// Key types
68#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
69pub enum KeyType {
70    Symmetric,
71    Asymmetric,
72    Public,
73    Private,
74}
75
76/// Key rotation
77pub struct KeyRotation {
78    rotation_policy: RotationPolicy,
79    rotation_schedule: RotationSchedule,
80    rotation_history: RotationHistory,
81}
82
83/// Rotation policy
84#[derive(Debug, Clone)]
85pub struct RotationPolicy {
86    pub policy_id: String,
87    pub rotation_interval: u32,
88    pub rotation_trigger: RotationTrigger,
89    pub compliance_requirements: Vec<ComplianceRequirement>,
90}
91
92/// Rotation triggers
93#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
94pub enum RotationTrigger {
95    TimeBased,
96    UsageBased,
97    SecurityEvent,
98    Manual,
99}
100
101/// Compliance requirements
102#[derive(Debug, Clone)]
103pub struct ComplianceRequirement {
104    pub requirement_id: String,
105    pub standard: String,
106    pub requirement: String,
107    pub mandatory: bool,
108}
109
110/// Rotation schedule
111#[derive(Debug, Clone)]
112pub struct RotationSchedule {
113    pub schedule_id: String,
114    pub next_rotation: u64,
115    pub rotation_frequency: u32,
116    pub affected_keys: Vec<String>,
117}
118
119/// Rotation history
120#[derive(Debug, Clone)]
121pub struct RotationHistory {
122    pub history_id: String,
123    pub rotation_date: u64,
124    pub old_key: String,
125    pub new_key: String,
126    pub reason: String,
127}
128
129/// Key recovery
130pub struct KeyRecovery {
131    recovery_methods: HashMap<String, RecoveryMethod>,
132    recovery_procedures: HashMap<String, RecoveryProcedure>,
133}
134
135/// Recovery methods
136#[derive(Debug, Clone)]
137pub struct RecoveryMethod {
138    pub method_id: String,
139    pub method_type: RecoveryMethodType,
140    pub security_level: SecurityLevel,
141}
142
143/// Recovery method types
144#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
145pub enum RecoveryMethodType {
146    ShamirSecretSharing,
147    HardwareToken,
148    Biometric,
149    MultiFactor,
150}
151
152/// Security levels
153#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
154pub enum SecurityLevel {
155    Low,
156    Medium,
157    High,
158    Maximum,
159}
160
161/// Recovery procedures
162#[derive(Debug, Clone)]
163pub struct RecoveryProcedure {
164    pub procedure_id: String,
165    pub steps: Vec<RecoveryStep>,
166    pub verification_required: bool,
167}
168
169/// Recovery steps
170#[derive(Debug, Clone)]
171pub struct RecoveryStep {
172    pub step_id: String,
173    pub step_description: String,
174    pub step_type: RecoveryStepType,
175}
176
177/// Recovery step types
178#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
179pub enum RecoveryStepType {
180    Authentication,
181    Verification,
182    Decryption,
183    Validation,
184}
185
186/// Data protection
187pub struct DataProtection {
188    protection_policies: HashMap<String, ProtectionPolicy>,
189    breach_detection: BreachDetection,
190    incident_response: IncidentResponse,
191}
192
193/// Protection policies
194#[derive(Debug, Clone)]
195pub struct ProtectionPolicy {
196    pub policy_id: String,
197    pub policy_name: String,
198    pub policy_type: PolicyType,
199    pub data_classification: DataClassification,
200    pub access_controls: Vec<AccessControl>,
201}
202
203/// Policy types
204#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
205pub enum PolicyType {
206    HIPAA,
207    GDPR,
208    CCPA,
209    HITRUST,
210    Custom(String),
211}
212
213/// Data classification
214#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
215pub enum DataClassification {
216    Public,
217    Internal,
218    Confidential,
219    Restricted,
220    PHI, // Protected Health Information
221}
222
223/// Access controls
224#[derive(Debug, Clone)]
225pub struct AccessControl {
226    pub control_id: String,
227    pub control_type: AccessControlType,
228    pub permissions: Vec<Permission>,
229    pub conditions: Vec<AccessCondition>,
230}
231
232/// Access control types
233#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
234pub enum AccessControlType {
235    RoleBased,
236    AttributeBased,
237    RuleBased,
238    Discretionary,
239}
240
241/// Permissions
242#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
243pub enum Permission {
244    Read,
245    Write,
246    Delete,
247    Share,
248    Export,
249}
250
251/// Access conditions
252#[derive(Debug, Clone)]
253pub struct AccessCondition {
254    pub condition_id: String,
255    pub condition_type: ConditionType,
256    pub condition_value: String,
257}
258
259/// Condition types
260#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
261pub enum ConditionType {
262    Time,
263    Location,
264    Device,
265    User,
266}
267
268/// Breach detection
269pub struct BreachDetection {
270    detection_algorithms: HashMap<String, DetectionAlgorithm>,
271    alert_systems: HashMap<String, AlertSystem>,
272}
273
274/// Detection algorithms
275#[derive(Debug, Clone)]
276pub struct DetectionAlgorithm {
277    pub algorithm_id: String,
278    pub algorithm_type: DetectionAlgorithmType,
279    pub sensitivity: f64,
280    pub false_positive_rate: f64,
281}
282
283/// Detection algorithm types
284#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
285pub enum DetectionAlgorithmType {
286    AnomalyDetection,
287    PatternRecognition,
288    MachineLearning,
289    RuleBased,
290}
291
292/// Alert systems
293#[derive(Debug, Clone)]
294pub struct AlertSystem {
295    pub system_id: String,
296    pub system_type: AlertSystemType,
297    pub notification_channels: Vec<NotificationChannel>,
298}
299
300/// Alert system types
301#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
302pub enum AlertSystemType {
303    Email,
304    SMS,
305    Slack,
306    Pager,
307    Custom(String),
308}
309
310/// Notification channels
311#[derive(Debug, Clone)]
312pub struct NotificationChannel {
313    pub channel_id: String,
314    pub channel_type: NotificationChannelType,
315    pub configuration: ChannelConfiguration,
316}
317
318/// Notification channel types
319#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
320pub enum NotificationChannelType {
321    Email,
322    SMS,
323    Webhook,
324    API,
325}
326
327/// Channel configuration
328#[derive(Debug, Clone)]
329pub struct ChannelConfiguration {
330    pub endpoint: String,
331    pub authentication: AuthenticationMethod,
332    pub format: MessageFormat,
333}
334
335/// Message formats
336#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
337pub enum MessageFormat {
338    JSON,
339    XML,
340    Text,
341    Custom(String),
342}
343
344/// Incident response
345pub struct IncidentResponse {
346    response_plans: HashMap<String, ResponsePlan>,
347    response_team: ResponseTeam,
348    escalation_procedures: EscalationProcedures,
349}
350
351/// Response plans
352#[derive(Debug, Clone)]
353pub struct ResponsePlan {
354    pub plan_id: String,
355    pub plan_name: String,
356    pub plan_type: ResponsePlanType,
357    pub steps: Vec<ResponseStep>,
358}
359
360/// Response plan types
361#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
362pub enum ResponsePlanType {
363    DataBreach,
364    SecurityIncident,
365    PrivacyViolation,
366    SystemOutage,
367}
368
369/// Response steps
370#[derive(Debug, Clone)]
371pub struct ResponseStep {
372    pub step_id: String,
373    pub step_description: String,
374    pub step_type: ResponseStepType,
375    pub responsible_party: String,
376    pub deadline: u32,
377}
378
379/// Response step types
380#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
381pub enum ResponseStepType {
382    Investigation,
383    Containment,
384    Eradication,
385    Recovery,
386    Reporting,
387}
388
389/// Response team
390#[derive(Debug, Clone)]
391pub struct ResponseTeam {
392    pub team_id: String,
393    pub team_name: String,
394    pub members: Vec<TeamMember>,
395    pub roles: HashMap<String, TeamRole>,
396}
397
398/// Team members
399#[derive(Debug, Clone)]
400pub struct TeamMember {
401    pub member_id: String,
402    pub name: String,
403    pub role: String,
404    pub contact_info: ContactInfo,
405    pub availability: Availability,
406}
407
408/// Availability
409#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
410pub enum Availability {
411    Available,
412    Busy,
413    OnCall,
414    Unavailable,
415}
416
417/// Team roles
418#[derive(Debug, Clone)]
419pub struct TeamRole {
420    pub role_id: String,
421    pub role_name: String,
422    pub responsibilities: Vec<String>,
423    pub authority_level: AuthorityLevel,
424}
425
426/// Authority levels
427#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
428pub enum AuthorityLevel {
429    Observer,
430    Operator,
431    Manager,
432    Director,
433}
434
435/// Escalation procedures
436pub struct EscalationProcedures {
437    escalation_rules: HashMap<String, EscalationRule>,
438    escalation_matrix: EscalationMatrix,
439}
440
441/// Escalation rules
442#[derive(Debug, Clone)]
443pub struct EscalationRule {
444    pub rule_id: String,
445    pub rule_name: String,
446    pub trigger_conditions: Vec<TriggerCondition>,
447    pub escalation_actions: Vec<EscalationAction>,
448}
449
450/// Trigger conditions
451#[derive(Debug, Clone)]
452pub struct TriggerCondition {
453    pub condition_id: String,
454    pub condition_type: TriggerConditionType,
455    pub condition_value: String,
456}
457
458/// Trigger condition types
459#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
460pub enum TriggerConditionType {
461    Severity,
462    Time,
463    Impact,
464    Compliance,
465}
466
467/// Escalation actions
468#[derive(Debug, Clone)]
469pub struct EscalationAction {
470    pub action_id: String,
471    pub action_type: EscalationActionType,
472    pub action_details: String,
473}
474
475/// Escalation action types
476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
477pub enum EscalationActionType {
478    Notify,
479    Escalate,
480    Activate,
481    Report,
482}
483
484/// Escalation matrix
485#[derive(Debug, Clone)]
486pub struct EscalationMatrix {
487    pub matrix_id: String,
488    pub matrix_name: String,
489    pub escalation_levels: Vec<EscalationLevel>,
490}
491
492/// Escalation levels
493#[derive(Debug, Clone)]
494pub struct EscalationLevel {
495    pub level_id: String,
496    pub level_name: String,
497    pub level_number: u32,
498    pub notification_recipients: Vec<String>,
499    pub response_time: u32,
500}
501
502/// Anonymization engine
503pub struct AnonymizationEngine {
504    anonymization_methods: HashMap<String, AnonymizationMethod>,
505    privacy_models: HashMap<String, PrivacyModel>,
506    risk_assessment: RiskAssessment,
507}
508
509/// Anonymization methods
510#[derive(Debug, Clone)]
511pub struct AnonymizationMethod {
512    pub method_id: String,
513    pub method_name: String,
514    pub method_type: AnonymizationMethodType,
515    pub parameters: AnonymizationParameters,
516}
517
518/// Anonymization method types
519#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
520pub enum AnonymizationMethodType {
521    Suppression,
522    Generalization,
523    Perturbation,
524    Masking,
525    Pseudonymization,
526}
527
528/// Anonymization parameters
529#[derive(Debug, Clone, Serialize, Deserialize)]
530pub struct AnonymizationParameters {
531    pub privacy_threshold: f64,
532    pub information_loss: f64,
533    pub utility_preservation: f64,
534}
535
536/// Privacy models
537#[derive(Debug, Clone)]
538pub struct PrivacyModel {
539    pub model_id: String,
540    pub model_name: String,
541    pub model_type: PrivacyModelType,
542    pub parameters: PrivacyModelParameters,
543}
544
545/// Privacy model types
546#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
547pub enum PrivacyModelType {
548    KAnonymity,
549    LDiversity,
550    TCloseness,
551    DifferentialPrivacy,
552}
553
554/// Privacy model parameters
555#[derive(Debug, Clone, Serialize, Deserialize)]
556pub struct PrivacyModelParameters {
557    pub k_value: Option<u32>,
558    pub l_value: Option<u32>,
559    pub t_value: Option<f64>,
560    pub epsilon: Option<f64>,
561}
562
563/// Risk assessment
564pub struct RiskAssessment {
565    risk_models: HashMap<String, RiskModel>,
566    risk_metrics: HashMap<String, RiskMetric>,
567}
568
569/// Risk models
570#[derive(Debug, Clone)]
571pub struct RiskModel {
572    pub model_id: String,
573    pub model_name: String,
574    pub model_type: RiskModelType,
575    pub risk_factors: Vec<RiskFactor>,
576}
577
578/// Risk model types
579#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
580pub enum RiskModelType {
581    Statistical,
582    MachineLearning,
583    ExpertSystem,
584    Hybrid,
585}
586
587/// Risk factors
588#[derive(Debug, Clone)]
589pub struct RiskFactor {
590    pub factor_id: String,
591    pub factor_name: String,
592    pub factor_weight: f64,
593    pub factor_value: f64,
594}
595
596/// Risk metrics
597#[derive(Debug, Clone)]
598pub struct RiskMetric {
599    pub metric_id: String,
600    pub metric_name: String,
601    pub metric_value: f64,
602    pub metric_threshold: f64,
603}
604
605/// Access logging
606pub struct AccessLogging {
607    log_entries: HashMap<String, LogEntry>,
608    log_analysis: LogAnalysis,
609    retention_policy: RetentionPolicy,
610}
611
612/// Log entries
613#[derive(Debug, Clone)]
614pub struct LogEntry {
615    pub entry_id: String,
616    pub timestamp: u64,
617    pub user_id: String,
618    pub action: AccessAction,
619    pub resource: String,
620    pub outcome: AccessOutcome,
621    pub details: String,
622}
623
624/// Access actions
625#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
626pub enum AccessAction {
627    Read,
628    Write,
629    Delete,
630    Share,
631    Export,
632    Login,
633    Logout,
634}
635
636/// Access outcomes
637#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
638pub enum AccessOutcome {
639    Success,
640    Failure,
641    Blocked,
642    Suspicious,
643}
644
645/// Log analysis
646pub struct LogAnalysis {
647    analysis_methods: HashMap<String, AnalysisMethod>,
648    anomaly_detection: AnomalyDetection,
649}
650
651/// Analysis methods
652#[derive(Debug, Clone)]
653pub struct AnalysisMethod {
654    pub method_id: String,
655    pub method_name: String,
656    pub method_type: AnalysisMethodType,
657}
658
659/// Analysis method types
660#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
661pub enum AnalysisMethodType {
662    Statistical,
663    Pattern,
664    Behavioral,
665    Temporal,
666}
667
668/// Anomaly detection
669#[derive(Debug, Clone)]
670pub struct AnomalyDetection {
671    detection_algorithms: HashMap<String, DetectionAlgorithm>,
672    alert_thresholds: HashMap<String, f64>,
673}
674
675/// Retention policy
676#[derive(Debug, Clone)]
677pub struct RetentionPolicy {
678    pub policy_id: String,
679    pub policy_name: String,
680    pub retention_period: u32,
681    pub archival_period: u32,
682    pub deletion_method: DeletionMethod,
683}
684
685/// Deletion methods
686#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
687pub enum DeletionMethod {
688    SoftDelete,
689    HardDelete,
690    SecureDelete,
691}
692
693/// Consent management
694pub struct ConsentManagement {
695    consent_records: HashMap<String, ConsentRecord>,
696    consent_policies: HashMap<String, ConsentPolicy>,
697    consent_workflows: HashMap<String, ConsentWorkflow>,
698}
699
700/// Consent records
701#[derive(Debug, Clone)]
702pub struct ConsentRecord {
703    pub record_id: String,
704    pub patient_id: String,
705    pub consent_type: ConsentType,
706    pub consent_status: ConsentStatus,
707    pub granted_date: u64,
708    pub expiry_date: Option<u64>,
709    pub purpose: String,
710    pub limitations: Vec<String>,
711}
712
713/// Consent types
714#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
715pub enum ConsentType {
716    Treatment,
717    Research,
718    DataSharing,
719    Marketing,
720    Genetic,
721}
722
723/// Consent status
724#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
725pub enum ConsentStatus {
726    Granted,
727    Denied,
728    Revoked,
729    Expired,
730}
731
732/// Consent policies
733#[derive(Debug, Clone)]
734pub struct ConsentPolicy {
735    pub policy_id: String,
736    pub policy_name: String,
737    pub policy_type: ConsentPolicyType,
738    pub requirements: Vec<ConsentRequirement>,
739}
740
741/// Consent policy types
742#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
743pub enum ConsentPolicyType {
744    HIPAA,
745    GDPR,
746    Institutional,
747    StudySpecific,
748}
749
750/// Consent requirements
751#[derive(Debug, Clone)]
752pub struct ConsentRequirement {
753    pub requirement_id: String,
754    pub requirement_name: String,
755    pub requirement_type: RequirementType,
756    pub mandatory: bool,
757}
758
759/// Requirement types
760#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
761pub enum RequirementType {
762    Informed,
763    Written,
764    Witnessed,
765    Electronic,
766}
767
768/// Consent workflows
769#[derive(Debug, Clone)]
770pub struct ConsentWorkflow {
771    pub workflow_id: String,
772    pub workflow_name: String,
773    pub workflow_steps: Vec<WorkflowStep>,
774}
775
776/// Workflow steps
777#[derive(Debug, Clone)]
778pub struct WorkflowStep {
779    pub step_id: String,
780    pub step_name: String,
781    pub step_type: WorkflowStepType,
782    pub step_order: u32,
783}
784
785/// Workflow step types
786#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
787pub enum WorkflowStepType {
788    Information,
789    Acknowledgment,
790    Signature,
791    Review,
792}
793
794/// Data access control
795pub struct DataAccessControl {
796    access_policies: HashMap<String, AccessPolicy>,
797    authentication: AuthenticationSystem,
798    authorization: AuthorizationSystem,
799}
800
801/// Access policies
802#[derive(Debug, Clone)]
803pub struct AccessPolicy {
804    pub policy_id: String,
805    pub policy_name: String,
806    pub policy_type: AccessPolicyType,
807    pub rules: Vec<AccessRule>,
808}
809
810/// Access policy types
811#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
812pub enum AccessPolicyType {
813    RoleBased,
814    AttributeBased,
815    RuleBased,
816    Hybrid,
817}
818
819/// Access rules
820#[derive(Debug, Clone)]
821pub struct AccessRule {
822    pub rule_id: String,
823    pub rule_name: String,
824    pub conditions: Vec<AccessCondition>,
825    pub actions: Vec<AccessAction>,
826}
827
828/// Authentication system
829pub struct AuthenticationSystem {
830    authentication_methods: HashMap<String, AuthenticationMethod>,
831    session_management: SessionManagement,
832    multi_factor: MultiFactorAuthentication,
833}
834
835/// Authentication methods
836#[derive(Debug, Clone)]
837pub struct AuthenticationMethod {
838    pub method_id: String,
839    pub method_name: String,
840    pub method_type: AuthenticationMethodType,
841    pub security_level: SecurityLevel,
842}
843
844/// Authentication method types
845#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
846pub enum AuthenticationMethodType {
847    Password,
848    Biometric,
849    Token,
850    Certificate,
851    SSO,
852}
853
854/// Session management
855pub struct SessionManagement {
856    sessions: HashMap<String, Session>,
857    session_policies: HashMap<String, SessionPolicy>,
858}
859
860/// Sessions
861#[derive(Debug, Clone)]
862pub struct Session {
863    pub session_id: String,
864    pub user_id: String,
865    pub creation_time: u64,
866    pub expiry_time: u64,
867    pub last_activity: u64,
868    pub ip_address: String,
869    pub user_agent: String,
870}
871
872/// Session policies
873#[derive(Debug, Clone)]
874pub struct SessionPolicy {
875    pub policy_id: String,
876    pub policy_name: String,
877    pub session_timeout: u32,
878    pub idle_timeout: u32,
879    pub max_concurrent_sessions: u32,
880}
881
882/// Multi-factor authentication
883pub struct MultiFactorAuthentication {
884    factors: HashMap<String, AuthenticationFactor>,
885    factor_combinations: HashMap<String, FactorCombination>,
886}
887
888/// Authentication factors
889#[derive(Debug, Clone)]
890pub struct AuthenticationFactor {
891    pub factor_id: String,
892    pub factor_type: AuthenticationFactorType,
893    pub factor_provider: String,
894}
895
896/// Authentication factor types
897#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
898pub enum AuthenticationFactorType {
899    Knowledge,
900    Possession,
901    Inherence,
902    Location,
903}
904
905/// Factor combinations
906#[derive(Debug, Clone)]
907pub struct FactorCombination {
908    pub combination_id: String,
909    pub combination_name: String,
910    pub required_factors: Vec<String>,
911}
912
913/// Authorization system
914pub struct AuthorizationSystem {
915    authorization_policies: HashMap<String, AuthorizationPolicy>,
916    permission_management: PermissionManagement,
917    role_management: RoleManagement,
918}
919
920/// Authorization policies
921#[derive(Debug, Clone)]
922pub struct AuthorizationPolicy {
923    pub policy_id: String,
924    pub policy_name: String,
925    pub policy_type: AuthorizationPolicyType,
926    pub policy_rules: Vec<AuthorizationRule>,
927}
928
929/// Authorization policy types
930#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
931pub enum AuthorizationPolicyType {
932    Allow,
933    Deny,
934    Conditional,
935}
936
937/// Authorization rules
938#[derive(Debug, Clone)]
939pub struct AuthorizationRule {
940    pub rule_id: String,
941    pub rule_name: String,
942    pub conditions: Vec<AuthorizationCondition>,
943    pub decision: AuthorizationDecision,
944}
945
946/// Authorization conditions
947#[derive(Debug, Clone)]
948pub struct AuthorizationCondition {
949    pub condition_id: String,
950    pub condition_type: AuthorizationConditionType,
951    pub condition_value: String,
952}
953
954/// Authorization condition types
955#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
956pub enum AuthorizationConditionType {
957    User,
958    Role,
959    Resource,
960    Time,
961    Location,
962}
963
964/// Authorization decisions
965#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
966pub enum AuthorizationDecision {
967    Permit,
968    Deny,
969    NotApplicable,
970}
971
972/// Permission management
973pub struct PermissionManagement {
974    permissions: HashMap<String, Permission>,
975    permission_groups: HashMap<String, PermissionGroup>,
976}
977
978/// Permission groups
979#[derive(Debug, Clone)]
980pub struct PermissionGroup {
981    pub group_id: String,
982    pub group_name: String,
983    pub permissions: Vec<String>,
984}
985
986/// Role management
987pub struct RoleManagement {
988    roles: HashMap<String, Role>,
989    role_hierarchy: RoleHierarchy,
990}
991
992/// Roles
993#[derive(Debug, Clone)]
994pub struct Role {
995    pub role_id: String,
996    pub role_name: String,
997    pub role_description: String,
998    pub permissions: Vec<String>,
999}
1000
1001/// Role hierarchy
1002#[derive(Debug, Clone)]
1003pub struct RoleHierarchy {
1004    pub hierarchy_id: String,
1005    pub parent_roles: Vec<String>,
1006    pub child_roles: Vec<String>,
1007}
1008impl PrivacyProtection {
1009    pub fn new() -> Self {
1010        Self {
1011            encryption: EncryptionManager::new(),
1012            anonymization: AnonymizationEngine::new(),
1013            access_logging: AccessLogging::new(),
1014            consent_management: ConsentManagement::new(),
1015        }
1016    }
1017
1018    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1019        self.encryption.initialize()?;
1020        self.anonymization.initialize()?;
1021        self.access_logging.initialize()?;
1022        self.consent_management.initialize()?;
1023        Ok(())
1024    }
1025}
1026
1027impl EncryptionManager {
1028    pub fn new() -> Self {
1029        Self {
1030            encryption_algorithms: HashMap::new(),
1031            key_management: KeyManagement::new(),
1032            data_protection: DataProtection::new(),
1033        }
1034    }
1035
1036    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1037        self.key_management.initialize()?;
1038        self.data_protection.initialize()?;
1039        Ok(())
1040    }
1041
1042    pub fn add_algorithm(&mut self, algorithm: EncryptionAlgorithm) {
1043        self.encryption_algorithms
1044            .insert(algorithm.algorithm_id.clone(), algorithm);
1045    }
1046
1047    pub fn get_algorithm(&self, algorithm_id: &str) -> Option<&EncryptionAlgorithm> {
1048        self.encryption_algorithms.get(algorithm_id)
1049    }
1050
1051    pub fn list_algorithms(&self) -> Vec<String> {
1052        self.encryption_algorithms.keys().cloned().collect()
1053    }
1054}
1055
1056impl KeyManagement {
1057    pub fn new() -> Self {
1058        Self {
1059            keys: HashMap::new(),
1060            key_rotation: KeyRotation::new(),
1061            key_recovery: KeyRecovery::new(),
1062        }
1063    }
1064
1065    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1066        Ok(())
1067    }
1068
1069    pub fn add_key(&mut self, key: EncryptionKey) {
1070        self.keys.insert(key.key_id.clone(), key);
1071    }
1072
1073    pub fn get_key(&self, key_id: &str) -> Option<&EncryptionKey> {
1074        self.keys.get(key_id)
1075    }
1076
1077    pub fn remove_key(&mut self, key_id: &str) -> Option<EncryptionKey> {
1078        self.keys.remove(key_id)
1079    }
1080
1081    pub fn key_rotation(&self) -> &KeyRotation {
1082        &self.key_rotation
1083    }
1084
1085    pub fn key_recovery(&self) -> &KeyRecovery {
1086        &self.key_recovery
1087    }
1088}
1089
1090impl KeyRotation {
1091    pub fn new() -> Self {
1092        Self {
1093            rotation_policy: RotationPolicy::new(),
1094            rotation_schedule: RotationSchedule::new(),
1095            rotation_history: RotationHistory::new(),
1096        }
1097    }
1098
1099    pub fn rotation_policy(&self) -> &RotationPolicy {
1100        &self.rotation_policy
1101    }
1102
1103    pub fn rotation_schedule(&self) -> &RotationSchedule {
1104        &self.rotation_schedule
1105    }
1106
1107    pub fn rotation_history(&self) -> &RotationHistory {
1108        &self.rotation_history
1109    }
1110}
1111
1112impl RotationPolicy {
1113    pub fn new() -> Self {
1114        Self {
1115            policy_id: "policy_1".to_string(),
1116            rotation_interval: 90, // 90 days
1117            rotation_trigger: RotationTrigger::TimeBased,
1118            compliance_requirements: Vec::new(),
1119        }
1120    }
1121}
1122
1123impl RotationSchedule {
1124    pub fn new() -> Self {
1125        Self {
1126            schedule_id: "schedule_1".to_string(),
1127            next_rotation: 0,
1128            rotation_frequency: 90,
1129            affected_keys: Vec::new(),
1130        }
1131    }
1132}
1133
1134impl RotationHistory {
1135    pub fn new() -> Self {
1136        Self {
1137            history_id: "history_1".to_string(),
1138            rotation_date: 0,
1139            old_key: String::new(),
1140            new_key: String::new(),
1141            reason: String::new(),
1142        }
1143    }
1144}
1145
1146impl KeyRecovery {
1147    pub fn new() -> Self {
1148        Self {
1149            recovery_methods: HashMap::new(),
1150            recovery_procedures: HashMap::new(),
1151        }
1152    }
1153
1154    pub fn add_recovery_method(&mut self, method: RecoveryMethod) {
1155        self.recovery_methods
1156            .insert(method.method_id.clone(), method);
1157    }
1158
1159    pub fn get_recovery_method(&self, method_id: &str) -> Option<&RecoveryMethod> {
1160        self.recovery_methods.get(method_id)
1161    }
1162
1163    pub fn add_recovery_procedure(&mut self, procedure: RecoveryProcedure) {
1164        self.recovery_procedures
1165            .insert(procedure.procedure_id.clone(), procedure);
1166    }
1167
1168    pub fn get_recovery_procedure(&self, procedure_id: &str) -> Option<&RecoveryProcedure> {
1169        self.recovery_procedures.get(procedure_id)
1170    }
1171}
1172
1173impl DataProtection {
1174    pub fn new() -> Self {
1175        Self {
1176            protection_policies: HashMap::new(),
1177            breach_detection: BreachDetection::new(),
1178            incident_response: IncidentResponse::new(),
1179        }
1180    }
1181
1182    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1183        Ok(())
1184    }
1185
1186    pub fn add_protection_policy(&mut self, policy: ProtectionPolicy) {
1187        self.protection_policies
1188            .insert(policy.policy_id.clone(), policy);
1189    }
1190
1191    pub fn get_protection_policy(&self, policy_id: &str) -> Option<&ProtectionPolicy> {
1192        self.protection_policies.get(policy_id)
1193    }
1194
1195    pub fn breach_detection(&self) -> &BreachDetection {
1196        &self.breach_detection
1197    }
1198
1199    pub fn incident_response(&self) -> &IncidentResponse {
1200        &self.incident_response
1201    }
1202}
1203
1204impl BreachDetection {
1205    pub fn new() -> Self {
1206        Self {
1207            detection_algorithms: HashMap::new(),
1208            alert_systems: HashMap::new(),
1209        }
1210    }
1211
1212    pub fn add_detection_algorithm(&mut self, algorithm: DetectionAlgorithm) {
1213        self.detection_algorithms
1214            .insert(algorithm.algorithm_id.clone(), algorithm);
1215    }
1216
1217    pub fn get_detection_algorithm(&self, algorithm_id: &str) -> Option<&DetectionAlgorithm> {
1218        self.detection_algorithms.get(algorithm_id)
1219    }
1220
1221    pub fn add_alert_system(&mut self, system: AlertSystem) {
1222        self.alert_systems.insert(system.system_id.clone(), system);
1223    }
1224
1225    pub fn get_alert_system(&self, system_id: &str) -> Option<&AlertSystem> {
1226        self.alert_systems.get(system_id)
1227    }
1228}
1229
1230impl IncidentResponse {
1231    pub fn new() -> Self {
1232        Self {
1233            response_plans: HashMap::new(),
1234            response_team: ResponseTeam::new(),
1235            escalation_procedures: EscalationProcedures::new(),
1236        }
1237    }
1238
1239    pub fn add_response_plan(&mut self, plan: ResponsePlan) {
1240        self.response_plans.insert(plan.plan_id.clone(), plan);
1241    }
1242
1243    pub fn get_response_plan(&self, plan_id: &str) -> Option<&ResponsePlan> {
1244        self.response_plans.get(plan_id)
1245    }
1246
1247    pub fn response_team(&self) -> &ResponseTeam {
1248        &self.response_team
1249    }
1250
1251    pub fn escalation_procedures(&self) -> &EscalationProcedures {
1252        &self.escalation_procedures
1253    }
1254}
1255
1256impl ResponseTeam {
1257    pub fn new() -> Self {
1258        Self {
1259            team_id: "team_1".to_string(),
1260            team_name: "Incident Response Team".to_string(),
1261            members: Vec::new(),
1262            roles: HashMap::new(),
1263        }
1264    }
1265}
1266
1267impl EscalationProcedures {
1268    pub fn new() -> Self {
1269        Self {
1270            escalation_rules: HashMap::new(),
1271            escalation_matrix: EscalationMatrix::new(),
1272        }
1273    }
1274
1275    pub fn add_escalation_rule(&mut self, rule: EscalationRule) {
1276        self.escalation_rules.insert(rule.rule_id.clone(), rule);
1277    }
1278
1279    pub fn get_escalation_rule(&self, rule_id: &str) -> Option<&EscalationRule> {
1280        self.escalation_rules.get(rule_id)
1281    }
1282
1283    pub fn escalation_matrix(&self) -> &EscalationMatrix {
1284        &self.escalation_matrix
1285    }
1286}
1287
1288impl EscalationMatrix {
1289    pub fn new() -> Self {
1290        Self {
1291            matrix_id: "matrix_1".to_string(),
1292            matrix_name: "Escalation Matrix".to_string(),
1293            escalation_levels: Vec::new(),
1294        }
1295    }
1296}
1297
1298impl AnonymizationEngine {
1299    pub fn new() -> Self {
1300        Self {
1301            anonymization_methods: HashMap::new(),
1302            privacy_models: HashMap::new(),
1303            risk_assessment: RiskAssessment::new(),
1304        }
1305    }
1306
1307    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1308        Ok(())
1309    }
1310
1311    pub fn add_anonymization_method(&mut self, method: AnonymizationMethod) {
1312        self.anonymization_methods
1313            .insert(method.method_id.clone(), method);
1314    }
1315
1316    pub fn get_anonymization_method(&self, method_id: &str) -> Option<&AnonymizationMethod> {
1317        self.anonymization_methods.get(method_id)
1318    }
1319
1320    pub fn add_privacy_model(&mut self, model: PrivacyModel) {
1321        self.privacy_models.insert(model.model_id.clone(), model);
1322    }
1323
1324    pub fn get_privacy_model(&self, model_id: &str) -> Option<&PrivacyModel> {
1325        self.privacy_models.get(model_id)
1326    }
1327
1328    pub fn risk_assessment(&self) -> &RiskAssessment {
1329        &self.risk_assessment
1330    }
1331}
1332
1333impl RiskAssessment {
1334    pub fn new() -> Self {
1335        Self {
1336            risk_models: HashMap::new(),
1337            risk_metrics: HashMap::new(),
1338        }
1339    }
1340
1341    pub fn add_risk_model(&mut self, model: RiskModel) {
1342        self.risk_models.insert(model.model_id.clone(), model);
1343    }
1344
1345    pub fn get_risk_model(&self, model_id: &str) -> Option<&RiskModel> {
1346        self.risk_models.get(model_id)
1347    }
1348
1349    pub fn add_risk_metric(&mut self, metric: RiskMetric) {
1350        self.risk_metrics.insert(metric.metric_id.clone(), metric);
1351    }
1352
1353    pub fn get_risk_metric(&self, metric_id: &str) -> Option<&RiskMetric> {
1354        self.risk_metrics.get(metric_id)
1355    }
1356
1357    pub fn assess_risk(&self, factors: &[RiskFactor]) -> f64 {
1358        if factors.is_empty() {
1359            return 0.0;
1360        }
1361        let total_weight: f64 = factors.iter().map(|f| f.factor_weight).sum();
1362        if total_weight == 0.0 {
1363            return 0.0;
1364        }
1365        factors
1366            .iter()
1367            .map(|f| f.factor_weight * f.factor_value)
1368            .sum::<f64>()
1369            / total_weight
1370    }
1371}
1372
1373impl AccessLogging {
1374    pub fn new() -> Self {
1375        Self {
1376            log_entries: HashMap::new(),
1377            log_analysis: LogAnalysis::new(),
1378            retention_policy: RetentionPolicy::new(),
1379        }
1380    }
1381
1382    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1383        Ok(())
1384    }
1385
1386    pub fn add_log_entry(&mut self, entry: LogEntry) {
1387        self.log_entries.insert(entry.entry_id.clone(), entry);
1388    }
1389
1390    pub fn get_log_entry(&self, entry_id: &str) -> Option<&LogEntry> {
1391        self.log_entries.get(entry_id)
1392    }
1393
1394    pub fn log_analysis(&self) -> &LogAnalysis {
1395        &self.log_analysis
1396    }
1397
1398    pub fn retention_policy(&self) -> &RetentionPolicy {
1399        &self.retention_policy
1400    }
1401}
1402
1403impl LogAnalysis {
1404    pub fn new() -> Self {
1405        Self {
1406            analysis_methods: HashMap::new(),
1407            anomaly_detection: AnomalyDetection::new(),
1408        }
1409    }
1410
1411    pub fn add_analysis_method(&mut self, method: AnalysisMethod) {
1412        self.analysis_methods
1413            .insert(method.method_id.clone(), method);
1414    }
1415
1416    pub fn get_analysis_method(&self, method_id: &str) -> Option<&AnalysisMethod> {
1417        self.analysis_methods.get(method_id)
1418    }
1419
1420    pub fn anomaly_detection(&self) -> &AnomalyDetection {
1421        &self.anomaly_detection
1422    }
1423}
1424
1425impl AnomalyDetection {
1426    pub fn new() -> Self {
1427        Self {
1428            detection_algorithms: HashMap::new(),
1429            alert_thresholds: HashMap::new(),
1430        }
1431    }
1432
1433    pub fn add_detection_algorithm(&mut self, algorithm: DetectionAlgorithm) {
1434        self.detection_algorithms
1435            .insert(algorithm.algorithm_id.clone(), algorithm);
1436    }
1437
1438    pub fn get_detection_algorithm(&self, algorithm_id: &str) -> Option<&DetectionAlgorithm> {
1439        self.detection_algorithms.get(algorithm_id)
1440    }
1441
1442    pub fn set_alert_threshold(&mut self, metric_name: &str, threshold: f64) {
1443        self.alert_thresholds
1444            .insert(metric_name.to_string(), threshold);
1445    }
1446
1447    pub fn get_alert_threshold(&self, metric_name: &str) -> Option<&f64> {
1448        self.alert_thresholds.get(metric_name)
1449    }
1450}
1451
1452impl RetentionPolicy {
1453    pub fn new() -> Self {
1454        Self {
1455            policy_id: "policy_1".to_string(),
1456            policy_name: "Log Retention Policy".to_string(),
1457            retention_period: 2555, // 7 years
1458            archival_period: 3650,  // 10 years
1459            deletion_method: DeletionMethod::SecureDelete,
1460        }
1461    }
1462}
1463
1464impl ConsentManagement {
1465    pub fn new() -> Self {
1466        Self {
1467            consent_records: HashMap::new(),
1468            consent_policies: HashMap::new(),
1469            consent_workflows: HashMap::new(),
1470        }
1471    }
1472
1473    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1474        Ok(())
1475    }
1476
1477    pub fn add_consent_record(&mut self, record: ConsentRecord) {
1478        self.consent_records
1479            .insert(record.record_id.clone(), record);
1480    }
1481
1482    pub fn get_consent_record(&self, record_id: &str) -> Option<&ConsentRecord> {
1483        self.consent_records.get(record_id)
1484    }
1485
1486    pub fn add_consent_policy(&mut self, policy: ConsentPolicy) {
1487        self.consent_policies
1488            .insert(policy.policy_id.clone(), policy);
1489    }
1490
1491    pub fn get_consent_policy(&self, policy_id: &str) -> Option<&ConsentPolicy> {
1492        self.consent_policies.get(policy_id)
1493    }
1494
1495    pub fn add_consent_workflow(&mut self, workflow: ConsentWorkflow) {
1496        self.consent_workflows
1497            .insert(workflow.workflow_id.clone(), workflow);
1498    }
1499
1500    pub fn get_consent_workflow(&self, workflow_id: &str) -> Option<&ConsentWorkflow> {
1501        self.consent_workflows.get(workflow_id)
1502    }
1503}
1504
1505impl DataAccessControl {
1506    pub fn new() -> Self {
1507        Self {
1508            access_policies: HashMap::new(),
1509            authentication: AuthenticationSystem::new(),
1510            authorization: AuthorizationSystem::new(),
1511        }
1512    }
1513
1514    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1515        self.authentication.initialize()?;
1516        self.authorization.initialize()?;
1517        Ok(())
1518    }
1519
1520    pub fn add_access_policy(&mut self, policy: AccessPolicy) {
1521        self.access_policies
1522            .insert(policy.policy_id.clone(), policy);
1523    }
1524
1525    pub fn get_access_policy(&self, policy_id: &str) -> Option<&AccessPolicy> {
1526        self.access_policies.get(policy_id)
1527    }
1528
1529    pub fn list_access_policies(&self) -> Vec<String> {
1530        self.access_policies.keys().cloned().collect()
1531    }
1532}
1533
1534impl AuthenticationSystem {
1535    pub fn new() -> Self {
1536        Self {
1537            authentication_methods: HashMap::new(),
1538            session_management: SessionManagement::new(),
1539            multi_factor: MultiFactorAuthentication::new(),
1540        }
1541    }
1542
1543    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1544        Ok(())
1545    }
1546
1547    pub fn add_authentication_method(&mut self, method: AuthenticationMethod) {
1548        self.authentication_methods
1549            .insert(method.method_id.clone(), method);
1550    }
1551
1552    pub fn get_authentication_method(&self, method_id: &str) -> Option<&AuthenticationMethod> {
1553        self.authentication_methods.get(method_id)
1554    }
1555
1556    pub fn session_management(&self) -> &SessionManagement {
1557        &self.session_management
1558    }
1559
1560    pub fn multi_factor(&self) -> &MultiFactorAuthentication {
1561        &self.multi_factor
1562    }
1563}
1564
1565impl SessionManagement {
1566    pub fn new() -> Self {
1567        Self {
1568            sessions: HashMap::new(),
1569            session_policies: HashMap::new(),
1570        }
1571    }
1572
1573    pub fn add_session(&mut self, session: Session) {
1574        self.sessions.insert(session.session_id.clone(), session);
1575    }
1576
1577    pub fn get_session(&self, session_id: &str) -> Option<&Session> {
1578        self.sessions.get(session_id)
1579    }
1580
1581    pub fn remove_session(&mut self, session_id: &str) -> Option<Session> {
1582        self.sessions.remove(session_id)
1583    }
1584
1585    pub fn add_session_policy(&mut self, policy: SessionPolicy) {
1586        self.session_policies
1587            .insert(policy.policy_id.clone(), policy);
1588    }
1589
1590    pub fn get_session_policy(&self, policy_id: &str) -> Option<&SessionPolicy> {
1591        self.session_policies.get(policy_id)
1592    }
1593}
1594
1595impl MultiFactorAuthentication {
1596    pub fn new() -> Self {
1597        Self {
1598            factors: HashMap::new(),
1599            factor_combinations: HashMap::new(),
1600        }
1601    }
1602
1603    pub fn add_factor(&mut self, factor: AuthenticationFactor) {
1604        self.factors.insert(factor.factor_id.clone(), factor);
1605    }
1606
1607    pub fn get_factor(&self, factor_id: &str) -> Option<&AuthenticationFactor> {
1608        self.factors.get(factor_id)
1609    }
1610
1611    pub fn add_factor_combination(&mut self, combination: FactorCombination) {
1612        self.factor_combinations
1613            .insert(combination.combination_id.clone(), combination);
1614    }
1615
1616    pub fn get_factor_combination(&self, combination_id: &str) -> Option<&FactorCombination> {
1617        self.factor_combinations.get(combination_id)
1618    }
1619}
1620
1621impl AuthorizationSystem {
1622    pub fn new() -> Self {
1623        Self {
1624            authorization_policies: HashMap::new(),
1625            permission_management: PermissionManagement::new(),
1626            role_management: RoleManagement::new(),
1627        }
1628    }
1629
1630    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1631        Ok(())
1632    }
1633
1634    pub fn add_authorization_policy(&mut self, policy: AuthorizationPolicy) {
1635        self.authorization_policies
1636            .insert(policy.policy_id.clone(), policy);
1637    }
1638
1639    pub fn get_authorization_policy(&self, policy_id: &str) -> Option<&AuthorizationPolicy> {
1640        self.authorization_policies.get(policy_id)
1641    }
1642
1643    pub fn permission_management(&self) -> &PermissionManagement {
1644        &self.permission_management
1645    }
1646
1647    pub fn role_management(&self) -> &RoleManagement {
1648        &self.role_management
1649    }
1650}
1651
1652impl PermissionManagement {
1653    pub fn new() -> Self {
1654        Self {
1655            permissions: HashMap::new(),
1656            permission_groups: HashMap::new(),
1657        }
1658    }
1659
1660    pub fn add_permission(&mut self, name: &str, permission: Permission) {
1661        self.permissions.insert(name.to_string(), permission);
1662    }
1663
1664    pub fn get_permission(&self, name: &str) -> Option<&Permission> {
1665        self.permissions.get(name)
1666    }
1667
1668    pub fn add_permission_group(&mut self, group: PermissionGroup) {
1669        self.permission_groups.insert(group.group_id.clone(), group);
1670    }
1671
1672    pub fn get_permission_group(&self, group_id: &str) -> Option<&PermissionGroup> {
1673        self.permission_groups.get(group_id)
1674    }
1675}
1676
1677impl RoleManagement {
1678    pub fn new() -> Self {
1679        Self {
1680            roles: HashMap::new(),
1681            role_hierarchy: RoleHierarchy::new(),
1682        }
1683    }
1684
1685    pub fn add_role(&mut self, role: Role) {
1686        self.roles.insert(role.role_id.clone(), role);
1687    }
1688
1689    pub fn get_role(&self, role_id: &str) -> Option<&Role> {
1690        self.roles.get(role_id)
1691    }
1692
1693    pub fn role_hierarchy(&self) -> &RoleHierarchy {
1694        &self.role_hierarchy
1695    }
1696}
1697
1698impl RoleHierarchy {
1699    pub fn new() -> Self {
1700        Self {
1701            hierarchy_id: "hierarchy_1".to_string(),
1702            parent_roles: Vec::new(),
1703            child_roles: Vec::new(),
1704        }
1705    }
1706}
qualia_core_db/specialized_libs/medical_computing/privacy.rs

qualia_core_db/specialized_libs/medical_computing/
privacy.rs
