chore: update baptism step

src/extract/attribute/attribute.ts

@@ -401,7 +401,6 @@ const attributes: FluroAttribute[] = [
     IsRequired: false,
     AllowSearch: false
   },
-
   {
     _id: 'BirthDateVerified',
     AbbreviatedName: 'Birth Date Verified',
@@ -425,6 +424,30 @@ const attributes: FluroAttribute[] = [
     IsRequired: false,
     AllowSearch: false
   },
+  {
+    _id: 'BaptismType',
+    AbbreviatedName: 'Baptism Type',
+    FieldTypeId: fieldTypes.SingleSelect,
+    EntityTypeId: entityTypes['Rock.Model.Step'],
+    Name: 'Baptism Type',
+    AttributeQualifiers: [
+      {
+        IsSystem: false,
+        Key: 'values',
+        Value: 'Infant,Adult'
+      } as components['schemas']['Rock.Model.AttributeQualifier']
+    ],
+    Description: 'The type of baptism the person underwent',
+    EntityTypeQualifierColumn: 'StepTypeId',
+    EntityTypeQualifierValue: '1',
+    IsSystem: false,
+    Order: 0,
+    IsGridColumn: false,
+    IsMultiValue: false,
+    IsRequired: false,
+    AllowSearch: false,
+    ShowOnBulk: true
+  },
   {
     _id: 'Magnification',
     AbbreviatedName: 'Magnification Completion Date',

src/extract/contact/contact.ts

@@ -138,6 +138,7 @@ const schema = z.object({
           data: z
             .object({
               dateofBaptism: z.string().datetime().nullish(),
+              typeofBaptism: z.enum(['Infant', 'Adult', '']).optional(),
               isaChristian: z.enum(['Yes', 'No', 'Unsure', '']).optional()
             })
             .optional()

src/load/contact/baptismStep/attribute/attribute.ts

@@ -0,0 +1,53 @@
+import { DELETE, POST, RockApiError, type components } from '../../../client'
+
+export async function load(
+  AttributeValues: {
+    [key: string]: string | null | undefined
+  },
+  data: components['schemas']['Rock.Model.Step']
+): Promise<void> {
+  if (data.Id == null) return
+
+  for (const attributeKey of Object.keys(AttributeValues)) {
+    const attributeValue = AttributeValues[attributeKey]
+
+    if (data.AttributeValues?.[attributeKey].Value != attributeValue) {
+      if (attributeValue == null || attributeValue == '') {
+        // delete attribute value
+        const params = {
+          path: {
+            id: data.Id
+          },
+          query: {
+            attributeKey
+          }
+        }
+        const { error } = await DELETE('/api/Steps/AttributeValue/{id}', {
+          params
+        })
+        if (error != null)
+          throw new RockApiError(error, {
+            cause: { path: params.path, query: params.query }
+          })
+      } else {
+        // update attribute value
+        const params = {
+          path: {
+            id: data.Id
+          },
+          query: {
+            attributeKey,
+            attributeValue: attributeValue
+          }
+        }
+        const { error } = await POST('/api/Steps/AttributeValue/{id}', {
+          params
+        })
+        if (error != null)
+          throw new RockApiError(error, {
+            cause: { path: params.path, query: params.query }
+          })
+      }
+    }
+  }
+}

src/load/contact/baptismStep/attribute/index.ts

@@ -0,0 +1 @@
+export { load } from './attribute'

src/load/contact/baptismStep/baptismStep.ts

@@ -0,0 +1,100 @@
+import { omit } from 'lodash'
+import f from 'odata-filter-builder'
+
+import { GET, PATCH, POST, RockApiError, type components } from '../../client'
+import type { CacheObject } from '../../types'
+import type { RockContact } from '../contact'
+
+import { load as loadAttribute } from './attribute'
+
+export async function load(
+  person: components['schemas']['Rock.Model.Person'],
+  value: RockContact
+): Promise<void> {
+  const cacheObject = await loadStep(person, value)
+
+  if (cacheObject == null) return
+
+  const params = {
+    path: {
+      id: cacheObject.rockId
+    },
+    query: {
+      loadAttributes: 'simple' as const
+    }
+  }
+
+  const { data, error } = await GET('/api/Steps/{id}', {
+    params
+  })
+
+  if (error != null) throw new RockApiError(error, { cause: { ...params } })
+
+  await loadAttribute(value.data.BaptismStep?.AttributeValues ?? {}, data)
+}
+
+async function loadStep(
+  person: components['schemas']['Rock.Model.Person'],
+  value: RockContact
+): Promise<CacheObject | undefined> {
+  if (person.PrimaryAliasId == null || value.data.BaptismStep == null) return
+
+  const params = {
+    query: {
+      $filter: f()
+        .eq('PersonAliasId', person.PrimaryAliasId)
+        .eq('StepTypeId', 1)
+        .toString()
+    }
+  }
+
+  const { data, error } = await GET('/api/Steps', {
+    params
+  })
+
+  if (error != null)
+    throw new RockApiError(error, { cause: { query: params.query } })
+
+  if (data?.length === 0) {
+    // create new step
+    const body = {
+      PersonAliasId: person.PrimaryAliasId,
+      StepTypeId: 1,
+      CampusId: person.PrimaryCampusId,
+      ...omit(value.data.BaptismStep, 'AttributeValues')
+    }
+
+    const { data, error } = await POST('/api/Steps', {
+      body
+    })
+
+    if (error != null)
+      throw new RockApiError(error, { cause: { body, id: person.Id } })
+
+    return {
+      rockId: data as unknown as number
+    }
+  } else {
+    // update existing step
+    const Id = data[0].Id as number
+
+    const body = {
+      PersonAliasId: person.PrimaryAliasId,
+      StepTypeId: 2,
+      CampusId: person.PrimaryCampusId,
+      ...omit(value.data.BaptismStep, 'AttributeValues')
+    }
+
+    const { error } = await PATCH('/api/Steps/{id}', {
+      params: { path: { id: Id } },
+      body: body as unknown as Record<string, never>
+    })
+
+    if (error != null)
+      throw new RockApiError(error, { cause: { body, id: person.Id } })
+
+    return {
+      rockId: Id
+    }
+  }
+}

src/load/contact/baptismStep/index.ts

@@ -0,0 +1 @@
+export { load } from './baptismStep'

src/load/contact/contact.ts

@@ -7,30 +7,34 @@ import type { CacheObject } from '../types'
 
 import { load as loadAttribute } from './attribute'
 import { load as loadAvatar } from './avatar'
+import { load as loadBaptismStep } from './baptismStep'
 import { load as loadNewishStep } from './newishStep'
 import { load as loadPersonPreviousName } from './personPreviousName'
 import { load as loadNumber } from './phoneNumber'
 import { getRecordStatus } from './recordStatus'
 import { load as loadTag } from './tag'
 
+type Step =
+  | {
+      StepStatusId: number
+      CompletedDateTime: string | undefined
+      StartDateTime: string | undefined
+      EndDateTime: string | undefined
+      AttributeValues: {
+        [key: string]: string | null | undefined
+      }
+    }
+  | undefined
+
 export type RockContact = components['schemas']['Rock.Model.Person'] & {
   ForeignKey: string
   data: {
     GroupRoleId: number
     PhoneNumber: string[]
     FluroRecordStatus: string
     PersonPreviousName: string | undefined
-    NewishStep:
-      | {
-          StepStatusId: number
-          CompletedDateTime: string | undefined
-          StartDateTime: string | undefined
-          EndDateTime: string | undefined
-          AttributeValues: {
-            [key: string]: string | null | undefined
-          }
-        }
-      | undefined
+    NewishStep: Step
+    BaptismStep: Step
     AttributeValues: {
       [key: string]: string | null | undefined
     }
@@ -59,6 +63,7 @@ export async function load(value: RockContact): Promise<CacheObject> {
   await loadAttribute(data, value)
   await loadPersonPreviousName(data, value)
   await loadNewishStep(data, value)
+  await loadBaptismStep(data, value)
   await loadTag(data, value)
 
   return cacheObject

src/transform/contact/contact.test.ts

@@ -61,6 +61,7 @@ describe('contact', () => {
         GroupRoleId: 4,
         PersonPreviousName: undefined,
         NewishStep: undefined,
+        BaptismStep: undefined,
         TagIds: [1],
         AttributeValues: {
           FirstVisit: '2021-01-01',

src/transform/contact/contact.ts

@@ -125,6 +125,25 @@ function transformNewishStep(
     }
 }
 
+function transformBaptismStep(
+  data: NonNullable<NonNullable<FluroContact['details']>['faithInfo']>['data']
+): RockContact['data']['NewishStep'] {
+  if (data == null) return undefined
+
+  if (data.dateofBaptism != null) {
+    const date = new Date(data.dateofBaptism).toLocaleDateString('sv')
+    return {
+      CompletedDateTime: date,
+      StartDateTime: date,
+      EndDateTime: date,
+      StepStatusId: 2,
+      AttributeValues: {
+        BaptismType: data.typeofBaptism == 'Infant' ? 'Infant' : 'Adult'
+      }
+    }
+  }
+}
+
 /**
  * transforms a fluro api contact object to a rock contact object
  */
@@ -185,6 +204,7 @@ export function transform(cache: Cache, value: FluroContact): RockContact {
       FluroRecordStatus: value.status,
       PersonPreviousName: value.maidenName,
       NewishStep: transformNewishStep(value.details?.evPathwayDetails?.data),
+      BaptismStep: transformBaptismStep(value.details?.faithInfo?.data),
       TagIds: value.tags
         .map((tag) => cache['tag'][tag._id]?.rockId)
         .filter(Boolean),
@@ -223,7 +243,6 @@ export function transform(cache: Cache, value: FluroContact): RockContact {
         PoliceVettingRequest:
           value.details?.hsTrainingDetails?.data
             ?.responsetoPoliceVettingRequest,
-        BaptismDate: value.details?.faithInfo?.data?.dateofBaptism,
         core_GivingEnvelopeNumber:
           value.details?.financialDetail?.data?.accountNumber?.replace(
             /\D/g,