create missing policies

src/main.rs

@@ -487,6 +487,7 @@ enum RepairError{
 	UpdateScriptPolicy(submissions_api::Error),
 	DeleteScript(submissions_api::Error),
 	DeleteScriptPolicy(submissions_api::Error),
+	CreateScriptPolicy(submissions_api::Error),
 }
 struct RepairConfig{
 	session_id:String,
@@ -557,7 +558,8 @@ async fn repair(config:RepairConfig)->Result<(),RepairError>{
 		download_policies(api),
 	)?;
 
-	let mut script_id_from_hash=std::collections::HashMap::new();
+	let mut script_from_id=std::collections::HashMap::new();
+	let mut script_from_hash=std::collections::HashMap::new();
 	let mut unique_sources=std::collections::HashSet::new();
 
 	let mut duplicate_scripts=Vec::new();
@@ -570,7 +572,8 @@ async fn repair(config:RepairConfig)->Result<(),RepairError>{
 				ScriptID:script.ID,
 			});
 		}else{
-			script_id_from_hash.insert(script.Hash.as_str(),script);
+			script_from_id.insert(script.ID,script);
+			script_from_hash.insert(script.Hash.as_str(),script);
 		}
 	}
 
@@ -598,9 +601,12 @@ async fn repair(config:RepairConfig)->Result<(),RepairError>{
 	let mut update_policies=Vec::new();
 	let mut policies_not_unique=Vec::new();
 	let mut policies_missing_from_script=Vec::new();
+	let mut check_policy_exists=Vec::new();
+
+	let mut policy_from_hash=std::collections::HashMap::new();
 
 	for policy in &policies{
-		let from_script=script_id_from_hash.get(policy.FromScriptHash.as_str());
+		let from_script=script_from_hash.get(policy.FromScriptHash.as_str());
 
 		if let Some(&from_script)=from_script{
 			if policy.ToScriptID==from_script.ID{
@@ -619,6 +625,14 @@ async fn repair(config:RepairConfig)->Result<(),RepairError>{
 					policies_not_unique.push(submissions_api::types::GetScriptPolicyRequest{
 						ScriptPolicyID:policy.ID,
 					});
+				}else{
+					policy_from_hash.insert(policy.FromScriptHash.as_str(),policy);
+					// if policy is replace, but destination script is not allowed
+					if let Some(&to_script)=script_from_id.get(&policy.ToScriptID){
+						check_policy_exists.push((policy,to_script));
+					}else{
+						println!("ToScript does not exist! {:?} {:?} DOING NOTHING",policy.ToScriptID,policy.ID);
+					}
 				}
 			}
 		}else{
@@ -629,6 +643,31 @@ async fn repair(config:RepairConfig)->Result<(),RepairError>{
 		}
 	}
 
+	let mut create_allow_policy=Vec::new();
+	for (policy,to_script) in check_policy_exists{
+		if let Some(&allow_policy)=policy_from_hash.get(to_script.Hash.as_str()){
+			if allow_policy.Policy!=submissions_api::types::Policy::Allowed{
+				println!("Policy {:?} ToScript {:?} Policy {:?} was expected to be Allowed, but was {:?}!",policy.ID,to_script.ID,allow_policy.ID,allow_policy.Policy);
+			}
+		}else{
+			if policy.Policy==submissions_api::types::Policy::Replace{
+				println!("Policy {:?} ToScript {:?} has no Allowed policy!",policy.ID,to_script.ID);
+				create_allow_policy.push(submissions_api::types::CreateScriptPolicyRequest{
+					FromScriptID:to_script.ID,
+					ToScriptID:to_script.ID,
+					Policy:submissions_api::types::Policy::Allowed,
+				});
+			}
+		}
+	}
+
+	// All scripts should have exactly one policy
+	for script in &scripts{
+		if !policy_from_hash.contains_key(script.Hash.as_str()){
+			println!("Script {:?} has no policy!",script.ID);
+		}
+	}
+
 	if !update_policies.is_empty(){
 		print!("Update {} policies? [y/N]: ",update_policies.len());
 		std::io::stdout().flush().map_err(RepairError::Io)?;
@@ -680,6 +719,24 @@ async fn repair(config:RepairConfig)->Result<(),RepairError>{
 			api.delete_script_policy(request)
 		}).await.map_err(RepairError::DeleteScriptPolicy)?;
 	}
+	if !create_allow_policy.is_empty(){
+		print!("Create {} missing Allowed policies? [y/N]: ",create_allow_policy.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(create_allow_policy).map(Ok).try_for_each_concurrent(REMOTE_CONCURRENCY,async|request|{
+			api.create_script_policy(request).await?;
+			Ok(())
+		}).await.map_err(RepairError::CreateScriptPolicy)?;
+	}
 
 	Ok(())
 }