unify

2025-07-01 02:20:00 -07:00
parent ebba2083af
commit c8ecd108f7
1 changed files with 84 additions and 108 deletions
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,6 +1,7 @@
 use clap::{Args,Parser,Subcommand};
 use futures::{StreamExt,TryStreamExt};
 use rand::seq::SliceRandom;
+use submissions_api::types::{ScriptResponse,ScriptPolicyResponse};
 use std::io::Write;
 use std::path::PathBuf;

@@ -464,107 +465,26 @@ async fn upload_scripts(config:UploadConfig)->Result<(),ScriptUploadError>{
 #[allow(dead_code)]
 #[derive(Debug)]
 enum RepairError{
-	Duplicates(RepairDuplicatesError),
-	Policies(RepairPoliciesError),
-}
-impl From<RepairDuplicatesError> for RepairError{
-	fn from(value:RepairDuplicatesError)->Self{
-		RepairError::Duplicates(value)
-	}
-}
-impl From<RepairPoliciesError> for RepairError{
-	fn from(value:RepairPoliciesError)->Self{
-		RepairError::Policies(value)
-	}
+	Cookie(submissions_api::CookieError),
+	Reqwest(submissions_api::ReqwestError),
+	GetPolicies(submissions_api::Error),
+	GetScripts(submissions_api::types::Error),
+	GetScript(submissions_api::types::ScriptSingleItemError),
+	UpdateScriptPolicy(submissions_api::Error),
+	DeleteScript(submissions_api::Error),
+	DeleteScriptPolicy(submissions_api::Error),
 }
 struct RepairConfig{
 	session_id:String,
 	api_url:String,
 }
-async fn repair(config:RepairConfig)->Result<(),RepairError>{
-	let cookie=submissions_api::Cookie::new(&config.session_id).map_err(RepairPoliciesError::Cookie)?;
-	let api=&submissions_api::external::Context::new(config.api_url,cookie).map_err(RepairPoliciesError::Reqwest)?;
-
-	tokio::try_join!(
-		repair_duplicates(api),
-		repair_policies(api),
-	)?;
-	Ok(())
-}
-
-#[allow(dead_code)]
-#[derive(Debug)]
-enum RepairPoliciesError{
-	Cookie(submissions_api::CookieError),
-	Reqwest(submissions_api::ReqwestError),
-	GetPolicies(submissions_api::Error),
-	GetScripts(submissions_api::types::ScriptSingleItemError),
-	UpdateScriptPolicy(submissions_api::Error),
-}
-async fn repair_policies(api:&submissions_api::external::Context)->Result<(),RepairError>{
+async fn download_scripts(api:&submissions_api::external::Context)->Result<Vec<ScriptResponse>,RepairError>{
+	let mut scripts=Vec::new();
 	const LIMIT:u32=100;
 	let mut page=1;
 	loop{
-		println!("Downloading page {page}...");
-		let policies=api.get_script_policies(submissions_api::types::GetScriptPoliciesRequest{
-			Page:page,
-			Limit:LIMIT,
-			FromScriptHash:None,
-			ToScriptID:None,
-			Policy:Some(submissions_api::types::Policy::Replace),
-		}).await.map_err(RepairPoliciesError::GetPolicies)?;
-
-		futures::stream::iter(policies.iter().map(Ok)).try_for_each_concurrent(REMOTE_CONCURRENCY,async|policy|{
-			let from_script=api.get_script_from_hash(submissions_api::types::HashRequest{
-				hash:policy.FromScriptHash.as_str(),
-			}).await.map_err(RepairPoliciesError::GetScripts)?;
-
-			if let Some(from_script)=from_script{
-				if policy.ToScriptID==from_script.ID{
-					// invalid policy.  Reset the policy to None
-					api.update_script_policy(submissions_api::types::UpdateScriptPolicyRequest{
-						ID:policy.ID,
-						FromScriptID:None,
-						ToScriptID:None,
-						Policy:Some(submissions_api::types::Policy::None),
-					}).await.map_err(RepairPoliciesError::UpdateScriptPolicy)?;
-					println!("Policy updated! {:?}",policy.ID);
-				}
-			}else{
-				println!("Script did not exist! hash={}",policy.FromScriptHash);
-			}
-			Ok(())
-		}).await.map_err(RepairError::Policies)?;
-
-		if policies.len()<LIMIT as usize{
-			// We scanned all policies
-			println!("Done!");
-			break;
-		}else{
-			page+=1;
-		}
-	}
-
-	Ok(())
-}
-
-#[allow(dead_code)]
-#[derive(Debug)]
-enum RepairDuplicatesError{
-	Cookie(submissions_api::CookieError),
-	Reqwest(submissions_api::ReqwestError),
-	GetScripts(submissions_api::Error),
-	DeleteScript(submissions_api::Error),
-}
-
-async fn repair_duplicates(api:&submissions_api::external::Context)->Result<(),RepairError>{
-	let mut sources=std::collections::HashSet::new();
-
-	const LIMIT:u32=100;
-	let mut page=1;
-	loop{
-		println!("Downloading page {page}...");
-		let scripts=api.get_scripts(submissions_api::types::GetScriptsRequest{
+		println!("Downloading scripts page {page}...");
+		scripts.extend(api.get_scripts(submissions_api::types::GetScriptsRequest{
 			Page:page,
 			Limit:LIMIT,
 			Name:None,
@@ -572,27 +492,83 @@ async fn repair_duplicates(api:&submissions_api::external::Context)->Result<(),R
 			Source:None,
 			ResourceType:None,
 			ResourceID:None,
-		}).await.map_err(RepairDuplicatesError::GetScripts)?;
+		}).await.map_err(RepairError::GetScripts)?);

-		let done=scripts.len()<LIMIT as usize;
-
-		for script in scripts{
-			if !sources.insert(script.Source){
-				println!("Deleting duplicate script {:?}",script.ID);
-				api.delete_script(submissions_api::types::GetScriptRequest{
-					ScriptID:script.ID,
-				}).await.map_err(RepairDuplicatesError::DeleteScript)?;
-			}
-		}
-
-		if done{
-			// We scanned all policies
-			println!("Done!");
+		if scripts.len()<LIMIT as usize{
+			// We scanned all scripts
+			println!("Downloaded all scripts!");
 			break;
 		}else{
 			page+=1;
 		}
 	}
+	Ok(scripts)
+}
+async fn download_policies(api:&submissions_api::external::Context)->Result<Vec<ScriptPolicyResponse>,RepairError>{
+	let mut policies=Vec::new();
+	const LIMIT:u32=100;
+	let mut page=1;
+	loop{
+		println!("Downloading policies page {page}...");
+		policies.extend(api.get_script_policies(submissions_api::types::GetScriptPoliciesRequest{
+			Page:page,
+			Limit:LIMIT,
+			FromScriptHash:None,
+			ToScriptID:None,
+			Policy:Some(submissions_api::types::Policy::Replace),
+		}).await.map_err(RepairError::GetPolicies)?);
+
+		if policies.len()<LIMIT as usize{
+			// We scanned all policies
+			println!("Downloaded all policies!");
+			break;
+		}else{
+			page+=1;
+		}
+	}
+	Ok(policies)
+}
+async fn repair(config:RepairConfig)->Result<(),RepairError>{
+	let cookie=submissions_api::Cookie::new(&config.session_id).map_err(RepairError::Cookie)?;
+	let api=&submissions_api::external::Context::new(config.api_url,cookie).map_err(RepairError::Reqwest)?;
+
+	let (scripts,policies)=tokio::try_join!(
+		download_scripts(api),
+		download_policies(api),
+	)?;
+
+	let mut sources=std::collections::HashSet::new();
+
+	for script in scripts{
+		if !sources.insert(script.Source){
+			println!("Deleting duplicate script {:?}",script.ID);
+			api.delete_script(submissions_api::types::GetScriptRequest{
+				ScriptID:script.ID,
+			}).await.map_err(RepairError::DeleteScript)?;
+		}
+	}
+
+	futures::stream::iter(policies.iter().map(Ok)).try_for_each_concurrent(REMOTE_CONCURRENCY,async|policy|{
+		let from_script=api.get_script_from_hash(submissions_api::types::HashRequest{
+			hash:policy.FromScriptHash.as_str(),
+		}).await.map_err(RepairError::GetScript)?;
+
+		if let Some(from_script)=from_script{
+			if policy.ToScriptID==from_script.ID{
+				// invalid policy.  Reset the policy to None
+				api.update_script_policy(submissions_api::types::UpdateScriptPolicyRequest{
+					ID:policy.ID,
+					FromScriptID:None,
+					ToScriptID:None,
+					Policy:Some(submissions_api::types::Policy::None),
+				}).await.map_err(RepairError::UpdateScriptPolicy)?;
+				println!("Policy updated! {:?}",policy.ID);
+			}
+		}else{
+			println!("Script did not exist! hash={}",policy.FromScriptHash);
+		}
+		Ok(())
+	}).await?;

 	Ok(())
 }