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(
64 id_prefix: String,
65 preserve_hierarchy: bool,
66 merge_duplicate_permissions: bool,
67 ) -> Self {
68 Self {
69 id_prefix,
70 preserve_hierarchy,
71 merge_duplicate_permissions,
72 }
73 }
74
75 pub fn convert_role(&self, legacy_role: &LegacyRole) -> Result<ConvertedRole, MigrationError> {
77 let now = chrono::Utc::now();
78
79 let mut permissions = legacy_role.permissions.clone();
80
81 if self.merge_duplicate_permissions {
83 permissions.sort();
84 permissions.dedup();
85 }
86
87 let parent_role_id = if self.preserve_hierarchy && !legacy_role.parent_roles.is_empty() {
89 Some(format!("{}{}", self.id_prefix, legacy_role.parent_roles[0]))
91 } else {
92 None
93 };
94
95 let mut metadata = legacy_role.metadata.clone();
97
98 metadata.insert("migration_source".to_string(), "legacy_system".to_string());
100 metadata.insert("original_id".to_string(), legacy_role.id.clone());
101
102 if legacy_role.parent_roles.len() > 1 {
103 metadata.insert(
104 "original_parent_roles".to_string(),
105 legacy_role.parent_roles.join(","),
106 );
107 }
108
109 Ok(ConvertedRole {
110 id: format!("{}{}", self.id_prefix, legacy_role.id),
111 name: legacy_role.name.clone(),
112 description: legacy_role.description.clone(),
113 permissions,
114 parent_role_id,
115 metadata,
116 created_at: now,
117 updated_at: now,
118 })
119 }
120
121 pub fn convert_roles(
123 &self,
124 legacy_roles: &[LegacyRole],
125 ) -> Result<Vec<ConvertedRole>, MigrationError> {
126 let mut converted_roles = Vec::new();
127 let mut role_map: HashMap<String, &LegacyRole> = HashMap::new();
128
129 for role in legacy_roles {
131 role_map.insert(role.id.clone(), role);
132 }
133
134 let ordered_roles = self.order_roles_by_dependencies(legacy_roles)?;
136
137 for role in ordered_roles {
138 let converted = self.convert_role(role)?;
139 converted_roles.push(converted);
140 }
141
142 Ok(converted_roles)
143 }
144
145 fn order_roles_by_dependencies<'a>(
147 &self,
148 roles: &'a [LegacyRole],
149 ) -> Result<Vec<&'a LegacyRole>, MigrationError> {
150 let mut ordered = Vec::new();
151 let mut visited = std::collections::HashSet::new();
152 let mut visiting = std::collections::HashSet::new();
153 let role_map: HashMap<String, &LegacyRole> =
154 roles.iter().map(|role| (role.id.clone(), role)).collect();
155
156 for role in roles {
157 if !visited.contains(&role.id) {
158 self.visit_role_dependencies(
159 role,
160 &role_map,
161 &mut ordered,
162 &mut visited,
163 &mut visiting,
164 )?;
165 }
166 }
167
168 Ok(ordered)
169 }
170
171 #[allow(clippy::only_used_in_recursion)]
173 fn visit_role_dependencies<'a>(
174 &self,
175 role: &'a LegacyRole,
176 role_map: &HashMap<String, &'a LegacyRole>,
177 ordered: &mut Vec<&'a LegacyRole>,
178 visited: &mut std::collections::HashSet<String>,
179 visiting: &mut std::collections::HashSet<String>,
180 ) -> Result<(), MigrationError> {
181 if visiting.contains(&role.id) {
182 return Err(MigrationError::AnalysisError(format!(
183 "Circular dependency detected involving role '{}'",
184 role.id
185 )));
186 }
187
188 if visited.contains(&role.id) {
189 return Ok(());
190 }
191
192 visiting.insert(role.id.clone());
193
194 for parent_id in &role.parent_roles {
196 if let Some(parent_role) = role_map.get(parent_id) {
197 self.visit_role_dependencies(parent_role, role_map, ordered, visited, visiting)?;
198 }
199 }
200
201 visiting.remove(&role.id);
202 visited.insert(role.id.clone());
203 ordered.push(role);
204
205 Ok(())
206 }
207}
208
209pub struct PermissionConverter {
211 id_prefix: String,
212 normalize_actions: bool,
213 normalize_resources: bool,
214}
215
216impl Default for PermissionConverter {
217 fn default() -> Self {
218 Self {
219 id_prefix: "migrated_".to_string(),
220 normalize_actions: true,
221 normalize_resources: true,
222 }
223 }
224}
225
226impl PermissionConverter {
227 pub fn new(id_prefix: String, normalize_actions: bool, normalize_resources: bool) -> Self {
229 Self {
230 id_prefix,
231 normalize_actions,
232 normalize_resources,
233 }
234 }
235
236 pub fn convert_permission(
238 &self,
239 legacy_permission: &LegacyPermission,
240 ) -> Result<ConvertedPermission, MigrationError> {
241 let now = chrono::Utc::now();
242
243 let action = if self.normalize_actions {
244 self.normalize_action(&legacy_permission.action)
245 } else {
246 legacy_permission.action.clone()
247 };
248
249 let resource = if self.normalize_resources {
250 self.normalize_resource(&legacy_permission.resource)
251 } else {
252 legacy_permission.resource.clone()
253 };
254
255 let mut conditions = legacy_permission.conditions.clone();
256
257 conditions.insert("migration_source".to_string(), "legacy_system".to_string());
259 conditions.insert("original_id".to_string(), legacy_permission.id.clone());
260
261 Ok(ConvertedPermission {
262 id: format!("{}{}", self.id_prefix, legacy_permission.id),
263 action,
264 resource,
265 conditions,
266 created_at: now,
267 })
268 }
269
270 pub fn convert_permissions(
272 &self,
273 legacy_permissions: &[LegacyPermission],
274 ) -> Result<Vec<ConvertedPermission>, MigrationError> {
275 legacy_permissions
276 .iter()
277 .map(|perm| self.convert_permission(perm))
278 .collect()
279 }
280
281 fn normalize_action(&self, action: &str) -> String {
283 match action.to_lowercase().as_str() {
284 "read" | "view" | "get" | "list" => "read".to_string(),
285 "write" | "create" | "post" | "add" => "create".to_string(),
286 "update" | "put" | "patch" | "modify" | "edit" => "update".to_string(),
287 "delete" | "remove" | "destroy" => "delete".to_string(),
288 "execute" | "run" | "invoke" => "execute".to_string(),
289 "admin" | "manage" | "administrate" => "manage".to_string(),
290 _ => action.to_string(),
291 }
292 }
293
294 fn normalize_resource(&self, resource: &str) -> String {
296 resource
298 .to_lowercase()
299 .replace("-", "_")
300 .replace(" ", "_")
301 .replace("/", "_")
302 }
303}
304
305pub struct UserAssignmentConverter {
307 default_assigned_by: Option<String>,
308 preserve_expiration: bool,
309}
310
311impl Default for UserAssignmentConverter {
312 fn default() -> Self {
313 Self {
314 default_assigned_by: Some("migration_system".to_string()),
315 preserve_expiration: true,
316 }
317 }
318}
319
320impl UserAssignmentConverter {
321 pub fn new(default_assigned_by: Option<String>, preserve_expiration: bool) -> Self {
323 Self {
324 default_assigned_by,
325 preserve_expiration,
326 }
327 }
328
329 pub fn convert_user_assignment(
331 &self,
332 legacy_assignment: &LegacyUserAssignment,
333 role_mappings: &HashMap<String, String>,
334 ) -> Result<Option<ConvertedUserAssignment>, MigrationError> {
335 let now = chrono::Utc::now();
336
337 let role_id = if let Some(legacy_role_id) = &legacy_assignment.role_id {
339 if let Some(new_role_id) = role_mappings.get(legacy_role_id) {
340 new_role_id.clone()
341 } else {
342 return Err(MigrationError::AnalysisError(format!(
343 "No role mapping found for legacy role '{}'",
344 legacy_role_id
345 )));
346 }
347 } else {
348 return Ok(None); };
351
352 let expires_at = if self.preserve_expiration {
353 legacy_assignment.expiration
354 } else {
355 None
356 };
357
358 let mut metadata = HashMap::new();
359
360 for (key, value) in &legacy_assignment.attributes {
362 metadata.insert(key.clone(), value.clone());
363 }
364
365 metadata.insert("migration_source".to_string(), "legacy_system".to_string());
367 metadata.insert(
368 "original_permissions".to_string(),
369 legacy_assignment.permissions.join(","),
370 );
371
372 Ok(Some(ConvertedUserAssignment {
373 user_id: legacy_assignment.user_id.clone(),
374 role_id,
375 assigned_at: now,
376 assigned_by: self.default_assigned_by.clone(),
377 expires_at,
378 metadata,
379 }))
380 }
381
382 pub fn convert_user_assignments(
384 &self,
385 legacy_assignments: &[LegacyUserAssignment],
386 role_mappings: &HashMap<String, String>,
387 ) -> Result<Vec<ConvertedUserAssignment>, MigrationError> {
388 let mut converted = Vec::new();
389
390 for assignment in legacy_assignments {
391 if let Some(converted_assignment) =
392 self.convert_user_assignment(assignment, role_mappings)?
393 {
394 converted.push(converted_assignment);
395 }
396 }
397
398 Ok(converted)
399 }
400}
401
402#[derive(Default)]
404pub struct LegacySystemConverter {
405 role_converter: RoleConverter,
406 permission_converter: PermissionConverter,
407 user_assignment_converter: UserAssignmentConverter,
408}
409
410impl LegacySystemConverter {
411 pub fn new(
413 role_converter: RoleConverter,
414 permission_converter: PermissionConverter,
415 user_assignment_converter: UserAssignmentConverter,
416 ) -> Self {
417 Self {
418 role_converter,
419 permission_converter,
420 user_assignment_converter,
421 }
422 }
423
424 pub fn convert_system(
426 &self,
427 legacy_roles: &[LegacyRole],
428 legacy_permissions: &[LegacyPermission],
429 legacy_assignments: &[LegacyUserAssignment],
430 ) -> Result<ConvertedSystem, MigrationError> {
431 let converted_roles = self.role_converter.convert_roles(legacy_roles)?;
433
434 let role_mappings: HashMap<String, String> = legacy_roles
436 .iter()
437 .zip(&converted_roles)
438 .map(|(legacy, converted)| (legacy.id.clone(), converted.id.clone()))
439 .collect();
440
441 let converted_permissions = self
443 .permission_converter
444 .convert_permissions(legacy_permissions)?;
445
446 let converted_assignments = self
448 .user_assignment_converter
449 .convert_user_assignments(legacy_assignments, &role_mappings)?;
450
451 Ok(ConvertedSystem {
452 roles: converted_roles,
453 permissions: converted_permissions,
454 user_assignments: converted_assignments,
455 role_mappings,
456 conversion_metadata: self.generate_conversion_metadata(
457 legacy_roles,
458 legacy_permissions,
459 legacy_assignments,
460 ),
461 })
462 }
463
464 fn generate_conversion_metadata(
466 &self,
467 legacy_roles: &[LegacyRole],
468 legacy_permissions: &[LegacyPermission],
469 legacy_assignments: &[LegacyUserAssignment],
470 ) -> ConversionMetadata {
471 ConversionMetadata {
472 converted_at: chrono::Utc::now(),
473 legacy_role_count: legacy_roles.len(),
474 legacy_permission_count: legacy_permissions.len(),
475 legacy_assignment_count: legacy_assignments.len(),
476 conversion_summary: format!(
477 "Converted {} roles, {} permissions, and {} user assignments",
478 legacy_roles.len(),
479 legacy_permissions.len(),
480 legacy_assignments.len()
481 ),
482 }
483 }
484}
485
486#[derive(Debug, Clone, Serialize, Deserialize)]
488pub struct ConvertedSystem {
489 pub roles: Vec<ConvertedRole>,
490 pub permissions: Vec<ConvertedPermission>,
491 pub user_assignments: Vec<ConvertedUserAssignment>,
492 pub role_mappings: HashMap<String, String>,
493 pub conversion_metadata: ConversionMetadata,
494}
495
496#[derive(Debug, Clone, Serialize, Deserialize)]
498pub struct ConversionMetadata {
499 pub converted_at: chrono::DateTime<chrono::Utc>,
500 pub legacy_role_count: usize,
501 pub legacy_permission_count: usize,
502 pub legacy_assignment_count: usize,
503 pub conversion_summary: String,
504}
505
506#[cfg(test)]
507mod tests {
508 use super::*;
509
510 fn create_test_role() -> LegacyRole {
511 LegacyRole {
512 id: "admin".to_string(),
513 name: "Administrator".to_string(),
514 description: Some("Admin role".to_string()),
515 permissions: vec!["read".to_string(), "write".to_string(), "read".to_string()], parent_roles: vec!["super_admin".to_string()],
517 metadata: {
518 let mut map = HashMap::new();
519 map.insert("priority".to_string(), "high".to_string());
520 map
521 },
522 }
523 }
524
525 #[test]
526 fn test_role_converter() {
527 let converter = RoleConverter::default();
528 let legacy_role = create_test_role();
529
530 let converted = converter.convert_role(&legacy_role).unwrap();
531
532 assert_eq!(converted.id, "migrated_admin");
533 assert_eq!(converted.name, "Administrator");
534 assert_eq!(converted.permissions.len(), 2); assert_eq!(
536 converted.parent_role_id,
537 Some("migrated_super_admin".to_string())
538 );
539 assert!(converted.metadata.contains_key("migration_source"));
540 }
541
542 #[test]
543 fn test_permission_converter() {
544 let converter = PermissionConverter::default();
545 let legacy_permission = LegacyPermission {
546 id: "read_data".to_string(),
547 action: "VIEW".to_string(),
548 resource: "User-Data".to_string(),
549 conditions: HashMap::new(),
550 metadata: HashMap::new(),
551 };
552
553 let converted = converter.convert_permission(&legacy_permission).unwrap();
554
555 assert_eq!(converted.id, "migrated_read_data");
556 assert_eq!(converted.action, "read"); assert_eq!(converted.resource, "user_data"); assert!(converted.conditions.contains_key("migration_source"));
559 }
560
561 #[test]
562 fn test_user_assignment_converter() {
563 let converter = UserAssignmentConverter::default();
564 let legacy_assignment = LegacyUserAssignment {
565 user_id: "user123".to_string(),
566 role_id: Some("admin".to_string()),
567 permissions: vec!["read".to_string()],
568 attributes: {
569 let mut map = HashMap::new();
570 map.insert("department".to_string(), "IT".to_string());
571 map
572 },
573 expiration: None,
574 };
575
576 let mut role_mappings = HashMap::new();
577 role_mappings.insert("admin".to_string(), "migrated_admin".to_string());
578
579 let converted = converter
580 .convert_user_assignment(&legacy_assignment, &role_mappings)
581 .unwrap()
582 .unwrap();
583
584 assert_eq!(converted.user_id, "user123");
585 assert_eq!(converted.role_id, "migrated_admin");
586 assert!(converted.metadata.contains_key("department"));
587 assert!(converted.metadata.contains_key("migration_source"));
588 }
589
590 #[test]
591 fn test_system_converter() {
592 let converter = LegacySystemConverter::default();
593
594 let legacy_roles = vec![create_test_role()];
595 let legacy_permissions = vec![];
596 let legacy_assignments = vec![];
597
598 let converted_system = converter
599 .convert_system(&legacy_roles, &legacy_permissions, &legacy_assignments)
600 .unwrap();
601
602 assert_eq!(converted_system.roles.len(), 1);
603 assert_eq!(converted_system.permissions.len(), 0);
604 assert_eq!(converted_system.user_assignments.len(), 0);
605 assert_eq!(converted_system.role_mappings.len(), 1);
606 }
607}