1use super::{LegacyPermission, LegacyRole, LegacyUserAssignment, MigrationError};
7use serde::{Deserialize, Serialize};
8use std::collections::HashMap;
9
10#[derive(Debug, Clone, Serialize, Deserialize)]
12pub struct ConvertedRole {
13 pub id: String,
14 pub name: String,
15 pub description: Option<String>,
16 pub permissions: Vec<String>,
17 pub parent_role_id: Option<String>,
18 pub metadata: HashMap<String, String>,
19 pub created_at: chrono::DateTime<chrono::Utc>,
20 pub updated_at: chrono::DateTime<chrono::Utc>,
21}
22
23#[derive(Debug, Clone, Serialize, Deserialize)]
25pub struct ConvertedPermission {
26 pub id: String,
27 pub action: String,
28 pub resource: String,
29 pub conditions: HashMap<String, String>,
30 pub created_at: chrono::DateTime<chrono::Utc>,
31}
32
33#[derive(Debug, Clone, Serialize, Deserialize)]
35pub struct ConvertedUserAssignment {
36 pub user_id: String,
37 pub role_id: String,
38 pub assigned_at: chrono::DateTime<chrono::Utc>,
39 pub assigned_by: Option<String>,
40 pub expires_at: Option<chrono::DateTime<chrono::Utc>>,
41 pub metadata: HashMap<String, String>,
42}
43
44pub struct RoleConverter {
46 id_prefix: String,
47 preserve_hierarchy: bool,
48 merge_duplicate_permissions: bool,
49}
50
51impl Default for RoleConverter {
52 fn default() -> Self {
53 Self {
54 id_prefix: "migrated_".to_string(),
55 preserve_hierarchy: true,
56 merge_duplicate_permissions: true,
57 }
58 }
59}
60
61impl RoleConverter {
62 pub fn new(
72 id_prefix: String,
73 preserve_hierarchy: bool,
74 merge_duplicate_permissions: bool,
75 ) -> Self {
76 Self {
77 id_prefix,
78 preserve_hierarchy,
79 merge_duplicate_permissions,
80 }
81 }
82
83 pub fn with_id_prefix(mut self, prefix: impl Into<String>) -> Self {
85 self.id_prefix = prefix.into();
86 self
87 }
88
89 pub fn with_hierarchy(mut self) -> Self {
91 self.preserve_hierarchy = true;
92 self
93 }
94
95 pub fn without_hierarchy(mut self) -> Self {
97 self.preserve_hierarchy = false;
98 self
99 }
100
101 pub fn with_deduplication(mut self) -> Self {
103 self.merge_duplicate_permissions = true;
104 self
105 }
106
107 pub fn without_deduplication(mut self) -> Self {
109 self.merge_duplicate_permissions = false;
110 self
111 }
112
113 pub fn convert_role(&self, legacy_role: &LegacyRole) -> Result<ConvertedRole, MigrationError> {
115 let now = chrono::Utc::now();
116
117 let mut permissions = legacy_role.permissions.clone();
118
119 if self.merge_duplicate_permissions {
121 permissions.sort();
122 permissions.dedup();
123 }
124
125 let parent_role_id = if self.preserve_hierarchy && !legacy_role.parent_roles.is_empty() {
127 Some(format!("{}{}", self.id_prefix, legacy_role.parent_roles[0]))
129 } else {
130 None
131 };
132
133 let mut metadata = legacy_role.metadata.clone();
135
136 metadata.insert("migration_source".to_string(), "legacy_system".to_string());
138 metadata.insert("original_id".to_string(), legacy_role.id.clone());
139
140 if legacy_role.parent_roles.len() > 1 {
141 metadata.insert(
142 "original_parent_roles".to_string(),
143 legacy_role.parent_roles.join(","),
144 );
145 }
146
147 Ok(ConvertedRole {
148 id: format!("{}{}", self.id_prefix, legacy_role.id),
149 name: legacy_role.name.clone(),
150 description: legacy_role.description.clone(),
151 permissions,
152 parent_role_id,
153 metadata,
154 created_at: now,
155 updated_at: now,
156 })
157 }
158
159 pub fn convert_roles(
161 &self,
162 legacy_roles: &[LegacyRole],
163 ) -> Result<Vec<ConvertedRole>, MigrationError> {
164 let mut converted_roles = Vec::new();
165 let mut role_map: HashMap<String, &LegacyRole> = HashMap::new();
166
167 for role in legacy_roles {
169 role_map.insert(role.id.clone(), role);
170 }
171
172 let ordered_roles = self.order_roles_by_dependencies(legacy_roles)?;
174
175 for role in ordered_roles {
176 let converted = self.convert_role(role)?;
177 converted_roles.push(converted);
178 }
179
180 Ok(converted_roles)
181 }
182
183 fn order_roles_by_dependencies<'a>(
185 &self,
186 roles: &'a [LegacyRole],
187 ) -> Result<Vec<&'a LegacyRole>, MigrationError> {
188 let mut ordered = Vec::new();
189 let mut visited = std::collections::HashSet::new();
190 let mut visiting = std::collections::HashSet::new();
191 let role_map: HashMap<String, &LegacyRole> =
192 roles.iter().map(|role| (role.id.clone(), role)).collect();
193
194 for role in roles {
195 if !visited.contains(&role.id) {
196 self.visit_role_dependencies(
197 role,
198 &role_map,
199 &mut ordered,
200 &mut visited,
201 &mut visiting,
202 )?;
203 }
204 }
205
206 Ok(ordered)
207 }
208
209 #[allow(clippy::only_used_in_recursion)]
211 fn visit_role_dependencies<'a>(
212 &self,
213 role: &'a LegacyRole,
214 role_map: &HashMap<String, &'a LegacyRole>,
215 ordered: &mut Vec<&'a LegacyRole>,
216 visited: &mut std::collections::HashSet<String>,
217 visiting: &mut std::collections::HashSet<String>,
218 ) -> Result<(), MigrationError> {
219 if visiting.contains(&role.id) {
220 return Err(MigrationError::AnalysisError(format!(
221 "Circular dependency detected involving role '{}'",
222 role.id
223 )));
224 }
225
226 if visited.contains(&role.id) {
227 return Ok(());
228 }
229
230 visiting.insert(role.id.clone());
231
232 for parent_id in &role.parent_roles {
234 if let Some(parent_role) = role_map.get(parent_id) {
235 self.visit_role_dependencies(parent_role, role_map, ordered, visited, visiting)?;
236 }
237 }
238
239 visiting.remove(&role.id);
240 visited.insert(role.id.clone());
241 ordered.push(role);
242
243 Ok(())
244 }
245}
246
247pub struct PermissionConverter {
249 id_prefix: String,
250 normalize_actions: bool,
251 normalize_resources: bool,
252}
253
254impl Default for PermissionConverter {
255 fn default() -> Self {
256 Self {
257 id_prefix: "migrated_".to_string(),
258 normalize_actions: true,
259 normalize_resources: true,
260 }
261 }
262}
263
264impl PermissionConverter {
265 pub fn new(id_prefix: String, normalize_actions: bool, normalize_resources: bool) -> Self {
267 Self {
268 id_prefix,
269 normalize_actions,
270 normalize_resources,
271 }
272 }
273
274 pub fn convert_permission(
276 &self,
277 legacy_permission: &LegacyPermission,
278 ) -> Result<ConvertedPermission, MigrationError> {
279 let now = chrono::Utc::now();
280
281 let action = if self.normalize_actions {
282 self.normalize_action(&legacy_permission.action)
283 } else {
284 legacy_permission.action.clone()
285 };
286
287 let resource = if self.normalize_resources {
288 self.normalize_resource(&legacy_permission.resource)
289 } else {
290 legacy_permission.resource.clone()
291 };
292
293 let mut conditions = legacy_permission.conditions.clone();
294
295 conditions.insert("migration_source".to_string(), "legacy_system".to_string());
297 conditions.insert("original_id".to_string(), legacy_permission.id.clone());
298
299 Ok(ConvertedPermission {
300 id: format!("{}{}", self.id_prefix, legacy_permission.id),
301 action,
302 resource,
303 conditions,
304 created_at: now,
305 })
306 }
307
308 pub fn convert_permissions(
310 &self,
311 legacy_permissions: &[LegacyPermission],
312 ) -> Result<Vec<ConvertedPermission>, MigrationError> {
313 legacy_permissions
314 .iter()
315 .map(|perm| self.convert_permission(perm))
316 .collect()
317 }
318
319 fn normalize_action(&self, action: &str) -> String {
321 match action.to_lowercase().as_str() {
322 "read" | "view" | "get" | "list" => "read".to_string(),
323 "write" | "create" | "post" | "add" => "create".to_string(),
324 "update" | "put" | "patch" | "modify" | "edit" => "update".to_string(),
325 "delete" | "remove" | "destroy" => "delete".to_string(),
326 "execute" | "run" | "invoke" => "execute".to_string(),
327 "admin" | "manage" | "administrate" => "manage".to_string(),
328 _ => action.to_string(),
329 }
330 }
331
332 fn normalize_resource(&self, resource: &str) -> String {
334 resource
336 .to_lowercase()
337 .replace("-", "_")
338 .replace(" ", "_")
339 .replace("/", "_")
340 }
341}
342
343pub struct UserAssignmentConverter {
345 default_assigned_by: Option<String>,
346 preserve_expiration: bool,
347}
348
349impl Default for UserAssignmentConverter {
350 fn default() -> Self {
351 Self {
352 default_assigned_by: Some("migration_system".to_string()),
353 preserve_expiration: true,
354 }
355 }
356}
357
358impl UserAssignmentConverter {
359 pub fn new(default_assigned_by: Option<String>, preserve_expiration: bool) -> Self {
361 Self {
362 default_assigned_by,
363 preserve_expiration,
364 }
365 }
366
367 pub fn convert_user_assignment(
369 &self,
370 legacy_assignment: &LegacyUserAssignment,
371 role_mappings: &HashMap<String, String>,
372 ) -> Result<Option<ConvertedUserAssignment>, MigrationError> {
373 let now = chrono::Utc::now();
374
375 let role_id = if let Some(legacy_role_id) = &legacy_assignment.role_id {
377 if let Some(new_role_id) = role_mappings.get(legacy_role_id) {
378 new_role_id.clone()
379 } else {
380 return Err(MigrationError::AnalysisError(format!(
381 "No role mapping found for legacy role '{}'",
382 legacy_role_id
383 )));
384 }
385 } else {
386 return Ok(None); };
389
390 let expires_at = if self.preserve_expiration {
391 legacy_assignment.expiration
392 } else {
393 None
394 };
395
396 let mut metadata = HashMap::new();
397
398 for (key, value) in &legacy_assignment.attributes {
400 metadata.insert(key.clone(), value.clone());
401 }
402
403 metadata.insert("migration_source".to_string(), "legacy_system".to_string());
405 metadata.insert(
406 "original_permissions".to_string(),
407 legacy_assignment.permissions.join(","),
408 );
409
410 Ok(Some(ConvertedUserAssignment {
411 user_id: legacy_assignment.user_id.clone(),
412 role_id,
413 assigned_at: now,
414 assigned_by: self.default_assigned_by.clone(),
415 expires_at,
416 metadata,
417 }))
418 }
419
420 pub fn convert_user_assignments(
422 &self,
423 legacy_assignments: &[LegacyUserAssignment],
424 role_mappings: &HashMap<String, String>,
425 ) -> Result<Vec<ConvertedUserAssignment>, MigrationError> {
426 let mut converted = Vec::new();
427
428 for assignment in legacy_assignments {
429 if let Some(converted_assignment) =
430 self.convert_user_assignment(assignment, role_mappings)?
431 {
432 converted.push(converted_assignment);
433 }
434 }
435
436 Ok(converted)
437 }
438}
439
440#[derive(Default)]
442pub struct LegacySystemConverter {
443 role_converter: RoleConverter,
444 permission_converter: PermissionConverter,
445 user_assignment_converter: UserAssignmentConverter,
446}
447
448impl LegacySystemConverter {
449 pub fn new(
451 role_converter: RoleConverter,
452 permission_converter: PermissionConverter,
453 user_assignment_converter: UserAssignmentConverter,
454 ) -> Self {
455 Self {
456 role_converter,
457 permission_converter,
458 user_assignment_converter,
459 }
460 }
461
462 pub fn convert_system(
464 &self,
465 legacy_roles: &[LegacyRole],
466 legacy_permissions: &[LegacyPermission],
467 legacy_assignments: &[LegacyUserAssignment],
468 ) -> Result<ConvertedSystem, MigrationError> {
469 let converted_roles = self.role_converter.convert_roles(legacy_roles)?;
471
472 let role_mappings: HashMap<String, String> = legacy_roles
474 .iter()
475 .zip(&converted_roles)
476 .map(|(legacy, converted)| (legacy.id.clone(), converted.id.clone()))
477 .collect();
478
479 let converted_permissions = self
481 .permission_converter
482 .convert_permissions(legacy_permissions)?;
483
484 let converted_assignments = self
486 .user_assignment_converter
487 .convert_user_assignments(legacy_assignments, &role_mappings)?;
488
489 Ok(ConvertedSystem {
490 roles: converted_roles,
491 permissions: converted_permissions,
492 user_assignments: converted_assignments,
493 role_mappings,
494 conversion_metadata: self.generate_conversion_metadata(
495 legacy_roles,
496 legacy_permissions,
497 legacy_assignments,
498 ),
499 })
500 }
501
502 fn generate_conversion_metadata(
504 &self,
505 legacy_roles: &[LegacyRole],
506 legacy_permissions: &[LegacyPermission],
507 legacy_assignments: &[LegacyUserAssignment],
508 ) -> ConversionMetadata {
509 ConversionMetadata {
510 converted_at: chrono::Utc::now(),
511 legacy_role_count: legacy_roles.len(),
512 legacy_permission_count: legacy_permissions.len(),
513 legacy_assignment_count: legacy_assignments.len(),
514 conversion_summary: format!(
515 "Converted {} roles, {} permissions, and {} user assignments",
516 legacy_roles.len(),
517 legacy_permissions.len(),
518 legacy_assignments.len()
519 ),
520 }
521 }
522}
523
524#[derive(Debug, Clone, Serialize, Deserialize)]
526pub struct ConvertedSystem {
527 pub roles: Vec<ConvertedRole>,
528 pub permissions: Vec<ConvertedPermission>,
529 pub user_assignments: Vec<ConvertedUserAssignment>,
530 pub role_mappings: HashMap<String, String>,
531 pub conversion_metadata: ConversionMetadata,
532}
533
534#[derive(Debug, Clone, Serialize, Deserialize)]
536pub struct ConversionMetadata {
537 pub converted_at: chrono::DateTime<chrono::Utc>,
538 pub legacy_role_count: usize,
539 pub legacy_permission_count: usize,
540 pub legacy_assignment_count: usize,
541 pub conversion_summary: String,
542}
543
544#[cfg(test)]
545mod tests {
546 use super::*;
547
548 fn create_test_role() -> LegacyRole {
549 LegacyRole {
550 id: "admin".to_string(),
551 name: "Administrator".to_string(),
552 description: Some("Admin role".to_string()),
553 permissions: vec!["read".to_string(), "write".to_string(), "read".to_string()], parent_roles: vec!["super_admin".to_string()],
555 metadata: {
556 let mut map = HashMap::new();
557 map.insert("priority".to_string(), "high".to_string());
558 map
559 },
560 }
561 }
562
563 #[test]
564 fn test_role_converter() {
565 let converter = RoleConverter::default();
566 let legacy_role = create_test_role();
567
568 let converted = converter.convert_role(&legacy_role).unwrap();
569
570 assert_eq!(converted.id, "migrated_admin");
571 assert_eq!(converted.name, "Administrator");
572 assert_eq!(converted.permissions.len(), 2); assert_eq!(
574 converted.parent_role_id,
575 Some("migrated_super_admin".to_string())
576 );
577 assert!(converted.metadata.contains_key("migration_source"));
578 }
579
580 #[test]
581 fn test_permission_converter() {
582 let converter = PermissionConverter::default();
583 let legacy_permission = LegacyPermission {
584 id: "read_data".to_string(),
585 action: "VIEW".to_string(),
586 resource: "User-Data".to_string(),
587 conditions: HashMap::new(),
588 metadata: HashMap::new(),
589 };
590
591 let converted = converter.convert_permission(&legacy_permission).unwrap();
592
593 assert_eq!(converted.id, "migrated_read_data");
594 assert_eq!(converted.action, "read"); assert_eq!(converted.resource, "user_data"); assert!(converted.conditions.contains_key("migration_source"));
597 }
598
599 #[test]
600 fn test_user_assignment_converter() {
601 let converter = UserAssignmentConverter::default();
602 let legacy_assignment = LegacyUserAssignment {
603 user_id: "user123".to_string(),
604 role_id: Some("admin".to_string()),
605 permissions: vec!["read".to_string()],
606 attributes: {
607 let mut map = HashMap::new();
608 map.insert("department".to_string(), "IT".to_string());
609 map
610 },
611 expiration: None,
612 };
613
614 let mut role_mappings = HashMap::new();
615 role_mappings.insert("admin".to_string(), "migrated_admin".to_string());
616
617 let converted = converter
618 .convert_user_assignment(&legacy_assignment, &role_mappings)
619 .unwrap()
620 .unwrap();
621
622 assert_eq!(converted.user_id, "user123");
623 assert_eq!(converted.role_id, "migrated_admin");
624 assert!(converted.metadata.contains_key("department"));
625 assert!(converted.metadata.contains_key("migration_source"));
626 }
627
628 #[test]
629 fn test_system_converter() {
630 let converter = LegacySystemConverter::default();
631
632 let legacy_roles = vec![create_test_role()];
633 let legacy_permissions = vec![];
634 let legacy_assignments = vec![];
635
636 let converted_system = converter
637 .convert_system(&legacy_roles, &legacy_permissions, &legacy_assignments)
638 .unwrap();
639
640 assert_eq!(converted_system.roles.len(), 1);
641 assert_eq!(converted_system.permissions.len(), 0);
642 assert_eq!(converted_system.user_assignments.len(), 0);
643 assert_eq!(converted_system.role_mappings.len(), 1);
644 }
645}