Implement kings as service (WiP)

src/chronology/application/DateSelection.tsx

@@ -15,19 +15,22 @@ import {
 import useDateSelectionState, {
   DateEditorStateProps,
 } from 'chronology/application/DateSelectionState'
+import KingsService from './KingsService'
 
 type Props = {
   dateProp?: MesopotamianDate
   updateDate: (date?: MesopotamianDate, index?: number) => Bluebird<Fragment>
   inList?: boolean
   index?: number
   saveDateOverride?: (updatedDate?: MesopotamianDate, index?: number) => void
+  kingsService: KingsService
 }
 
 interface DateEditorProps extends DateEditorStateProps {
   target: React.MutableRefObject<null>
   isSaving: boolean
   isDisplayed: boolean
+  kingsService: KingsService
 }
 
 export function DateEditor({
@@ -41,6 +44,7 @@ export function DateEditor({
   setIsDisplayed,
   setIsSaving,
   saveDateOverride,
+  kingsService,
 }: DateEditorProps): JSX.Element {
   const state = useDateSelectionState({
     date,
@@ -50,6 +54,7 @@ export function DateEditor({
     setIsDisplayed,
     setIsSaving,
     saveDateOverride,
+    kingsService,
   })
 
   const dateOptionsInput = DateOptionsInput({ ...state })
@@ -114,6 +119,7 @@ export default function DateSelection({
   inList = false,
   index,
   saveDateOverride,
+  kingsService,
 }: Props): JSX.Element {
   const target = useRef(null)
   const [isDisplayed, setIsDisplayed] = useState(false)
@@ -149,6 +155,7 @@ export default function DateSelection({
       setDate={setDate}
       index={index}
       saveDateOverride={saveDateOverride}
+      kingsService={kingsService}
     />
   )
 

src/chronology/application/DateSelectionMethods.ts

@@ -4,6 +4,7 @@ import { DateFieldDto, MonthFieldDto } from 'fragmentarium/domain/FragmentDtos'
 import { Fragment } from 'fragmentarium/domain/fragment'
 import { DateSelectionStateParams } from './DateSelectionState'
 import { EponymDateField, KingDateField } from 'chronology/domain/DateBase'
+import KingsService from './KingsService'
 
 interface SaveDateParams {
   date?: MesopotamianDate
@@ -45,20 +46,26 @@ export function saveDateDefault({
   }
 }
 
-export function getDate(params: DateSelectionStateParams): MesopotamianDate {
-  return MesopotamianDate.fromJson({
-    year: getYear(params),
-    month: getMonth(params),
-    day: getDay(params),
-    king: getKing(params),
-    eponym: getEponym(params),
-    isSeleucidEra: params.isSeleucidEra,
-    isAssyrianDate: params.isAssyrianDate,
-    ur3Calendar:
-      params.ur3Calendar && params.isCalendarFieldDisplayed
-        ? params.ur3Calendar
-        : undefined,
-  })
+export function getDate(
+  params: DateSelectionStateParams,
+  kingsService: KingsService
+): MesopotamianDate {
+  return MesopotamianDate.fromJson(
+    {
+      year: getYear(params),
+      month: getMonth(params),
+      day: getDay(params),
+      king: getKing(params),
+      eponym: getEponym(params),
+      isSeleucidEra: params.isSeleucidEra,
+      isAssyrianDate: params.isAssyrianDate,
+      ur3Calendar:
+        params.ur3Calendar && params.isCalendarFieldDisplayed
+          ? params.ur3Calendar
+          : undefined,
+    },
+    kingsService
+  )
 }
 
 function getYear(params: DateSelectionStateParams): DateFieldDto {

src/chronology/application/DateSelectionState.ts

@@ -2,14 +2,26 @@ import { MesopotamianDate } from 'chronology/domain/Date'
 import { EponymDateField, Ur3Calendar } from 'chronology/domain/DateBase'
 import { KingDateField } from 'chronology/domain/DateBase'
 import usePromiseEffect from 'common/usePromiseEffect'
-import { Eponym } from 'chronology/ui/DateEditor/Eponyms'
 import { useState } from 'react'
 import Bluebird from 'bluebird'
 import { Fragment } from 'fragmentarium/domain/fragment'
 import {
   getDate,
   saveDateDefault,
 } from 'chronology/application/DateSelectionMethods'
+import KingsService from './KingsService'
+
+// ToDo:
+// - Test `isNotInBrinkman`
+// - Exclude empty dates and make it impossible to save them
+// - If year, month, and day are empty and not broken or undertain, do not display ∅.∅.∅, instead display only the name of the king.
+// - If day, month or year are not given, do not calculate the exact date, instead only the year.
+// - Accession year: year 0 of the king belongs with the last year of the prev. king
+// - Address date converter issues:
+//    1. January & February (both Gregorian & Julian) drifts upon change,
+//    2. Check dates around 1 BCE / CE,
+//    3. Fix errors with first and last ruler
+// - Instead of PGC, give the Julian date by default and show an info icon. When hovering over the icon, the user will get the PGC date.
 
 export interface DateEditorStateProps {
   date?: MesopotamianDate
@@ -19,6 +31,7 @@ export interface DateEditorStateProps {
   setIsSaving: React.Dispatch<React.SetStateAction<boolean>>
   index?: number
   saveDateOverride?: (updatedDate?: MesopotamianDate, index?: number) => void
+  kingsService: KingsService
 }
 
 interface YearStateParams {
@@ -74,7 +87,7 @@ interface KingAndEponymDateParams extends KingAndEponymBrokenUncertainParams {
   king?: KingDateField
   eponym?: EponymDateField
   setKing: React.Dispatch<React.SetStateAction<KingDateField | undefined>>
-  setEponym: React.Dispatch<React.SetStateAction<Eponym | undefined>>
+  setEponym: React.Dispatch<React.SetStateAction<EponymDateField | undefined>>
 }
 
 interface AdditionalDateStateParams
@@ -88,7 +101,9 @@ export interface DateSelectionStateParams
   extends YearStateParams,
     MonthStateParams,
     DayStateParams,
-    AdditionalDateStateParams {}
+    AdditionalDateStateParams {
+  kingsService: KingsService
+}
 
 export interface DateSelectionState extends DateSelectionStateParams {
   getDate: () => MesopotamianDate
@@ -241,6 +256,7 @@ export default function useDateSelectionState(
     ...useMonthState(date),
     ...useDayState(date),
     ...useAdditionalDateParams(date),
+    kingsService: props.kingsService,
   }
   const _saveDate = (updatedDate) =>
     saveDateDefault({
@@ -250,7 +266,7 @@ export default function useDateSelectionState(
       updatedDate,
     })
 
-  const _getDate = () => getDate(stateParams)
+  const _getDate = () => getDate(stateParams, props.kingsService)
 
   return {
     ...stateParams,

src/chronology/application/KingsService.ts

@@ -0,0 +1,58 @@
+import Promise from 'bluebird'
+import KingsRepository from 'chronology/infrastructure/KingsRepository'
+import { King } from 'chronology/ui/BrinkmanKings/BrinkmanKings'
+
+export interface kingsSearch {
+  fetchAll(query: string): Promise<readonly King[]>
+}
+
+export default class KingsService implements kingsSearch {
+  private readonly kingsRepository: KingsRepository
+  private _kings: King[] = []
+  kingOptions: Array<{ label: string; value: King }> = []
+
+  constructor(kingsRepository: KingsRepository) {
+    this.kingsRepository = kingsRepository
+  }
+
+  static async createAndInitialize(
+    kingsRepository: KingsRepository
+  ): Promise<KingsService> {
+    const service = new KingsService(kingsRepository)
+    await service.initializeKings()
+    return service
+  }
+
+  get kings(): King[] {
+    return this._kings
+  }
+
+  private async initializeKings(): Promise<void> {
+    try {
+      this._kings = await this.fetchAll()
+      this.kingOptions = this.getKingOptions()
+    } catch (error) {
+      console.error('Failed to initialize kingsCollection', error)
+    }
+  }
+
+  fetchAll(): Promise<King[]> {
+    return this.kingsRepository.fetchAll()
+  }
+
+  private getKingOptions(): Array<{ label: string; value: King }> {
+    return this.kings
+      .filter((king) => !['16', '17'].includes(king.dynastyNumber))
+      .map((king) => {
+        return {
+          label: this.getKingSelectLabel(king),
+          value: king,
+        }
+      })
+  }
+
+  private getKingSelectLabel(king: King): string {
+    const kingYears = king.date ? ` (${king.date})` : ''
+    return `${king.name}${kingYears}, ${king.dynastyName}`
+  }
+}

src/chronology/domain/Date.ts

@@ -2,9 +2,13 @@ import { MesopotamianDateDto } from 'fragmentarium/domain/FragmentDtos'
 import _ from 'lodash'
 import { romanize } from 'romans'
 import { MesopotamianDateBase } from 'chronology/domain/DateBase'
+import KingsService from 'chronology/application/KingsService'
 
 export class MesopotamianDate extends MesopotamianDateBase {
-  static fromJson(dateJSON: MesopotamianDateDto): MesopotamianDate {
+  static fromJson(
+    dateJson: MesopotamianDateDto,
+    kingsService: KingsService
+  ): MesopotamianDate {
     const {
       year,
       month,
@@ -14,8 +18,9 @@ export class MesopotamianDate extends MesopotamianDateBase {
       isSeleucidEra,
       isAssyrianDate,
       ur3Calendar,
-    } = dateJSON
+    } = dateJson
     return new MesopotamianDate(
+      kingsService,
       year,
       month,
       day,

src/chronology/domain/DateBase.ts

@@ -3,6 +3,7 @@ import { Eponym } from 'chronology/ui/DateEditor/Eponyms'
 import DateConverter from 'chronology/domain/DateConverter'
 import data from 'chronology/domain/dateConverterData.json'
 import _ from 'lodash'
+import KingsService from 'chronology/application/KingsService'
 
 export interface DateField {
   value: string
@@ -40,6 +41,7 @@ export enum Ur3Calendar {
 }
 
 export class MesopotamianDateBase {
+  kingsService: KingsService
   year: DateField
   month: MonthField
   day: DateField
@@ -50,6 +52,7 @@ export class MesopotamianDateBase {
   ur3Calendar?: Ur3Calendar
 
   constructor(
+    kingsService: KingsService,
     year: DateField,
     month: MonthField,
     day: DateField,
@@ -59,6 +62,7 @@ export class MesopotamianDateBase {
     isAssyrianDate?: boolean,
     ur3Calendar?: Ur3Calendar
   ) {
+    this.kingsService = kingsService
     this.year = year
     this.month = month
     this.day = day
@@ -188,7 +192,7 @@ export class MesopotamianDateBase {
     day: number,
     isApproximate: boolean
   ): string {
-    const converter = new DateConverter()
+    const converter = new DateConverter({ ...this })
     converter.setToSeBabylonianDate(year, month, day)
     return this.insertDateApproximation(converter.toDateString(), isApproximate)
   }
@@ -203,7 +207,7 @@ export class MesopotamianDateBase {
       (key) => data.rulerToBrinkmanKings[key] === this.king?.orderGlobal
     )
     if (kingName) {
-      const converter = new DateConverter()
+      const converter = new DateConverter({ ...this })
       converter.setToMesopotamianDate(kingName, year, month, day)
       return this.insertDateApproximation(
         converter.toDateString(),

src/chronology/domain/DateConverter.ts

@@ -11,15 +11,17 @@ import {
   King,
   findKingByOrderGlobal,
 } from 'chronology/ui/BrinkmanKings/BrinkmanKings'
+import KingsService from 'chronology/application/KingsService'
 
 export default class DateConverter extends DateConverterBase {
   checks: DateConverterChecks = new DateConverterChecks()
   earliestDate: CalendarProps
   latestDate: CalendarProps
+  kingsService: KingsService
 
-  constructor() {
+  constructor({ kingsService }: { kingsService: KingsService }) {
     super()
-    this.setToEarliestDate()
+    this.kingsService = kingsService
     this.earliestDate = { ...this.calendar }
     this.setToLatestDate()
     this.latestDate = { ...this.calendar }
@@ -49,7 +51,7 @@ export default class DateConverter extends DateConverterBase {
     ruler = ruler ?? this.calendar?.ruler
     if (ruler) {
       const orderGlobal = data.rulerToBrinkmanKings[ruler]
-      return findKingByOrderGlobal(orderGlobal)
+      return findKingByOrderGlobal(orderGlobal, this.kingsService.kings)
     }
     return null
   }

src/chronology/infrastructure/KingsRepository.ts

@@ -0,0 +1,15 @@
+import { King } from 'chronology/ui/BrinkmanKings/BrinkmanKings'
+import Promise from 'bluebird'
+import ApiClient from 'http/ApiClient'
+
+export default class KingsRepository {
+  private readonly apiClient: ApiClient
+
+  constructor(apiClient: ApiClient) {
+    this.apiClient = apiClient
+  }
+
+  fetchAll(): Promise<King[]> {
+    return this.apiClient.fetchJson('/kings-all', false)
+  }
+}

src/chronology/ui/BrinkmanKings/BrinkmanKings.test.tsx

@@ -1,5 +1,19 @@
+import { render, screen } from '@testing-library/react'
 import BrinkmanKingsTable from 'chronology/ui/BrinkmanKings/BrinkmanKings'
 
+/*
+jest.doMock('chronology/domain/BrinkmanKings.json', () => ({
+  __esModule: true,
+  default: [],
+}))
+*/
+jest.mock('chronology/domain/BrinkmanKings.json', () => [], { virtual: true })
+
 test('Snapshot', () => {
   expect(BrinkmanKingsTable()).toMatchSnapshot()
 })
+
+test('Displays only kings from Brinkman in table', () => {
+  render(BrinkmanKingsTable())
+  expect(screen.getByText('Maništušu')).not.toBeInTheDocument()
+})