add is_first_party to admin aggregator form

app/src/ApiClient.ts

@@ -110,6 +110,7 @@ export interface NewAggregator {
   api_url: string;
   dap_url: string;
   bearer_token: string;
+  is_first_party?: boolean;
 }
 
 export interface ApiToken {

app/src/aggregators/AggregatorForm.tsx

@@ -46,11 +46,13 @@ async function submit(
 
 export function AggregatorForm({
   handleSubmit,
+  showIsFirstParty = false,
 }: {
   handleSubmit: (
     aggregator: NewAggregator,
     helpers: FormikHelpers<NewAggregator>
   ) => void;
+  showIsFirstParty?: boolean;
 }) {
   const actionData = useActionData();
   let errors: undefined | FormikErrors<NewAggregator> = undefined;
@@ -72,6 +74,7 @@ export function AggregatorForm({
           api_url: "",
           dap_url: "",
           bearer_token: "",
+          is_first_party: showIsFirstParty ? true : undefined,
         } as NewAggregator
       }
       onSubmit={handleSubmit}
@@ -88,6 +91,7 @@ export function AggregatorForm({
           <ApiUrl {...props} />
           <DapUrl {...props} />
           <BearerToken {...props} />
+          {showIsFirstParty ? <IsFirstParty {...props} /> : null}
           <Button
             variant="primary"
             type="submit"
@@ -135,6 +139,20 @@ export default function AggregatorFormPage() {
   );
 }
 
+function IsFirstParty(props: FormikProps<NewAggregator>) {
+  return (
+    <FormGroup>
+      <Form.Switch
+        id="is_first_party"
+        label="First Party?"
+        onChange={props.handleChange}
+        onBlur={props.handleBlur}
+        checked={props.values.is_first_party}
+      />
+    </FormGroup>
+  );
+}
+
 function Name(props: FormikProps<NewAggregator>) {
   return (
     <FormGroup>
@@ -148,7 +166,7 @@ function Name(props: FormikProps<NewAggregator>) {
         onBlur={props.handleBlur}
         value={props.values.name}
         isInvalid={!!props.errors.name}
-        data-1p-ignore={true}
+        data-1p-ignore
       />
       <FormControl.Feedback type="invalid">
         {props.errors.name}

app/src/shared-aggregators/SharedAggregatorForm.tsx

@@ -38,7 +38,7 @@ export default function SharedAggreatorForm() {
   return (
     <>
       <h1>New Shared Aggregator</h1>
-      <AggregatorForm handleSubmit={handleSubmit} />
+      <AggregatorForm handleSubmit={handleSubmit} showIsFirstParty />
     </>
   );
 }

src/entity/aggregator/new_aggregator.rs

@@ -25,6 +25,7 @@ pub struct NewAggregator {
     pub dap_url: Option<String>,
     #[validate(required, custom = "base64", length(min = 8))]
     pub bearer_token: Option<String>,
+    pub is_first_party: Option<bool>,
 }
 
 fn validate_role(role: &str) -> Result<(), ValidationError> {
@@ -49,6 +50,7 @@ fn https(url: &str) -> Result<(), ValidationError> {
 impl NewAggregator {
     pub fn build(self, account: Option<&Account>) -> Result<ActiveModel, Error> {
         self.validate()?;
+
         // unwrap safety: the below unwraps will never panic, because
         // the above call to `NewAggregator::validate` will
         // early-return if any of the required `Option`s is `None`.
@@ -72,7 +74,7 @@ impl NewAggregator {
             created_at: OffsetDateTime::now_utc(),
             updated_at: OffsetDateTime::now_utc(),
             deleted_at: None,
-            is_first_party: account.is_none(),
+            is_first_party: account.is_none() && self.is_first_party.unwrap_or(true),
         }
         .into_active_model())
     }

tests/aggregators.rs

@@ -224,6 +224,26 @@ mod create {
         Ok(())
     }
 
+    #[test(harness = set_up)]
+    async fn is_first_party_is_ignored(app: DivviupApi) -> TestResult {
+        let (user, account, ..) = fixtures::member(&app).await;
+
+        let mut new_aggregator = fixtures::new_aggregator();
+        new_aggregator.is_first_party = Some(true);
+        let mut conn = post(format!("/api/accounts/{}/aggregators", account.id))
+            .with_api_headers()
+            .with_state(user)
+            .with_request_json(new_aggregator)
+            .run_async(&app)
+            .await;
+        assert_response!(conn, 201);
+        let aggregator: Aggregator = conn.response_json().await;
+        assert!(!aggregator.is_first_party);
+        assert!(!aggregator.reload(app.db()).await?.unwrap().is_first_party);
+
+        Ok(())
+    }
+
     #[test(harness = set_up)]
     async fn invalid(app: DivviupApi) -> TestResult {
         let (user, account, ..) = fixtures::member(&app).await;
@@ -835,6 +855,8 @@ mod shared_create {
         );
         assert_eq!(aggregator.role.as_ref(), new_aggregator.role.unwrap());
         assert!(aggregator.account_id.is_none());
+
+        // defaults to true when not specified
         assert!(aggregator.is_first_party);
 
         let aggregator_from_db = Aggregators::find_by_id(aggregator.id)
@@ -848,6 +870,44 @@ mod shared_create {
         Ok(())
     }
 
+    #[test(harness = set_up)]
+    async fn is_first_party_true_is_accepted(app: DivviupApi) -> TestResult {
+        let (admin, ..) = fixtures::admin(&app).await;
+        let mut new_aggregator = fixtures::new_aggregator();
+        new_aggregator.is_first_party = Some(true);
+        let mut conn = post("/api/aggregators")
+            .with_api_headers()
+            .with_state(admin)
+            .with_request_json(new_aggregator)
+            .run_async(&app)
+            .await;
+        assert_response!(conn, 201);
+        let aggregator: Aggregator = conn.response_json().await;
+        assert!(aggregator.is_first_party);
+        assert!(aggregator.reload(app.db()).await?.unwrap().is_first_party);
+
+        Ok(())
+    }
+
+    #[test(harness = set_up)]
+    async fn is_first_party_false_is_accepted(app: DivviupApi) -> TestResult {
+        let (admin, ..) = fixtures::admin(&app).await;
+        let mut new_aggregator = fixtures::new_aggregator();
+        new_aggregator.is_first_party = Some(false);
+        let mut conn = post("/api/aggregators")
+            .with_api_headers()
+            .with_state(admin)
+            .with_request_json(new_aggregator)
+            .run_async(&app)
+            .await;
+        assert_response!(conn, 201);
+        let aggregator: Aggregator = conn.response_json().await;
+        assert!(!aggregator.is_first_party);
+        assert!(!aggregator.reload(app.db()).await?.unwrap().is_first_party);
+
+        Ok(())
+    }
+
     #[test(harness = set_up)]
     async fn as_nonadmin(app: DivviupApi) -> TestResult {
         let (admin, ..) = fixtures::member(&app).await;

tests/harness/fixtures.rs

@@ -104,6 +104,7 @@ pub fn new_aggregator() -> NewAggregator {
         api_url: Some(format!("https://api.{}.divviup.org/prefix/", random_name())),
         dap_url: Some(format!("https://dap.{}.divviup.org", random_name())),
         bearer_token: Some(random_name()),
+        is_first_party: None,
     }
 }