@fdm-monster/client-next 0.0.1 → 0.0.2

package/src/store/dialog.store.ts

@@ -1,114 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,173 +0,0 @@
-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

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

package/src/store/index.ts

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

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

@@ -1,246 +0,0 @@
-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)
-    }
-  }
-})