queue and confirm changes

src/main.rs

@@ -465,6 +465,7 @@ async fn upload_scripts(config:UploadConfig)->Result<(),ScriptUploadError>{
 #[allow(dead_code)]
 #[derive(Debug)]
 enum RepairError{
+	Io(std::io::Error),
 	Cookie(submissions_api::CookieError),
 	Reqwest(submissions_api::ReqwestError),
 	GetPolicies(submissions_api::Error),
@@ -545,49 +546,127 @@ async fn repair(config:RepairConfig)->Result<(),RepairError>{
 	let mut script_id_from_hash=std::collections::HashMap::new();
 	let mut unique_sources=std::collections::HashSet::new();
 
+	let mut duplicate_scripts=Vec::new();
+
 	for script in &scripts{
 		// if not unique
 		if !unique_sources.insert(script.Source.as_str()){
-			println!("Deleting duplicate script {:?}",script.ID);
-			api.delete_script(submissions_api::types::GetScriptRequest{
+			println!("Identified duplicate script {:?}",script.ID);
+			duplicate_scripts.push(submissions_api::types::GetScriptRequest{
 				ScriptID:script.ID,
-			}).await.map_err(RepairError::DeleteScript)?;
+			});
 		}else{
 			script_id_from_hash.insert(script.Hash.as_str(),script);
 		}
 	}
 
+	if !duplicate_scripts.is_empty(){
+		// ask to confirm delete scripts
+		print!("Delete {} duplicate scripts? [y/N]: ",duplicate_scripts.len());
+		std::io::stdout().flush().map_err(RepairError::Io)?;
+
+		let mut input=String::new();
+		std::io::stdin().read_line(&mut input).map_err(RepairError::Io)?;
+		match input.trim(){
+			"y"|"Y"=>(),
+			_=>{
+				println!("Quitting.");
+				return Ok(());
+			},
+		}
+		futures::stream::iter(duplicate_scripts).map(Ok).try_for_each_concurrent(REMOTE_CONCURRENCY,|request|{
+			api.delete_script(request)
+		}).await.map_err(RepairError::DeleteScript)?;
+	}
+
 	let mut unique_policies=std::collections::HashSet::new();
+
+	let mut update_policies=Vec::new();
+	let mut policies_not_unique=Vec::new();
+	let mut policies_missing_from_script=Vec::new();
+
 	for policy in &policies{
 		let from_script=script_id_from_hash.get(policy.FromScriptHash.as_str());
 
 		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{
+				println!("Invalid policy {:?}, queueing update...",policy.ID);
+				update_policies.push(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{
 				// if not unique
 				if !unique_policies.insert(policy.FromScriptHash.as_str()){
-					println!("Policy is not unique! hash={} Deleting {:?}...",policy.FromScriptHash,policy.ID);
-					api.delete_script_policy(submissions_api::types::GetScriptPolicyRequest{
+					println!("Policy is not unique! hash={} id={:?}",policy.FromScriptHash,policy.ID);
+					policies_not_unique.push(submissions_api::types::GetScriptPolicyRequest{
 						ScriptPolicyID:policy.ID,
-					}).await.map_err(RepairError::DeleteScriptPolicy)?;
+					});
 				}
 			}
 		}else{
-			println!("FromScript did not exist! hash={} Deleting {:?}...",policy.FromScriptHash,policy.ID);
-			api.delete_script_policy(submissions_api::types::GetScriptPolicyRequest{
+			println!("FromScript does not exist! hash={} id={:?}",policy.FromScriptHash,policy.ID);
+			policies_missing_from_script.push(submissions_api::types::GetScriptPolicyRequest{
 				ScriptPolicyID:policy.ID,
-			}).await.map_err(RepairError::DeleteScriptPolicy)?;
+			});
 		}
 	}
 
+	if !update_policies.is_empty(){
+		print!("Update {} policies? [y/N]: ",update_policies.len());
+		std::io::stdout().flush().map_err(RepairError::Io)?;
+
+		let mut input=String::new();
+		std::io::stdin().read_line(&mut input).map_err(RepairError::Io)?;
+		match input.trim(){
+			"y"|"Y"=>(),
+			_=>{
+				println!("Quitting.");
+				return Ok(());
+			},
+		}
+		futures::stream::iter(update_policies).map(Ok).try_for_each_concurrent(REMOTE_CONCURRENCY,|request|{
+			api.update_script_policy(request)
+		}).await.map_err(RepairError::UpdateScriptPolicy)?;
+	}
+	if !policies_not_unique.is_empty(){
+		print!("Delete {} duplicate policies? [y/N]: ",policies_not_unique.len());
+		std::io::stdout().flush().map_err(RepairError::Io)?;
+
+		let mut input=String::new();
+		std::io::stdin().read_line(&mut input).map_err(RepairError::Io)?;
+		match input.trim(){
+			"y"|"Y"=>(),
+			_=>{
+				println!("Quitting.");
+				return Ok(());
+			},
+		}
+		futures::stream::iter(policies_not_unique).map(Ok).try_for_each_concurrent(REMOTE_CONCURRENCY,|request|{
+			api.delete_script_policy(request)
+		}).await.map_err(RepairError::DeleteScriptPolicy)?;
+	}
+	if !policies_missing_from_script.is_empty(){
+		print!("Delete {} orphaned policies? [y/N]: ",policies_missing_from_script.len());
+		std::io::stdout().flush().map_err(RepairError::Io)?;
+
+		let mut input=String::new();
+		std::io::stdin().read_line(&mut input).map_err(RepairError::Io)?;
+		match input.trim(){
+			"y"|"Y"=>(),
+			_=>{
+				println!("Quitting.");
+				return Ok(());
+			},
+		}
+		futures::stream::iter(policies_missing_from_script).map(Ok).try_for_each_concurrent(REMOTE_CONCURRENCY,|request|{
+			api.delete_script_policy(request)
+		}).await.map_err(RepairError::DeleteScriptPolicy)?;
+	}
+
 	Ok(())
 }