@propriety/court-calendar 0.0.0

package/src/_components/Toolbar/Toolbar.tsx

@@ -0,0 +1,159 @@
+import { useEffect, useState } from 'react';
+import type { Calendar, CalendarApi } from '@fullcalendar/core/index.js';
+import NavigateNext from '@mui/icons-material/NavigateNext';
+import NavigateBefore from '@mui/icons-material/NavigateBefore';
+import Add from '@mui/icons-material/Add';
+import Box from '@mui/material/Box';
+import Button from '@mui/material/Button';
+import Typography from '@mui/material/Typography';
+import FormControl from '@mui/material/FormControl';
+import type { CalendarFilterCtx } from '../../types';
+import DateTypeFilter from './DateTypeFilter';
+import ViewFilter from './ViewFilter';
+import HearingTypeFilter from './HearingTypeFilter';
+import Stack from '@mui/material/Stack';
+import UserFilter from './UserFilter';
+import SearchBar from '../Shared/SearchBar';
+import CaseFilter from './CaseFilter';
+import MuniDropdown from '../Shared/MuniDropdown';
+
+export default function Toolbar({
+    calendarApi,
+    filterCtx,
+    setFilterCtx,
+    handleCreateClick,
+    currentView,
+    setCurrentView,
+    setCurrentDate,
+    activeUser,
+    isFetchingCases,
+}: {
+    calendarApi: Calendar | null;
+    filterCtx: CalendarFilterCtx;
+    setFilterCtx: (ctx: CalendarFilterCtx) => void;
+    handleCreateClick: () => void;
+    currentView: string;
+    setCurrentView: (view: string) => void;
+    currentDate: Date;
+    setCurrentDate: (date: Date) => void;
+    activeUser: number | null;
+    isFetchingCases: boolean;
+}) {
+    const [currentTitle, setCurrentTitle] = useState('');
+
+    useEffect(() => {
+        if (calendarApi) {
+            const handleDatesSet = () => {
+                setCurrentTitle(calendarApi.getCurrentData().viewTitle);
+            };
+            calendarApi.on('datesSet', handleDatesSet);
+            return () => {
+                calendarApi.off('datesSet', handleDatesSet);
+            };
+        }
+    }, [calendarApi]);
+
+    useEffect(() => {
+        if (calendarApi) {
+            if (currentView === 'tableView') {
+                setCurrentTitle(calendarApi.getDate().toLocaleDateString('en-US', { month: 'long', year: 'numeric' }));
+                return;
+            }
+            setCurrentTitle(calendarApi.getCurrentData().viewTitle);
+        }
+    }, [calendarApi, currentView]);
+
+    function goToToday() {
+        if (calendarApi) {
+            calendarApi.today();
+            setCurrentDate(new Date());
+            setCurrentTitle(calendarApi.getCurrentData().viewTitle);
+        }
+    }
+
+    function handleNext() {
+        if (calendarApi) {
+            calendarApi.next();
+            setCurrentDate(calendarApi.getDate());
+            setCurrentTitle(calendarApi.getCurrentData().viewTitle);
+        }
+    }
+
+    function handlePrev() {
+        if (calendarApi) {
+            calendarApi.prev();
+            setCurrentDate(calendarApi.getDate());
+            setCurrentTitle(calendarApi.getCurrentData().viewTitle);
+        }
+    }
+
+    return (
+        <Stack
+            direction={'row'}
+            display='flex'
+            alignItems='center'
+            justifyContent='space-between'
+            sx={{ p: 2, gap: 2 }}
+            className='themed'
+            maxWidth='100%'
+            flexWrap={'wrap'}
+        >
+            <Box display='flex' alignItems='center' gap={2}>
+                <FormControl size='small'>
+                    <ViewFilter currentView={currentView} setCurrentView={setCurrentView} />
+                </FormControl>
+
+                <FormControl size='small'>
+                    <HearingTypeFilter filterCtx={filterCtx} setFilterCtx={setFilterCtx} />
+                </FormControl>
+                <FormControl size='small'>
+                    <DateTypeFilter filterCtx={filterCtx} setFilterCtx={setFilterCtx} />
+                </FormControl>
+                <FormControl size='small'>
+                    <CaseFilter filterCtx={filterCtx} setFilterCtx={setFilterCtx} isFetchingCases={isFetchingCases} />
+                </FormControl>
+            </Box>
+            <Box display='flex' alignItems='center' gap={2}>
+                <FormControl size='small'>
+                    <SearchBar
+                        searchTerm={filterCtx.searchTerm}
+                        setSearchTerm={(term) => setFilterCtx({ ...filterCtx, searchTerm: term })}
+                        width={200}
+                    />
+                </FormControl>
+                <FormControl size='small'>
+                    <UserFilter filterCtx={filterCtx} setFilterCtx={setFilterCtx} activeUser={activeUser} />
+                </FormControl>
+                <FormControl size='small' sx={{ minWidth: 250, minHeight: 45 }}>
+                    <MuniDropdown
+                        selectedMuni={filterCtx.municode || ''}
+                        setSelectedMuni={(muni) => setFilterCtx({ ...filterCtx, municode: muni })}
+                        allowClear={true}
+                        size='small'
+                    />
+                </FormControl>
+            </Box>
+            <Box display='flex' alignItems='center' gap={1}>
+                <Typography
+                    variant='h6'
+                    component='div'
+                    sx={{ flexGrow: 1, textAlign: 'center', maxWidth: '200px', whiteSpace: 'nowrap' }}
+                >
+                    {currentTitle}
+                </Typography>
+                <Button size='medium' onClick={handleCreateClick}>
+                    <Add fontSize='medium' />
+                </Button>
+                <Button variant='outlined' size='medium' onClick={goToToday}>
+                    Today
+                </Button>
+                <Button size='medium' onClick={handlePrev}>
+                    <NavigateBefore fontSize='medium' />
+                </Button>
+                <Button size='medium' onClick={handleNext}>
+                    <NavigateNext fontSize='medium' />
+                </Button>
+            </Box>
+        </Stack>
+    );
+}

package/src/_components/Toolbar/UserFilter.tsx

@@ -0,0 +1,105 @@
+import Stack from '@mui/material/Stack';
+import type { CalendarFilterCtx, User } from '../../types';
+import Tooltip from '@mui/material/Tooltip';
+import PersonIcon from '@mui/icons-material/Person';
+import IconButton from '@mui/material/IconButton';
+import { allUsers } from '@/helpers/people';
+import Autocomplete from '@mui/material/Autocomplete';
+import TextField from '@mui/material/TextField';
+
+export default function UserFilter({
+    filterCtx,
+    setFilterCtx,
+    activeUser,
+}: {
+    filterCtx: CalendarFilterCtx;
+    setFilterCtx: (ctx: CalendarFilterCtx) => void;
+    activeUser: number | null;
+}) {
+    function handleAssignedToMeClick() {
+        if (activeUser) {
+            setFilterCtx({
+                ...filterCtx,
+                showOnlyAssignedToUser: activeUser,
+            });
+        }
+    }
+    const excludedUserLastnames = ['Import', 'Memos', 'Table', 'Note', 'Robot', 'Ingestion'];
+
+    // Prepare filtered user options
+    const userOptions = Object.values(allUsers).filter(
+        (option) => option.UserLastName && !excludedUserLastnames.includes(option.UserLastName),
+    );
+
+    return (
+        <Stack direction='row' spacing={0} alignItems='center' borderRadius={'4px'} border={1}>
+            <Tooltip title='Me' arrow placement='top'>
+                <IconButton
+                    onClick={handleAssignedToMeClick}
+                    sx={{
+                        border: 'none',
+                        borderRadius: 0,
+                        p: '11px',
+                        boxShadow: 'none',
+                        background: 'none',
+                    }}
+                    size='medium'
+                >
+                    <PersonIcon fontSize='small' />
+                </IconButton>
+            </Tooltip>
+            <Tooltip title='Assigned to' arrow placement='top'>
+                <Autocomplete
+                    size='small'
+                    options={userOptions}
+                    getOptionLabel={(option: User) => `${option.UserFirstName} ${option.UserLastName}`}
+                    value={userOptions.find((u) => u.UserID === filterCtx.showOnlyAssignedToUser) || null}
+                    onChange={(_, newValue) =>
+                        setFilterCtx({
+                            ...filterCtx,
+                            showOnlyAssignedToUser: newValue ? newValue.UserID : null,
+                        })
+                    }
+                    renderInput={(params) => (
+                        <TextField
+                            {...params}
+                            label='Assigned to'
+                            fullWidth
+                            slotProps={{
+                                input: {
+                                    ...params.InputProps,
+                                    sx: {
+                                        '& .MuiOutlinedInput-notchedOutline': {
+                                            border: 'none',
+                                        },
+                                        '&:hover': {
+                                            backgroundColor: 'var(--fc-today-bg-color) !important',
+                                        },
+                                        '& button': {
+                                            transition: 'none !important',
+                                        },
+                                    },
+                                },
+                            }}
+                        />
+                    )}
+                    sx={{
+                        minWidth: 150,
+                        width: 150,
+                        border: 'none',
+                        borderRadius: 0,
+                        boxShadow: 'none',
+                        background: 'none',
+                        '& .MuiInputBase-root:hover': {
+                            backgroundColor: 'var(--fc-today-bg-color) !important',
+                        },
+                        '& button': {
+                            transition: 'none !important',
+                        },
+                    }}
+                    classes={{ paper: 'themed' }}
+                />
+            </Tooltip>
+        </Stack>
+    );
+}

package/src/_components/Toolbar/ViewFilter.tsx

@@ -0,0 +1,48 @@
+import ToggleButton from '@mui/material/ToggleButton';
+import ToggleButtonGroup from '@mui/material/ToggleButtonGroup';
+import Tooltip from '@mui/material/Tooltip';
+import CalendarViewMonthIcon from '@mui/icons-material/CalendarViewMonth';
+import CalendarViewWeekIcon from '@mui/icons-material/CalendarViewWeek';
+import CalendarViewDayIcon from '@mui/icons-material/CalendarViewDay';
+import FormatListBulletedIcon from '@mui/icons-material/FormatListBulleted';
+
+export default function ViewFilter({
+    currentView,
+    setCurrentView,
+}: {
+    currentView: string;
+    setCurrentView: (view: string) => void;
+}) {
+    return (
+        <ToggleButtonGroup
+            value={currentView}
+            onChange={(event, newView) => {
+                if (newView !== null) {
+                    setCurrentView(newView);
+                }
+            }}
+            exclusive
+        >
+            <Tooltip title='Month' arrow placement='top'>
+                <ToggleButton value='dayGridMonth'>
+                    <CalendarViewMonthIcon fontSize='small' />
+                </ToggleButton>
+            </Tooltip>
+            <Tooltip title='Week' arrow placement='top'>
+                <ToggleButton value='dayGridWeek'>
+                    <CalendarViewWeekIcon fontSize='small' />
+                </ToggleButton>
+            </Tooltip>
+            <Tooltip title='Day' arrow placement='top'>
+                <ToggleButton value='listDay'>
+                    <CalendarViewDayIcon fontSize='small' />
+                </ToggleButton>
+            </Tooltip>
+            <Tooltip title='Table' arrow placement='top'>
+                <ToggleButton value='tableView'>
+                    <FormatListBulletedIcon fontSize='small' />
+                </ToggleButton>
+            </Tooltip>
+        </ToggleButtonGroup>
+    );
+}

package/src/helpers/cache.ts

@@ -0,0 +1,89 @@
+import type { Case, CourtDate } from '@/types';
+import Dexie, { type Table } from 'dexie';
+
+const CASES_CACHE_EXPIRY = 1000 * 60 * 60; // 1 hour
+const COURT_DATES_CACHE_EXPIRY = 1000 * 60 * 5; // 5 minutes
+
+// Define Dexie database
+class CasesDB extends Dexie {
+    cases!: Table<{ courtDateId: string; data: Case[]; timestamp: number }, string>;
+    courtDates!: Table<{ id: string; data: CourtDate[]; timestamp: number }, string>;
+    constructor() {
+        super('CourtCasesDB');
+        this.version(1).stores({
+            cases: 'courtDateId',
+        });
+        this.version(2).stores({
+            cases: 'courtDateId',
+            courtDates: 'id',
+        });
+    }
+}
+
+const db = new CasesDB();
+
+// Get all cached cases (for all court dates)
+export async function getCasesCache(): Promise<{
+    [courtDateId: string]: { data: Case[]; timestamp: number };
+}> {
+    const all = await db.cases.toArray();
+    const now = Date.now();
+    const cache: { [courtDateId: string]: { data: Case[]; timestamp: number } } = {};
+    for (const entry of all) {
+        if (now - entry.timestamp < CASES_CACHE_EXPIRY) {
+            cache[entry.courtDateId] = { data: entry.data, timestamp: entry.timestamp };
+        }
+    }
+    return cache;
+}
+
+// Set all cases (overwrites all per-court-date entries)
+export async function setCasesCache(cache: { [courtDateId: string]: { data: Case[]; timestamp: number } }) {
+    await db.cases.clear();
+    const entries = Object.entries(cache).map(([courtDateId, value]) => ({
+        courtDateId,
+        data: value.data,
+        timestamp: value.timestamp,
+    }));
+    await db.cases.bulkPut(entries);
+}
+
+export async function getCachedCases(courtDateId: string): Promise<Case[] | null> {
+    const entry = await db.cases.get(courtDateId);
+    const now = Date.now();
+    if (entry && Array.isArray(entry.data) && now - entry.timestamp < CASES_CACHE_EXPIRY) {
+        return entry.data;
+    }
+    return null;
+}
+
+export async function updateCasesCache(courtDateId: string, data: Case[]) {
+    try {
+        await db.cases.put({ courtDateId, data, timestamp: Date.now() });
+    } catch (e) {
+        // Dexie handles quota errors internally, but you can catch and log if needed
+        console.warn('Error updating cases cache for', courtDateId, e);
+    }
+}
+
+export async function removeCasesCache(courtDateId: string) {
+    await db.cases.delete(courtDateId);
+}
+
+// Court Dates Cache Functions
+export async function getCourtDatesCache(): Promise<CourtDate[] | null> {
+    const entry = await db.courtDates.get('all');
+    const now = Date.now();
+    if (entry && Array.isArray(entry.data) && now - entry.timestamp < COURT_DATES_CACHE_EXPIRY) {
+        return entry.data;
+    }
+    return null;
+}
+
+export async function setCourtDatesCache(data: CourtDate[]) {
+    try {
+        await db.courtDates.put({ id: 'all', data, timestamp: Date.now() });
+    } catch (e) {
+        console.warn('Error updating court dates cache', e);
+    }
+}

package/src/helpers/cases.ts

@@ -0,0 +1,79 @@
+import type { Case, CourtDate } from '../types';
+
+export async function* searchByCaseTerm(term: string, apiKey: string) {
+    if (!apiKey || term.trim() === '') return;
+    let page = 1;
+    let totalPages = 1;
+    do {
+        const res = await fetch(
+            `https://utils.aventine.ai/court-cases/search?page=${page}&query=${encodeURIComponent(term)}`,
+            {
+                mode: 'cors',
+                headers: { 'x-api-key': apiKey },
+                method: 'GET',
+            },
+        );
+
+        const data = await res.json();
+        const courtIds = data.data.map((c: CourtDate) => c.CourtDateID);
+        totalPages = data.total_pages;
+        yield courtIds; // Yield partial result for this page
+        page++;
+    } while (page <= totalPages);
+}
+
+export async function fetchCasesByCourtDate(id: string, apiKey: string): Promise<Case[]> {
+    if (!apiKey) return [];
+    const res = await fetch(`https://utils.aventine.ai/court-dates/${id}/cases`, {
+        mode: 'cors',
+        headers: {
+            'x-api-key': apiKey,
+        },
+    });
+    const data = await res.json();
+    console.log('Fetched cases for court date', id, data);
+    return data || [];
+}
+
+export async function* fetchAllCasesPaginated(apiKey: string, pageSize = 20) {
+    if (!apiKey) return;
+    let page = 1;
+    let totalPages = 1;
+    do {
+        const res = await fetch(`https://utils.aventine.ai/court-cases/filtering?page=${page}&page_size=${pageSize}`, {
+            mode: 'cors',
+            headers: { 'x-api-key': apiKey },
+            method: 'GET',
+        });
+        const data = await res.json();
+        totalPages = data.total_pages;
+        const allCases: Record<string, Case[]> = {};
+        for (const courtDate of data.data) {
+            if (courtDate.cases && Array.isArray(courtDate.cases)) {
+                allCases[courtDate.CourtDateID] = courtDate.cases;
+            }
+        }
+        yield allCases; // Yield partial result for this page
+        page++;
+    } while (page <= totalPages);
+}
+
+export function isCaseSettled(c: Case, isVillage: boolean): boolean {
+    if (!isVillage) {
+        // town
+        if (c.SCARDeterminationAction === null) return false;
+        if (c.SCARDeterminationAction.toLowerCase().includes('s')) return true;
+    } else {
+        // village
+        if (c.VillageSCARDeterminationAction === null) return false;
+        if (c.VillageSCARDeterminationAction.toLowerCase().includes('s')) return true;
+    }
+    return false;
+}
+
+export function isCaseMissingEvidence(c: Case): boolean {
+    if (!c.evidence) return true;
+    if (!c.evidence.Evidence || c.evidence.Evidence === null) return true;
+    if (c.evidence.Evidence.trim() === '') return true;
+    return false;
+}

package/src/helpers/courtDates.ts

@@ -0,0 +1,139 @@
+import { HearingType, Lifecycle, SourceType, type CourtDate } from '../types';
+import { formatDateForAPI } from './formatter';
+
+export async function getAllDates(apiKey: string): Promise<Array<CourtDate>> {
+    if (!apiKey) return [];
+
+    const res = await fetch(`https://utils.aventine.ai/court-dates/all`, {
+        mode: 'cors',
+        headers: {
+            'x-api-key': apiKey,
+        },
+    });
+    const data = await res.json();
+    console.log('Fetched dates:', data);
+
+    for (const date of data.dates) {
+        if (!date.Lifecycle) {
+            date.Lifecycle = Lifecycle.SCHEDULED;
+        }
+        if (!date.Type) {
+            date.Type = HearingType.UNKNOWN;
+        }
+    }
+
+    return data.dates || [];
+}
+
+export async function updateCourtDate(
+    courtDateId: number,
+    updatedData: Partial<CourtDate>,
+    apiKey: string,
+    courtCases?: string[],
+): Promise<boolean> {
+    if (!apiKey) return false;
+    const res = await fetch(`https://utils.aventine.ai/court-dates/${courtDateId}/update`, {
+        method: 'PUT',
+        mode: 'cors',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': apiKey,
+        },
+        body: JSON.stringify({
+            adjournment_date: updatedData.AdjournmentDate
+                ? formatDateForAPI(new Date(updatedData.AdjournmentDate))
+                : undefined,
+            court_date: updatedData.CourtDate ? formatDateForAPI(new Date(updatedData.CourtDate)) : undefined,
+            hearing_link: updatedData.HearingLink !== '' ? updatedData.HearingLink : undefined,
+            hearing_officer: updatedData.HearingOfficer !== null ? updatedData.HearingOfficer : undefined,
+            hearing_time: updatedData.HearingTime !== '' ? updatedData.HearingTime : undefined,
+            hearing_type: updatedData.Type !== HearingType.UNKNOWN ? updatedData.Type : undefined,
+            muni: updatedData.MuniCode,
+            firstChair: updatedData.FirstChair !== null ? updatedData.FirstChair : undefined,
+            secondChair: updatedData.SecondChair !== null ? updatedData.SecondChair : undefined,
+            lifecycle: updatedData.Lifecycle !== Lifecycle.SCHEDULED ? updatedData.Lifecycle : undefined,
+            court_cases: courtCases || undefined,
+            is_adjourned: updatedData.IsAdjourned !== undefined ? updatedData.IsAdjourned : undefined,
+            notes: updatedData.Notes !== null ? updatedData.Notes : undefined,
+        }),
+    });
+    if (res.ok) {
+        console.log(`Court date ${courtDateId} updated successfully.`);
+        return true;
+    } else {
+        console.error(`Failed to update court date ${courtDateId}. Status: ${res.status}`);
+        return false;
+    }
+}
+
+export async function deleteCourtDate(courtDateId: number, apiKey: string): Promise<boolean> {
+    if (!apiKey) return false;
+    const res = await fetch(`https://utils.aventine.ai/court-dates/${courtDateId}`, {
+        method: 'DELETE',
+        mode: 'cors',
+        headers: {
+            'x-api-key': apiKey,
+        },
+    });
+    if (res.ok) {
+        console.log(`Court date ${courtDateId} deleted successfully.`);
+        return true;
+    } else {
+        console.error(`Failed to delete court date ${courtDateId}. Status: ${res.status}`);
+        return false;
+    }
+}
+
+// get court_date_id from response
+export async function createCourtDate(
+    courtDate: Date,
+    muniCode: string,
+    apiKey: string,
+    courtCases?: string[],
+): Promise<number | null> {
+    if (!apiKey) return null;
+    const res = await fetch(`https://utils.aventine.ai/court-dates/create`, {
+        method: 'POST',
+        mode: 'cors',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': apiKey,
+        },
+        body: JSON.stringify({
+            court_date: formatDateForAPI(new Date(courtDate)),
+            muni: muniCode,
+            source: SourceType.MANUAL,
+            court_cases: courtCases || [],
+        }),
+    });
+    if (res.ok) {
+        const data = await res.json();
+        console.log(`Court date created successfully with ID: ${data.court_date_id}`);
+        return data.court_date_id;
+    } else {
+        console.error(`Failed to create court date. Status: ${res.status}`);
+        return null;
+    }
+}
+
+export async function snoozeUploadDeadline(courtDateId: number, apiKey: string): Promise<boolean> {
+    if (!apiKey) return false;
+    const res = await fetch(`https://utils.aventine.ai/court-cases/snooze/upload/${courtDateId}`, {
+        method: 'GET',
+        mode: 'cors',
+        headers: {
+            'x-api-key': apiKey,
+        },
+    });
+    if (res.ok) {
+        console.log(`Upload deadline for court date ${courtDateId} snoozed successfully.`);
+        return true;
+    } else {
+        console.error(`Failed to snooze upload deadline for court date ${courtDateId}. Status: ${res.status}`);
+        return false;
+    }
+}
+
+export function isVillageDate(muniCode: string): boolean {
+    return muniCode.length > 3 && muniCode.slice(-2) !== '00';
+}

package/src/helpers/formatter.ts

@@ -0,0 +1,16 @@
+import type { Evidence } from '../types';
+
+export function formatDateForAPI(date: Date): string {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+
+// [\"Sales\"] -> Sales
+export function formatEvidence(evidence: Evidence): string {
+    if (!evidence || !evidence.Evidence) return '';
+    const hasBeenUploaded = evidence.Uploaded && evidence.Uploaded.Evidence;
+    if (!hasBeenUploaded) return `${evidence.Evidence.replace(/[[\]"]+/g, '')} created`;
+    return `${evidence.Uploaded.Evidence.replace(/[[\]"]+/g, '')} uploaded on ${new Date(evidence.Uploaded.UploadDate).toLocaleDateString()}`;
+}

package/src/helpers/munis.ts

@@ -0,0 +1,44 @@
+import type { Muni } from '../types';
+
+async function getAllMuniNames(apiKey: string): Promise<Record<string, Muni>> {
+    if (!apiKey) return {};
+    const res = await fetch(`https://utils.aventine.ai/utils/get-muni-names`, {
+        mode: 'cors',
+        headers: {
+            'x-api-key': apiKey,
+        },
+    });
+    const data = await res.json();
+    console.log('Fetched muni names:', data);
+    const munis: Record<string, Muni> = {};
+    if (data == null) {
+        return munis;
+    }
+    for (const muni of Object.keys(data)) {
+        munis[muni] = data[muni];
+    }
+    return munis;
+}
+
+export const allMuniNames = await getAllMuniNames(import.meta.env.VITE_CALENDAR_API_KEY);
+
+export function getTownshipName(muniCode: string): string {
+    if (muniCode.length < 5) {
+        muniCode = muniCode + '00';
+    }
+    const muni = allMuniNames[muniCode];
+    if (!muni) return muniCode;
+    if (muniCode.slice(-2) !== '00') {
+        return muni.Village;
+    }
+    return muni.Township;
+}
+
+export function getCountyName(muniCode: string): string {
+    if (muniCode.length < 5) {
+        muniCode = muniCode + '00';
+    }
+    const muni = allMuniNames[muniCode];
+    if (!muni) return muniCode;
+    return muni.County;
+}