fluidd

1
import Vue from 'vue'
2
import { Globals, Waits } from '@/globals'
3
import type { NotifyOptions } from '@/plugins/socketClient'
4
import { consola } from 'consola'
5
import type { TimelapseWritableSettings } from '@/store/timelapse/types'
6
import type { WebcamConfig } from '@/store/webcams/types'
7

8
const baseEmit = (method: string, options: NotifyOptions) => {
9
  if (!Vue.$socket) {
10
    consola.warn('Socket emit denied, socket not ready.', method, options)
11
    return
12
  }
13
  Vue.$socket.emit(method, options)
14
}
15

16
export const SocketActions = {
17
  async machineServicesRestart (service: string) {
18
    const wait = Waits.onServiceRestart
19
    baseEmit(
20
      'machine.services.restart', {
21
        dispatch: 'void',
22
        params: { service },
23
        wait
24
      }
25
    )
26
  },
27

28
  async machineServicesStart (service: string) {
29
    const wait = Waits.onServiceStart
30
    baseEmit(
31
      'machine.services.start', {
32
        dispatch: 'void',
33
        params: { service },
34
        wait
35
      }
36
    )
37
  },
38

39
  async machineServicesStop (service: string) {
40
    const wait = Waits.onServiceStop
41
    baseEmit(
42
      'machine.services.stop', {
43
        dispatch: 'void',
44
        params: { service },
45
        wait
46
      }
47
    )
48
  },
49

50
  async machineReboot () {
51
    baseEmit(
52
      'machine.reboot', {
53
        dispatch: 'void'
54
      }
55
    )
56
  },
57

58
  async machineShutdown () {
59
    baseEmit(
60
      'machine.shutdown', {
61
        dispatch: 'void'
62
      }
63
    )
64
  },
65

66
  async machineUpdateStatus (refresh = false) {
67
    baseEmit(
68
      'machine.update.status', {
69
        dispatch: 'version/onUpdateStatus',
70
        params: { refresh },
71
        wait: Waits.onVersionRefresh
72
      }
73
    )
74
  },
75

76
  async machineUpdateRefresh (name?: string) {
77
    baseEmit(
78
      'machine.update.refresh', {
79
        dispatch: 'version/onUpdateStatus',
80
        params: { name },
81
        wait: Waits.onVersionRefresh
82
      }
83
    )
84
  },
85

86
  async machineUpdateRecover (name: string, hard = false) {
87
    const dispatch = name === 'moonraker'
88
      ? 'version/onUpdatedMoonraker'
89
      : name === 'klipper'
90
        ? 'version/onUpdatedKlipper'
91
        : 'version/onUpdatedClient'
92
    baseEmit(
93
      'machine.update.recover', {
94
        dispatch,
95
        params: { name, hard }
96
      }
97
    )
98
  },
99

100
  async machineUpdateMoonraker () {
101
    baseEmit(
102
      'machine.update.moonraker', {
103
        dispatch: 'version/onUpdatedMoonraker'
104
      }
105
    )
106
  },
107

108
  async machineUpdateKlipper () {
109
    baseEmit(
110
      'machine.update.klipper', {
111
        dispatch: 'version/onUpdatedKlipper',
112
        params: {
113
          include_deps: true
114
        }
115
      }
116
    )
117
  },
118

119
  async machineUpdateClient (name: string) {
120
    const dispatch = name === 'fluidd'
121
      ? 'version/onUpdatedFluidd'
122
      : 'version/onUpdatedClient'
123
    baseEmit(
124
      'machine.update.client', {
125
        dispatch,
126
        params: { name }
127
      }
128
    )
129
  },
130

131
  async machineUpdateSystem () {
132
    baseEmit(
133
      'machine.update.system', {
134
        dispatch: 'version/onUpdatedSystem'
135
      }
136
    )
137
  },
138

139
  async machineUpdateAll () {
140
    baseEmit(
141
      'machine.update.full', {
142
        dispatch: 'version/onUpdatedAll'
143
      }
144
    )
145
  },
146

147
  async machineProcStats () {
148
    baseEmit(
149
      'machine.proc_stats', {
150
        dispatch: 'server/onMachineProcStats'
151
      }
152
    )
153
  },
154

155
  async machineSystemInfo () {
156
    baseEmit(
157
      'machine.system_info', {
158
        dispatch: 'server/onMachineSystemInfo'
159
      }
160
    )
161
  },
162

163
  async machineDevicePowerDevices () {
164
    baseEmit(
165
      'machine.device_power.devices', {
166
        dispatch: 'power/onInit'
167
      }
168
    )
169
  },
170

171
  async machineDevicePowerStatus (device: string) {
172
    baseEmit(
173
      'machine.device_power.status', {
174
        dispatch: 'power/onStatus',
175
        params: { [device]: null }
176
      }
177
    )
178
  },
179

180
  async machineDevicePowerToggle (device: string, state: string, wait?: string) {
181
    const emit = (state === 'on')
182
      ? 'machine.device_power.on'
183
      : 'machine.device_power.off'
184
    baseEmit(
185
      emit, {
186
        dispatch: 'power/onToggle',
187
        params: { [device]: null },
188
        wait
189
      }
190
    )
191
  },
192

193
  async machinePeripheralsUsb () {
194
    baseEmit(
195
      'machine.peripherals.usb', {
196
        dispatch: 'server/onMachinePeripherals',
197
        wait: Waits.onMachinePeripheralsUsb
198
      }
199
    )
200
  },
201

202
  async machinePeripheralsSerial () {
203
    baseEmit(
204
      'machine.peripherals.serial', {
205
        dispatch: 'server/onMachinePeripherals',
206
        wait: Waits.onMachinePeripheralsSerial
207
      }
208
    )
209
  },
210

211
  async machinePeripheralsVideo () {
212
    baseEmit(
213
      'machine.peripherals.video', {
214
        dispatch: 'server/onMachinePeripherals',
215
        wait: Waits.onMachinePeripheralsVideo
216
      }
217
    )
218
  },
219

220
  async machinePeripheralsCanbus (canbusInterface: string) {
221
    const wait = `${Waits.onMachinePeripheralsCanbus}/${canbusInterface}`
222
    baseEmit(
223
      'machine.peripherals.canbus', {
224
        dispatch: 'server/onMachinePeripheralsCanbus',
225
        params: {
226
          interface: canbusInterface
227
        },
228
        wait
229
      }
230
    )
231
  },
232

233
  async machineTimelapseSetSettings (settings: Partial<TimelapseWritableSettings>, wait?: string) {
234
    baseEmit(
235
      'machine.timelapse.post_settings', {
236
        dispatch: 'timelapse/onSettings',
237
        params: settings,
238
        wait
239
      }
240
    )
241
  },
242

243
  async machineTimelapseSaveFrames (wait?: string) {
244
    baseEmit(
245
      'machine.timelapse.saveframes', {
246
        wait
247
      }
248
    )
249
  },
250

251
  async machineTimelapseRender () {
252
    baseEmit('machine.timelapse.render', {})
253
  },
254

255
  async printerInfo () {
256
    baseEmit(
257
      'printer.info', {
258
        dispatch: 'printer/onPrinterInfo'
259
      }
260
    )
261
  },
262

263
  async printerRestart () {
264
    baseEmit(
265
      'printer.restart', {
266
        dispatch: 'void',
267
        wait: Waits.onKlipperRestart
268
      }
269
    )
270
  },
271

272
  async printerFirmwareRestart () {
273
    baseEmit(
274
      'printer.firmware_restart', {
275
        dispatch: 'void',
276
        wait: Waits.onKlipperFirmwareRestart
277
      }
278
    )
279
  },
280

281
  async printerQueryEndstops () {
282
    baseEmit(
283
      'printer.query_endstops.status', {
284
        dispatch: 'printer/onQueryEndstops',
285
        wait: Waits.onQueryEndstops
286
      }
287
    )
288
  },
289

290
  async printerObjectsList () {
291
    baseEmit(
292
      'printer.objects.list', {
293
        dispatch: 'printer/onPrinterObjectsList'
294
      }
295
    )
296
  },
297

298
  async printerObjectsSubscribe (objects: {[key: string]: null}) {
299
    baseEmit(
300
      'printer.objects.subscribe', {
301
        dispatch: 'printer/onPrinterObjectsSubscribe',
302
        params: {
303
          objects
304
        }
305
      }
306
    )
307
  },
308

309
  async printerPrintStart (path: string) {
310
    baseEmit(
311
      'printer.print.start', {
312
        dispatch: 'void',
313
        params: {
314
          filename: path
315
        }
316
      }
317
    )
318
  },
319

320
  async printerPrintCancel () {
321
    baseEmit(
322
      'printer.print.cancel', {
323
        dispatch: 'printer/onPrintCancel',
324
        wait: Waits.onPrintCancel
325
      }
326
    )
327
  },
328

329
  async printerPrintPause () {
330
    baseEmit(
331
      'printer.print.pause', {
332
        dispatch: 'printer/onPrintPause',
333
        wait: Waits.onPrintPause
334
      }
335
    )
336
  },
337

338
  async printerPrintResume () {
339
    baseEmit(
340
      'printer.print.resume', {
341
        dispatch: 'printer/onPrintResume',
342
        wait: Waits.onPrintResume
343
      }
344
    )
345
  },
346

347
  async printerGcodeScript (gcode: string, wait?: string) {
348
    baseEmit(
349
      'printer.gcode.script', {
350
        dispatch: 'console/onGcodeScript',
351
        params: {
352
          script: gcode
353
        },
354
        wait
355
      }
356
    )
357
  },
358

359
  async printerGcodeHelp () {
360
    baseEmit(
361
      'printer.gcode.help', {
362
        dispatch: 'console/onGcodeHelp'
363
      }
364
    )
365
  },
366

367
  async printerEmergencyStop () {
368
    baseEmit(
369
      'printer.emergency_stop', {
370
        dispatch: 'void'
371
      }
372
    )
373
  },
374

375
  async serverInfo () {
376
    baseEmit(
377
      'server.info', {
378
        dispatch: 'server/onServerInfo'
379
      }
380
    )
381
  },
382

383
  async identify (params?: { client_name: string, version: string, type: string, url: string }) {
384
    baseEmit('server.connection.identify', {
385
      dispatch: 'socket/onConnectionId',
386
      params
387
    })
388
  },
389

390
  async timelapseState () {
391
    baseEmit(
392
      'machine.timelapse.get_settings', {
393
        dispatch: 'timelapse/onSettings'
394
      }
395
    )
396

397
    baseEmit(
398
      'machine.timelapse.lastframeinfo', {
399
        dispatch: 'timelapse/onLastFrame'
400
      }
401
    )
402
  },
403

404
  async serverConfig () {
405
    baseEmit(
406
      'server.config', {
407
        dispatch: 'server/onServerConfig'
408
      }
409
    )
410
  },
411

412
  /**
413
   * Writes data to moonraker's DB.
414
   */
415
  async serverWrite (key: string, value: unknown, namespace: string = Globals.MOONRAKER_DB.fluidd.NAMESPACE) {
416
    baseEmit(
417
      'server.database.post_item', {
418
        params: {
419
          namespace,
420
          key,
421
          value
422
        }
423
      }
424
    )
425
  },
426

427
  async serverDelete (key: string, namespace: string = Globals.MOONRAKER_DB.fluidd.NAMESPACE) {
428
    baseEmit(
429
      'server.database.delete_item', {
430
        params: {
431
          namespace,
432
          key
433
        }
434
      }
435
    )
436
  },
437

438
  async serverRead (key?: string, namespace: string = Globals.MOONRAKER_DB.fluidd.NAMESPACE) {
439
    baseEmit(
440
      'server.database.get_item', {
441
        dispatch: 'socket/onServerRead',
442
        params: {
443
          namespace,
444
          key
445
        }
446
      }
447
    )
448
  },
449

450
  async serverRestart () {
451
    baseEmit(
452
      'server.restart', {
453
        dispatch: 'void'
454
      }
455
    )
456
  },
457

458
  async serverTemperatureStore () {
459
    baseEmit(
460
      'server.temperature_store', {
461
        dispatch: 'charts/initTempStore',
462
        params: {
463
          include_monitors: true
464
        }
465
      }
466
    )
467
  },
468

469
  async serverGcodeStore () {
470
    baseEmit(
471
      'server.gcode_store', {
472
        dispatch: 'console/onGcodeStore'
473
      }
474
    )
475
  },
476

477
  async serverHistoryList (params?: { start?: number; limit?: number; before?: number; since?: number; order?: string }) {
478
    baseEmit(
479
      'server.history.list', {
480
        dispatch: 'history/onHistoryList',
481
        params
482
      }
483
    )
484
  },
485

486
  async serverHistoryTotals () {
487
    baseEmit(
488
      'server.history.totals', {
489
        dispatch: 'history/onHistoryTotals'
490
      }
491
    )
492
  },
493

494
  async serverHistoryDeleteJob (uid: string) {
495
    const params = uid === 'all'
496
      ? {
497
          all: true
498
        }
499
      : { uid }
500

501
    baseEmit(
502
      'server.history.delete_job', {
503
        dispatch: 'history/onDelete',
504
        params
505
      }
506
    )
507
  },
508

509
  async serverHistoryResetTotals () {
510
    baseEmit(
511
      'server.history.reset_totals', {
512
        dispatch: 'history/onHistoryChange'
513
      }
514
    )
515
  },
516

517
  async serverJobQueueStatus () {
518
    baseEmit(
519
      'server.job_queue.status', {
520
        dispatch: 'jobQueue/onJobQueueStatus',
521
        wait: Waits.onJobQueue
522
      }
523
    )
524
  },
525

526
  async serverJobQueuePostJob (filenames: string[], reset?: boolean) {
527
    baseEmit(
528
      'server.job_queue.post_job', {
529
        dispatch: 'jobQueue/onJobQueueStatus',
530
        params: {
531
          filenames,
532
          reset
533
        },
534
        wait: Waits.onJobQueue
535
      }
536
    )
537
  },
538

539
  async serverJobQueueDeleteJobs (jobIds: string[]) {
540
    const params = jobIds.length > 0 && jobIds[0] === 'all'
541
      ? { all: true }
542
      : { job_ids: jobIds }
543

544
    baseEmit(
545
      'server.job_queue.delete_job', {
546
        dispatch: 'jobQueue/onJobQueueStatus',
547
        params,
548
        wait: Waits.onJobQueue
549
      }
550
    )
551
  },
552

553
  async serverJobQueuePause () {
554
    baseEmit(
555
      'server.job_queue.pause', {
556
        dispatch: 'jobQueue/onJobQueueStatus',
557
        wait: Waits.onJobQueue
558
      }
559
    )
560
  },
561

562
  async serverJobQueueStart () {
563
    baseEmit(
564
      'server.job_queue.start', {
565
        dispatch: 'jobQueue/onJobQueueStatus',
566
        wait: Waits.onJobQueue
567
      }
568
    )
569
  },
570

571
  /**
572
   * Loads the metadata for a given filepath.
573
   * Expects the full path including root.
574
   * Optionally pass the just the filename and path.
575
   */
576
  async serverFilesMetadata (filepath: string) {
577
    baseEmit(
578
      'server.files.metadata', {
579
        dispatch: 'files/onFileMetaData',
580
        params: { filename: filepath }
581
      }
582
    )
583
  },
584

585
  async serverFilesMetascan (filepath: string) {
586
    baseEmit(
587
      'server.files.metascan', {
588
        dispatch: 'files/onFileMetaData',
589
        params: { filename: filepath }
590
      }
591
    )
592
  },
593

594
  /**
595
   * This only requires path, but we pass root along too
596
   * for brevity.
597
   */
598
  async serverFilesGetDirectory (root: string, path: string) {
599
    const wait = `${Waits.onFileSystem}/${root}/${path}/`
600
    baseEmit(
601
      'server.files.get_directory',
602
      {
603
        dispatch: 'files/onServerFilesGetDirectory',
604
        wait,
605
        params: { root, path, extended: true }
606
      }
607
    )
608
  },
609

610
  async serverFilesListRoot (root: string) {
611
    const wait = `${Waits.onFileSystem}/${root}/`
612
    baseEmit(
613
      'server.files.list',
614
      {
615
        dispatch: 'files/onServerFilesListRoot',
616
        wait,
617
        params: { root }
618
      }
619
    )
620
  },
621

622
  async serverFilesMove (source: string, dest: string) {
623
    const wait = `${Waits.onFileSystem}/${source}/`
624
    baseEmit(
625
      'server.files.move', {
626
        dispatch: 'void',
627
        wait,
628
        params: {
629
          source,
630
          dest
631
        }
632
      }
633
    )
634
  },
635

636
  async serverFilesCopy (source: string, dest: string) {
637
    const wait = `${Waits.onFileSystem}/${source}/`
638
    baseEmit(
639
      'server.files.copy', {
640
        dispatch: 'void',
641
        wait,
642
        params: {
643
          source,
644
          dest
645
        }
646
      }
647
    )
648
  },
649

650
  async serverFilesZip (dest: string, items: string[], store_only?: boolean) {
651
    const wait = `${Waits.onFileSystem}/${dest}/`
652
    baseEmit(
653
      'server.files.zip', {
654
        dispatch: 'void',
655
        wait,
656
        params: {
657
          dest,
658
          items,
659
          store_only
660
        }
661
      }
662
    )
663
  },
664

665
  /**
666
   * Create a directory.
667
   * Root should be included in the path.
668
   */
669
  async serverFilesPostDirectory (path: string) {
670
    const wait = `${Waits.onFileSystem}/${path}/`
671
    baseEmit(
672
      'server.files.post_directory', {
673
        dispatch: 'void',
674
        wait,
675
        params: {
676
          path
677
        }
678
      }
679
    )
680
  },
681

682
  async serverFilesDeleteFile (path: string) {
683
    const wait = `${Waits.onFileSystem}/${path}/`
684
    baseEmit(
685
      'server.files.delete_file', {
686
        dispatch: 'void',
687
        wait,
688
        params: {
689
          path
690
        }
691
      }
692
    )
693
  },
694

695
  async serverFilesDeleteDirectory (path: string, force = false) {
696
    const wait = `${Waits.onFileSystem}/${path}/`
697
    baseEmit(
698
      'server.files.delete_directory', {
699
        dispatch: 'void',
700
        wait,
701
        params: {
702
          path,
703
          force
704
        }
705
      }
706
    )
707
  },
708

709
  async serverAnnouncementsList () {
710
    baseEmit(
711
      'server.announcements.list', {
712
        dispatch: 'announcements/onAnnouncementsList'
713
      }
714
    )
715
  },
716

717
  async serverAnnouncementsDismiss (entry_id: string, wake_time?: number) {
718
    baseEmit(
719
      'server.announcements.dismiss', {
720
        dispatch: 'void',
721
        params: {
722
          entry_id,
723
          wake_time
724
        }
725
      }
726
    )
727
  },
728

729
  async serverLogsRollover (application?: string) {
730
    baseEmit(
731
      'server.logs.rollover', {
732
        dispatch: 'server/onLogsRollOver',
733
        params: {
734
          application
735
        }
736
      }
737
    )
738
  },
739

740
  async serverWebcamsList () {
741
    baseEmit(
742
      'server.webcams.list', {
743
        dispatch: 'webcams/onWebcamsList'
744
      }
745
    )
746
  },
747

748
  async serverWebcamsWrite (webcam: WebcamConfig) {
749
    baseEmit(
750
      'server.webcams.post_item', {
751
        params: webcam
752
      }
753
    )
754
  },
755

756
  async serverWebcamsDelete (uid: string) {
757
    baseEmit(
758
      'server.webcams.delete_item', {
759
        params: {
760
          uid
761
        }
762
      }
763
    )
764
  },
765

766
  async serverSensorsList () {
767
    baseEmit(
768
      'server.sensors.list', {
769
        dispatch: 'sensors/onSensorsList'
770
      }
771
    )
772
  },
773

774
  async serverSpoolmanGetSpoolId () {
775
    baseEmit(
776
      'server.spoolman.get_spool_id', {
777
        dispatch: 'spoolman/onActiveSpool'
778
      }
779
    )
780
  },
781

782
  async serverSpoolmanPostSpoolId (spoolId: number | undefined) {
783
    baseEmit(
784
      'server.spoolman.post_spool_id', {
785
        params: { spool_id: spoolId },
786
        dispatch: 'spoolman/onActiveSpool'
787
      }
788
    )
789
  },
790

791
  async serverSpoolmanProxyGetAvailableSpools () {
792
    baseEmit(
793
      'server.spoolman.proxy', {
794
        params: {
795
          request_method: 'GET',
796
          path: '/v1/spool',
797
          use_v2_response: true
798
        },
799
        dispatch: 'spoolman/onAvailableSpools'
800
      }
801
    )
802
  }
803
}
804