ecb wip

EventContextBuilder.groovy

package com.bloomhealthco.radiant.enrollment.core.coverage

import com.bloomhealthco.radiant.enrollment.core.builders.EventContext

/**
 * Builds an event context from a set of coverage events. EventContext is used to drive what coverage events appear
 * on an enrollment file.
 */
class EventContextBuilder {
    CoverageSegmentRepository coverageSegmentRepository

    EventContextBuilder(CoverageSegmentRepository coverageSegmentRepository) {
        this.coverageSegmentRepository = coverageSegmentRepository
    }

    /**
     * * Builds an event context from a set of coverage events.
     *
     * IMPORTANT: This logic is NOT 100% correct but it is duplicating the existing logic that I refactored
     * into this class. There are cases that we miss using this logic.
     *
     * Long term what I think needs to happen is we need to build up a list of exactly what needs to be sent. Right now
     * we assume that there are exactly 2 purchases with changes but that isn't correct. There could be multiple.
     * Some of them might not need to be sent at all.
     *
     * @param coverageEvents
     * @return
     */
    EventContext buildEventContext(List<CoverageEvent> coverageEvents) {
        List<CoverageEvent> coverageEventsForTransmission =
            findMostRecentCoverageEventsByPurchaseBloomId(coverageEvents)

        CoverageEvent currentEvent = coverageEventsForTransmission.find {
            it.changeType != ChangeType.TERMINATE
        }

        currentEvent = currentEvent ?: coverageEventsForTransmission.first()

        CoverageEvent previousEvent = coverageEventsForTransmission.find {
            it != currentEvent
        }

        return new EventContext(
                currentCoverageSegment: currentEvent.currentCoverageSegment,
                previousCoverageSegment: previousEvent?.currentCoverageSegment,
                currentEvent: currentEvent,
                previousEvent: previousEvent,
                lastCoverageSegmentProcessedByFamilyMember: lastCoverageSegmentProcessedByFamilyMember(
                        currentEvent.currentCoverageSegment, previousEvent?.currentCoverageSegment)
        )
    }

    private static List<CoverageEvent> findMostRecentCoverageEventsByPurchaseBloomId(
            List<CoverageEvent> coverageEvents) {

        Map<String, List<CoverageEvent>> coverageEventsByPurchase = coverageEvents.groupBy { it.purchaseBloomId }
        coverageEventsByPurchase.values()*.sort(byTimeOfEventDescending)
        return coverageEventsByPurchase.values()*.first().sort(byTimeOfEventDescending)
    }

    private Map<String, CoverageSegment> lastCoverageSegmentProcessedByFamilyMember(CoverageSegment segment1,
                                                                                    CoverageSegment segment2) {
        return getAllFamilyMemberBloomIdsFromCoverageSegments(segment1, segment2).collectEntries {
            String familyMemberBloomId ->
                [familyMemberBloomId, findLatestProcessedOrInitialSegment(familyMemberBloomId)]
        }
    }

    /**
     *
     * @param String familyMemberBloomId
     * @return CoverageSegment
     * First, find enrollee's latest coverage segment that was on a PROCESSED enrollment file.
     * If none found, then find their latest coverage segment that is part of a coverage event
     * with an 'INITIAL' status. These events were imported from bloomhealth to service_etl_enrollment.
     * They were never sent on an enrollment file in the new system, but we assume they were in old system.
     */
    private CoverageSegment findLatestProcessedOrInitialSegment(String familyMemberBloomId) {
        return coverageSegmentRepository.findLatestProcessedCoverageSegmentByFamilyMember(familyMemberBloomId) ?:
            coverageSegmentRepository.findLatestInitialCoverageSegmentByFamilyMember(familyMemberBloomId)
    }

    private static getAllFamilyMemberBloomIdsFromCoverageSegments(CoverageSegment segment1, CoverageSegment segment2) {
        List<String> previousBloomIds = segment1?.enrollees?.familyMemberBloomId ?: []
        List<String> currentBloomIds = segment2?.enrollees?.familyMemberBloomId ?: []

        return (previousBloomIds + currentBloomIds).unique()
    }

    private static Closure byTimeOfEventDescending = { CoverageEvent a, CoverageEvent b ->
        b.timeOfEvent <=> a.timeOfEvent
    }
}