@fdm-monster/client-next 0.0.1

package/src/store/dialog.store.ts

@@ -0,0 +1,114 @@
+import { defineStore } from 'pinia'
+import { DialogName } from '@/components/Generic/Dialogs/dialog.constants'
+
+interface DialogReference<T = any> {
+  id: DialogName
+  opened: boolean
+  beforeOpenedCallback?: (input?: T) => void | Promise<void>
+  openedCallback?: (input?: T) => void | Promise<void>
+  context?: any
+  output?: any
+}
+
+export type DialogsById = { [k: string]: DialogReference }
+
+interface State {
+  ids: DialogName[]
+  dialogsById: DialogsById
+}
+
+export const useDialogsStore = defineStore('Dialog', {
+  state: (): State => ({
+    ids: [],
+    dialogsById: {}
+  }),
+  getters: {
+    dialogs(): DialogReference[] {
+      return this.ids.map((i) => this.dialogsById[i])
+    },
+    getBeforeOpenedCallback() {
+      return (id: DialogName) => this.dialogsById[id]?.beforeOpenedCallback
+    },
+    getOpenedCallback() {
+      return (id: DialogName) => this.dialogsById[id]?.openedCallback
+    },
+    getContext() {
+      return (id: DialogName) => {
+        return this.dialogsById[id]?.context
+      }
+    },
+    getOutput() {
+      return (id: DialogName) => {
+        return this.dialogsById[id]?.output
+      }
+    },
+    isDialogOpened() {
+      return (id: DialogName) => {
+        return this.dialogsById[id]?.opened
+      }
+    }
+  },
+  actions: {
+    openDialogWithContext<T = any>(id: DialogName, context?: T) {
+      let dialog = this.dialogsById[id]
+      if (!dialog) {
+        dialog = this.registerDialogReference(id)
+      }
+      dialog.opened = true
+      dialog.context = context
+      // Vue 2 reactivity issue
+      this.dialogsById = {
+        ...this.dialogsById
+      }
+      console.debug(`[Pinia Dialog ${id}] Opened with context`, context)
+    },
+    closeDialog(id: DialogName, output?: any) {
+      let dialog = this.dialogsById[id]
+      if (!dialog) {
+        dialog = this.registerDialogReference(id)
+      }
+      dialog.opened = false
+      delete dialog.context
+      dialog.output = output
+      // Vue 2 reactivity issue
+      this.dialogsById = {
+        ...this.dialogsById
+      }
+      console.debug(`[Pinia Dialog ${id}] Closed`)
+    },
+    unregisterDialogReference(id: DialogName) {
+      delete this.dialogsById[id]
+      this.ids = this.ids.filter((i) => i !== id)
+    },
+    registerDialogReference<T = any>(
+      id?: DialogName,
+      callbacks?: {
+        beforeOpenedCallback?: (input?: T) => void
+        openedCallback?: (input?: T) => void
+      }
+    ) {
+      if (!id) {
+        throw new Error('Cannot unregister undefined dialog reference')
+      }
+
+      console.debug(`[Pinia Dialog ${id}] Registered`)
+      const existingDialog = this.dialogsById[id]
+      if (existingDialog) {
+        console.debug(
+          `[Pinia Dialog ${id}]  Already registered dialog, not registering again`
+        )
+        return existingDialog
+      }
+
+      const dialogRef = {
+        id,
+        opened: false,
+        beforeOpenedCallback: callbacks?.beforeOpenedCallback,
+        openedCallback: callbacks?.openedCallback
+      }
+      this.dialogsById[id] = dialogRef
+      this.ids.push(id)
+      return dialogRef
+    }
+  }
+})

package/src/store/features.store.ts

@@ -0,0 +1,57 @@
+import { defineStore } from 'pinia'
+import {
+  TFeatureFlags,
+  FeaturesModel,
+  IFeatureFlag
+} from '@/models/server/features.model'
+import { AppService } from '@/backend/app.service'
+
+interface State {
+  features: FeaturesModel | undefined
+}
+
+export const useFeatureStore = defineStore('Feature', {
+  state: (): State => ({
+    features: undefined
+  }),
+  getters: {
+    getFeatures(): FeaturesModel | undefined {
+      return this.features
+    },
+    hasFeature:
+      (state) =>
+      (feature: TFeatureFlags): boolean => {
+        if (!state.features) {
+          console.debug('Feature store not loaded')
+          return false
+        }
+
+        const featureDefined = state.features[feature] as
+          | IFeatureFlag
+          | undefined
+        if (!featureDefined) {
+          console.debug(
+            `Feature ${feature} not defined. Options:`,
+            Object.keys(state.features)
+          )
+          return false
+        }
+
+        return featureDefined?.available
+      }
+  },
+  actions: {
+    async loadFeatures() {
+      debugger
+      try {
+        const features = await AppService.getFeatures()
+        this.setFeatures(features)
+      } catch (error) {
+        this.features = {}
+      }
+    },
+    setFeatures(features: FeaturesModel) {
+      this.features = features
+    }
+  }
+})

package/src/store/floor.store.ts

@@ -0,0 +1,173 @@
+import { defineStore } from 'pinia'
+import { FloorDto } from '@/models/floors/floor.model'
+import { useSettingsStore } from './settings.store'
+import { PrinterDto } from '@/models/printers/printer.model'
+import { usePrinterStore } from './printer.store'
+import { FloorService } from '@/backend/floor.service'
+import { IdType } from '@/utils/id.type'
+
+export interface State {
+  floors: FloorDto[]
+  selectedFloor: FloorDto | null
+}
+
+export const useFloorStore = defineStore('Floors', {
+  state: (): State => ({
+    floors: [],
+    selectedFloor: null
+  }),
+  getters: {
+    sortedFloors(state) {
+      return state.floors.sort((f, f2) => f.floor - f2.floor)
+    },
+    floor(state) {
+      return (floorId: IdType) => state.floors.find((pf) => pf.id === floorId)
+    },
+    floorNames(state) {
+      return state.floors.map((f) => f.name)
+    },
+    floorOfPrinter() {
+      return (printerId: IdType) => {
+        return this.floors.find((f: FloorDto) =>
+          f.printers.map((pid) => pid.printerId).includes(printerId)
+        )
+      }
+    },
+    floorlessPrinters(state): PrinterDto[] {
+      const printersStore = usePrinterStore()
+      return printersStore.printers.filter(
+        (p) =>
+          !state.floors.find((f) =>
+            f.printers.find((fp) => fp.printerId === p.id)
+          )
+      )
+    },
+    gridSortedPrinters() {
+      const settingsStore = useSettingsStore()
+      const gridCols = settingsStore.gridCols
+      const gridRows = settingsStore.gridRows
+
+      const printersStore = usePrinterStore()
+      const printers = printersStore.printers
+      if (!printers.length) return []
+      if (!this.selectedFloor) return []
+
+      const positions = this.selectedFloor.printers
+      const matrix: (PrinterDto | undefined)[][] = []
+      for (let i = 0; i < gridCols; i++) {
+        const row: (PrinterDto | undefined)[] = []
+        matrix.push(row)
+        for (let j = 0; j < gridRows; j++) {
+          const position = positions.find((p) => p.x === i && p.y === j)
+          if (!position) {
+            row.push(undefined)
+          } else {
+            const printer = printers.find((p) => p.id === position.printerId)
+            row.push(printer)
+          }
+        }
+      }
+      return matrix
+    }
+  },
+  actions: {
+    async loadFloors() {
+      const floors = await FloorService.getFloors()
+      this.saveFloors(floors)
+      return floors
+    },
+    async createFloor(newPrinterFloor: FloorDto) {
+      const data = await FloorService.createFloor(newPrinterFloor)
+      this.floors.push(data)
+      return data
+    },
+    saveFloors(floors: FloorDto[]) {
+      if (!floors?.length) return
+      this.floors = floors.sort((f, f2) => f.floor - f2.floor)
+      const floorId = this.selectedFloor?.id
+      const foundFloor = this.floors.find((f) => f.id === floorId)
+      this.selectedFloor = !foundFloor ? this.floors[0] : foundFloor
+    },
+    async deleteFloor(floorId: IdType) {
+      await FloorService.deleteFloor(floorId)
+      this._popPrinterFloor(floorId)
+    },
+    async updateFloorName({
+      floorId,
+      name
+    }: {
+      floorId: IdType
+      name: string
+    }) {
+      const floor = await FloorService.updateFloorName(floorId, name)
+      this._replaceFloor(floor)
+      return floor
+    },
+    async updateFloorNumber({
+      floorId,
+      floorNumber
+    }: {
+      floorId: IdType
+      floorNumber: number
+    }) {
+      const floor = await FloorService.updateFloorNumber(floorId, floorNumber)
+      this._replaceFloor(floor)
+      return floor
+    },
+    async addPrinterToFloor({
+      floorId,
+      printerId,
+      x,
+      y
+    }: {
+      floorId: IdType
+      printerId: IdType
+      x: number
+      y: number
+    }) {
+      const result = await FloorService.addPrinterToFloor(floorId, {
+        printerId,
+        x,
+        y
+      })
+      this._replaceFloor(result)
+    },
+    async changeSelectedFloorByIndex(selectedPrinterFloorIndex: number) {
+      if (!this.floors?.length) return
+      if (this.floors.length <= selectedPrinterFloorIndex) return
+
+      const newFloor = this.floors[selectedPrinterFloorIndex]
+      // TODO throw warning?
+      if (!newFloor) return
+      this.selectedFloor = newFloor
+      return newFloor
+    },
+    async deletePrinterFromFloor({
+      floorId,
+      printerId
+    }: {
+      floorId: IdType
+      printerId: IdType
+    }) {
+      const result = await FloorService.deletePrinterFromFloor(
+        floorId,
+        printerId
+      )
+      this._replaceFloor(result)
+    },
+    _popPrinterFloor(floorId: IdType) {
+      const foundFloorIndex = this.floors.findIndex((pg) => pg.id === floorId)
+      if (foundFloorIndex !== -1) {
+        this.floors.splice(foundFloorIndex, 1)
+      }
+    },
+    _replaceFloor(printerFloor: FloorDto) {
+      const foundFloorIndex = this.floors.findIndex(
+        (pf) => pf.id === printerFloor.id
+      )
+      if (foundFloorIndex !== -1) {
+        this.floors[foundFloorIndex] = printerFloor
+      }
+    }
+  }
+})

package/src/store/grid.store.ts

@@ -0,0 +1,10 @@
+import { defineStore } from 'pinia'
+
+interface State {
+  gridEditMode: boolean
+}
+export const useGridStore = defineStore('GridStore', {
+  state: (): State => ({
+    gridEditMode: false
+  })
+})

package/src/store/index.ts

@@ -0,0 +1,4 @@
+// Utilities
+import { createPinia } from 'pinia'
+
+export default createPinia()

package/src/store/printer-state.store.ts

@@ -0,0 +1,246 @@
+import { defineStore } from 'pinia'
+import { PrinterDto } from '@/models/printers/printer.model'
+import {
+  PrinterStateDto,
+  SocketState
+} from '@/models/socketio-messages/socketio-message.model'
+import { usePrinterStore } from './printer.store'
+import { PrinterFileService } from '@/backend'
+import { useSettingsStore } from './settings.store'
+import { CurrentOrHistoryPayload } from '@/models/printers/printer-current-job.model'
+import { IdType } from '@/utils/id.type'
+import {
+  isPrinterIdling,
+  isPrinterPrinting
+} from '@/shared/printer-state.constants'
+
+interface State {
+  printerIds: IdType[]
+  printerEventsById: Record<IdType, PrinterStateDto>
+  socketStatesById: Record<IdType, SocketState>
+}
+
+export const usePrinterStateStore = defineStore('PrinterState', {
+  state: (): State => ({
+    printerIds: [],
+    printerEventsById: {},
+    socketStatesById: {}
+  }),
+  getters: {
+    operationalPrintersById() {
+      const printerStore = usePrinterStore()
+      const printersById: Record<IdType, PrinterDto> = {}
+      this.printerIds.forEach((id) => {
+        const printerEvents = this.printerEventsById[id]
+        if (printerEvents?.current?.payload?.state?.flags?.operational) {
+          const printer = printerStore.printer(id)
+          if (printer) {
+            printersById[id] = printer
+          } else {
+            throw new Error(
+              `PrinterStore contains no printer with id ${id} but events are known`
+            )
+          }
+        }
+      })
+      return printersById
+    },
+    isPrinterOperational(): (printerId: IdType) => boolean {
+      return (printerId: IdType) => {
+        return !!this.operationalPrintersById[printerId]
+      }
+    },
+    printingPrintersById() {
+      const printersById: Record<IdType, PrinterStateDto> = {}
+      this.printerIds.forEach((id) => {
+        const printerEvents = this.printerEventsById[id]
+        if (printerEvents?.current?.payload?.state?.flags?.printing) {
+          printersById[id] = printerEvents
+        }
+      })
+      return printersById
+    },
+    isPrinterPrinting(): (printerId: IdType) => boolean {
+      return (printerId: IdType) => !!this.printingPrintersById[printerId]
+    },
+    isPrinterStoppable(): (printerId: IdType) => boolean {
+      return (printerId: IdType) => {
+        const printerEvents = this.printerEventsById[printerId]
+        if (!printerEvents) return false
+        const flags = printerEvents?.current?.payload?.state?.flags
+        return flags?.printing || flags?.paused
+      }
+    },
+    isPrinterPaused(): (printerId: IdType) => boolean {
+      return (printerId: IdType) => {
+        const printerEvents = this.printerEventsById[printerId]
+        if (!printerEvents) return false
+        const flags = printerEvents?.current?.payload?.state?.flags
+        return flags?.paused
+      }
+    },
+    printerCurrentEventReceivedAtById() {
+      const printerCurrentEventReceivedAtById: Record<IdType, number> = {}
+      this.printerIds.forEach((id) => {
+        const printerEvents = this.printerEventsById[id]
+        if (printerEvents?.current?.receivedAt) {
+          printerCurrentEventReceivedAtById[id] =
+            printerEvents.current.receivedAt
+        }
+      })
+      return printerCurrentEventReceivedAtById
+    },
+    onlinePrinters() {
+      const printerStore = usePrinterStore()
+      const onlinePrinters: Record<IdType, PrinterDto> = {}
+      this.printerIds.forEach((id) => {
+        const socketState = this.socketStatesById[id]
+        if (socketState?.api === 'responding') {
+          const printer = printerStore.printer(id)
+          if (printer) {
+            onlinePrinters[id] = printer
+          } else {
+            throw new Error(
+              `PrinterStore contains no printer with id ${id} but socket state is opened`
+            )
+          }
+        }
+      })
+      return onlinePrinters
+    },
+    onlinePrintersWithStates(): {
+      printerState: PrinterStateDto
+      printer: PrinterDto
+    }[] {
+      return Object.values(this.onlinePrinters).map((printer) => {
+        return {
+          printer,
+          printerState: this.printerEventsById[printer.id]
+        }
+      })
+    },
+    printingCount(): number {
+      const printerStateStore = usePrinterStateStore()
+      return Object.values(printerStateStore.onlinePrintersWithStates).filter(
+        (p) => isPrinterPrinting(p.printerState)
+      ).length
+    },
+    operationalNotPrintingCount(): number {
+      return this.onlinePrintersWithStates.filter((pws) =>
+        isPrinterIdling(pws.printer, pws.printerState)
+      ).length
+    },
+    isApiResponding() {
+      return (printerId: IdType) => {
+        return Object.keys(this.onlinePrinters).includes(printerId.toString())
+      }
+    },
+    isPrinterNotOnline() {
+      return (printerId: IdType) => {
+        return !this.isApiResponding(printerId)
+      }
+    },
+    printerJobsById() {
+      const printerStore = usePrinterStore()
+      const jobsRendered =
+        useSettingsStore().frontendDebugSettings.showJobsRendered
+      const printersWithJobById: Record<IdType, CurrentOrHistoryPayload> = {}
+      this.printerIds.forEach((id) => {
+        const printerEvents = this.printerEventsById[id]
+        const flags = printerEvents?.current?.payload?.state?.flags
+        if (flags?.printing || flags?.paused) {
+          const printer = printerStore.printer(id)
+          if (printer) {
+            printersWithJobById[printer.id] = printerEvents?.current?.payload
+          } else {
+            throw new Error(
+              `PrinterStore contains no printer with id ${id} but events are known`
+            )
+          }
+        }
+      })
+
+      if (jobsRendered) {
+        // TODO improve summary
+        console.debug(
+          '[PrinterStateStore] rendered printerJobsById',
+          printersWithJobById
+        )
+      }
+      return printersWithJobById
+    },
+    printersWithJob() {
+      const printerStore = usePrinterStore()
+      const printersWithJobById: {
+        printer: PrinterDto
+        job: CurrentOrHistoryPayload
+      }[] = []
+      this.printerIds.forEach((id) => {
+        const printerEvents = this.printerEventsById[id]
+        const flags = printerEvents?.current?.payload?.state?.flags
+        if (flags?.printing || flags?.paused) {
+          const printer = printerStore.printer(id)
+          if (printer) {
+            printersWithJobById.push({
+              printer,
+              job: printerEvents?.current?.payload
+            })
+          } else {
+            throw new Error(
+              `PrinterStore contains no printer with id ${id} but events are known`
+            )
+          }
+        }
+      })
+      return printersWithJobById
+    },
+    printingFilePathsByPrinterId() {
+      const printingFilesByPrinterId: Record<IdType, string> = {}
+      this.printerIds.forEach((id) => {
+        const printerEvents = this.printerEventsById[id]
+        const flags = printerEvents?.current?.payload?.state?.flags
+        if (flags?.printing || flags?.paused) {
+          // TODO decide on comparing with name or path
+          printingFilesByPrinterId[id] =
+            printerEvents?.current?.payload?.job?.file?.path
+        }
+      })
+      return printingFilesByPrinterId
+    }
+  },
+  actions: {
+    setSocketStates(socketStates: Record<IdType, SocketState>) {
+      this.socketStatesById = socketStates
+      this.printerIds = Object.keys(socketStates)
+    },
+    setPrinterEvents(printerEvents: Record<IdType, PrinterStateDto>) {
+      this.printerEventsById = printerEvents
+      // TODO check id's different from printer events and socket states
+    },
+    deletePrinterEvents(printerId: IdType) {
+      delete this.printerEventsById[printerId]
+      this.printerIds = Object.keys(this.printerEventsById)
+    },
+    async selectAndPrintFile({
+      printerId,
+      fullPath
+    }: {
+      printerId: IdType
+      fullPath: string
+    }) {
+      if (!printerId) return
+      const printerStore = usePrinterStore()
+      const printer = printerStore.printer(printerId)
+      if (!printer) return
+
+      if (this.isPrinterPrinting(printerId)) {
+        alert(
+          'This printer is printing or not connected! Either way printing is not an option.'
+        )
+        return
+      }
+
+      await PrinterFileService.selectAndPrintFile(printerId, fullPath, true)
+    }
+  }
+})