muzzman_daemon/
session.rs

1use std::path::PathBuf;
2
3use crate::{
4    packets::{ClientPackets, ServerPackets},
5    TDaemonSession,
6};
7use muzzman_lib::prelude::*;
8
9impl TSession for Box<dyn TDaemonSession> {
10    fn load_module(&self, path: PathBuf) -> Result<MRef, SessionError> {
11        let id = self.generate();
12        let packet = ServerPackets::LoadModule { id, path };
13
14        self.send(packet);
15        if let Some(ClientPackets::LoadModule(_, response)) = self.waiting_for(id) {
16            match response {
17                Ok(ok) => Ok(self.mref_get_or_add(ok)),
18                Err(err) => Err(err),
19            }
20        } else {
21            Err(SessionError::ServerTimeOut)
22        }
23    }
24
25    fn remove_module(&self, module_id: ModuleId) -> Result<MRow, SessionError> {
26        let id = self.generate();
27        let packet = ServerPackets::RemoveModule { id, module_id };
28
29        self.send(packet);
30        if let Some(ClientPackets::RemoveModule(_, response)) = self.waiting_for(id) {
31            match response {
32                Ok(_) => Err(SessionError::Custom("Cannot be transfered".into())),
33                Err(err) => Err(err),
34            }
35        } else {
36            Err(SessionError::ServerTimeOut)
37        }
38    }
39
40    fn register_action(
41        &self,
42        _module_id: &ModuleId,
43        _name: String,
44        _values: Vec<(String, Value)>,
45        _callback: fn(MRef, values: Vec<Type>),
46    ) -> Result<(), SessionError> {
47        todo!()
48    }
49
50    fn remove_action(&self, _module_id: &ModuleId, _name: String) -> Result<(), SessionError> {
51        todo!()
52    }
53
54    fn get_actions(&self, range: std::ops::Range<usize>) -> Result<Actions, SessionError> {
55        let id = self.generate();
56        let packet = ServerPackets::GetActions { id, range };
57
58        self.send(packet);
59        if let Some(ClientPackets::GetActions(_, response)) = self.waiting_for(id) {
60            match response {
61                Ok(ok) => {
62                    let mut tmp = Vec::new();
63                    for k in ok {
64                        tmp.push((k.0, self.mref_get_or_add(k.1), k.2))
65                    }
66                    Ok(tmp)
67                }
68                Err(err) => Err(err),
69            }
70        } else {
71            Err(SessionError::ServerTimeOut)
72        }
73    }
74
75    fn get_actions_len(&self) -> Result<usize, SessionError> {
76        let id = self.generate();
77        let packet = ServerPackets::GetActionsLen { id };
78
79        self.send(packet);
80        if let Some(ClientPackets::GetActionsLen(_, response)) = self.waiting_for(id) {
81            response
82        } else {
83            Err(SessionError::ServerTimeOut)
84        }
85    }
86
87    fn run_action(
88        &self,
89        module_id: &ModuleId,
90        name: String,
91        data: Vec<Type>,
92    ) -> Result<(), SessionError> {
93        let id = self.generate();
94        let packet = ServerPackets::RunAction {
95            id,
96            module_id: *module_id,
97            name,
98            data,
99        };
100
101        self.send(packet);
102        if let Some(ClientPackets::RunAction(_, response)) = self.waiting_for(id) {
103            response
104        } else {
105            Err(SessionError::ServerTimeOut)
106        }
107    }
108
109    fn get_modules_len(&self) -> Result<usize, SessionError> {
110        let id = self.generate();
111        let packet = ServerPackets::GetModulesLen { id };
112
113        self.send(packet);
114        if let Some(ClientPackets::GetModulesLen(_, response)) = self.waiting_for(id) {
115            response
116        } else {
117            Err(SessionError::ServerTimeOut)
118        }
119    }
120
121    fn get_modules(&self, range: std::ops::Range<usize>) -> Result<Vec<MRef>, SessionError> {
122        let id = self.generate();
123        let packet = ServerPackets::GetModules { id, range };
124
125        self.send(packet);
126        if let Some(ClientPackets::GetModules(_, response)) = self.waiting_for(id) {
127            match response {
128                Ok(ok) => {
129                    let mut tmp = Vec::new();
130                    for k in ok {
131                        tmp.push(self.mref_get_or_add(k))
132                    }
133                    Ok(tmp)
134                }
135                Err(err) => Err(err),
136            }
137        } else {
138            Err(SessionError::ServerTimeOut)
139        }
140    }
141
142    fn module_get_name(&self, module_id: &ModuleId) -> Result<String, SessionError> {
143        let id = self.generate();
144        let packet = ServerPackets::ModuleGetName {
145            id,
146            module_id: *module_id,
147        };
148
149        self.send(packet);
150        if let Some(ClientPackets::ModuleGetName(_, response)) = self.waiting_for(id) {
151            response
152        } else {
153            Err(SessionError::ServerTimeOut)
154        }
155    }
156
157    fn module_set_name(&self, module_id: &ModuleId, name: String) -> Result<(), SessionError> {
158        let id = self.generate();
159        let packet = ServerPackets::ModuleSetName {
160            id,
161            module_id: *module_id,
162            to: name,
163        };
164
165        self.send(packet);
166        if let Some(ClientPackets::ModuleSetName(_, response)) = self.waiting_for(id) {
167            response
168        } else {
169            Err(SessionError::ServerTimeOut)
170        }
171    }
172
173    fn module_get_default_name(&self, module_id: &ModuleId) -> Result<String, SessionError> {
174        let id = self.generate();
175        let packet = ServerPackets::ModuleGetDefaultName {
176            id,
177            module_id: *module_id,
178        };
179
180        self.send(packet);
181        if let Some(ClientPackets::ModuleGetDefaultName(_, response)) = self.waiting_for(id) {
182            response
183        } else {
184            Err(SessionError::ServerTimeOut)
185        }
186    }
187
188    fn module_get_desc(&self, module_id: &ModuleId) -> Result<String, SessionError> {
189        let id = self.generate();
190        let packet = ServerPackets::ModuleGetDesc {
191            id,
192            module_id: *module_id,
193        };
194
195        self.send(packet);
196        if let Some(ClientPackets::ModuleGetDesc(_, response)) = self.waiting_for(id) {
197            response
198        } else {
199            Err(SessionError::ServerTimeOut)
200        }
201    }
202
203    fn module_set_desc(&self, module_id: &ModuleId, desc: String) -> Result<(), SessionError> {
204        let id = self.generate();
205        let packet = ServerPackets::ModuleSetDesc {
206            id,
207            module_id: *module_id,
208            to: desc,
209        };
210
211        self.send(packet);
212        if let Some(ClientPackets::ModuleSetDesc(_, response)) = self.waiting_for(id) {
213            response
214        } else {
215            Err(SessionError::ServerTimeOut)
216        }
217    }
218
219    fn module_get_default_desc(&self, module_id: &ModuleId) -> Result<String, SessionError> {
220        let id = self.generate();
221        let packet = ServerPackets::ModuleGetDefaultDesc {
222            id,
223            module_id: *module_id,
224        };
225
226        self.send(packet);
227        if let Some(ClientPackets::ModuleGetDefaultDesc(_, response)) = self.waiting_for(id) {
228            response
229        } else {
230            Err(SessionError::ServerTimeOut)
231        }
232    }
233
234    fn module_get_proxy(&self, module_id: &ModuleId) -> Result<usize, SessionError> {
235        let id = self.generate();
236        let packet = ServerPackets::ModuleGetProxy {
237            id,
238            module_id: *module_id,
239        };
240
241        self.send(packet);
242        if let Some(ClientPackets::ModuleGetProxy(_, response)) = self.waiting_for(id) {
243            response
244        } else {
245            Err(SessionError::ServerTimeOut)
246        }
247    }
248
249    fn module_set_proxy(&self, module_id: &ModuleId, proxy: usize) -> Result<(), SessionError> {
250        let id = self.generate();
251        let packet = ServerPackets::ModuleSetProxy {
252            id,
253            module_id: *module_id,
254            to: proxy,
255        };
256
257        self.send(packet);
258        if let Some(ClientPackets::ModuleSetProxy(_, response)) = self.waiting_for(id) {
259            response
260        } else {
261            Err(SessionError::ServerTimeOut)
262        }
263    }
264
265    fn module_get_settings(&self, module_id: &ModuleId) -> Result<Data, SessionError> {
266        let id = self.generate();
267        let packet = ServerPackets::ModuleGetSettings {
268            id,
269            module_id: *module_id,
270        };
271
272        self.send(packet);
273        if let Some(ClientPackets::ModuleGetSettings(_, response)) = self.waiting_for(id) {
274            *response
275        } else {
276            Err(SessionError::ServerTimeOut)
277        }
278    }
279
280    fn module_set_settings(&self, module_id: &ModuleId, data: Data) -> Result<(), SessionError> {
281        let id = self.generate();
282        let packet = ServerPackets::ModuleSetSettings {
283            id,
284            module_id: *module_id,
285            to: data,
286        };
287
288        self.send(packet);
289        if let Some(ClientPackets::ModuleSetSettings(_, response)) = self.waiting_for(id) {
290            response
291        } else {
292            Err(SessionError::ServerTimeOut)
293        }
294    }
295
296    fn module_get_element_settings(&self, module_id: &ModuleId) -> Result<Data, SessionError> {
297        let id = self.generate();
298        let packet = ServerPackets::ModuleGetElementSettings {
299            id,
300            module_id: *module_id,
301        };
302
303        self.send(packet);
304        if let Some(ClientPackets::ModuleGetElementSettings(_, response)) = self.waiting_for(id) {
305            response
306        } else {
307            Err(SessionError::ServerTimeOut)
308        }
309    }
310
311    fn module_set_element_settings(
312        &self,
313        module_id: &ModuleId,
314        data: Data,
315    ) -> Result<(), SessionError> {
316        let id = self.generate();
317        let packet = ServerPackets::ModuleSetElementSettings {
318            id,
319            module_id: *module_id,
320            to: data,
321        };
322
323        self.send(packet);
324        if let Some(ClientPackets::ModuleSetElementSettings(_, response)) = self.waiting_for(id) {
325            response
326        } else {
327            Err(SessionError::ServerTimeOut)
328        }
329    }
330
331    fn module_init_location(
332        &self,
333        module_id: &ModuleId,
334        location_id: &LocationId,
335        data: FileOrData,
336    ) -> Result<(), SessionError> {
337        let id = self.generate();
338        let packet = ServerPackets::ModuleInitLocation {
339            id,
340            module_id: *module_id,
341            location_id: location_id.clone(),
342            data,
343        };
344
345        self.send(packet);
346        if let Some(ClientPackets::ModuleInitLocation(_, response)) = self.waiting_for(id) {
347            response
348        } else {
349            Err(SessionError::ServerTimeOut)
350        }
351    }
352
353    fn module_init_element(
354        &self,
355        module_id: &ModuleId,
356        element_id: &ElementId,
357    ) -> Result<(), SessionError> {
358        let id = self.generate();
359        let packet = ServerPackets::ModuleInitElement {
360            id,
361            module_id: *module_id,
362            element_id: element_id.clone(),
363        };
364
365        self.send(packet);
366        if let Some(ClientPackets::ModuleInitElement(_, response)) = self.waiting_for(id) {
367            response
368        } else {
369            Err(SessionError::ServerTimeOut)
370        }
371    }
372
373    fn module_accept_url(&self, module_id: &ModuleId, url: String) -> Result<bool, SessionError> {
374        let id = self.generate();
375        let packet = ServerPackets::ModuleAcceptUrl {
376            id,
377            module_id: *module_id,
378            url: url.to_string(),
379        };
380
381        self.send(packet);
382        if let Some(ClientPackets::ModuleAcceptUrl(_, response)) = self.waiting_for(id) {
383            response
384        } else {
385            Err(SessionError::ServerTimeOut)
386        }
387    }
388
389    fn module_accept_extension(
390        &self,
391        module_id: &ModuleId,
392        filename: &str,
393    ) -> Result<bool, SessionError> {
394        let id = self.generate();
395        let packet = ServerPackets::ModuleAcceptExtension {
396            id,
397            module_id: *module_id,
398            filename: filename.to_owned(),
399        };
400
401        self.send(packet);
402        if let Some(ClientPackets::ModuleAcceptExtension(_, response)) = self.waiting_for(id) {
403            response
404        } else {
405            Err(SessionError::ServerTimeOut)
406        }
407    }
408
409    fn module_accepted_protocols(&self, module_id: &ModuleId) -> Result<Vec<String>, SessionError> {
410        let id = self.generate();
411        let packet = ServerPackets::ModuleAcceptedProtocols {
412            id,
413            module_id: module_id.clone(),
414        };
415
416        self.send(packet);
417        if let Some(ClientPackets::ModuleAcceptedProtocols(_, response)) = self.waiting_for(id) {
418            response
419        } else {
420            Err(SessionError::ServerTimeOut)
421        }
422    }
423
424    fn module_step_element(
425        &self,
426        _module_id: &ModuleId,
427        _element_id: &ElementId,
428        _control_flow: ControlFlow,
429        _storage: Storage,
430    ) -> Result<(ControlFlow, Storage), SessionError> {
431        todo!()
432    }
433
434    fn module_step_location(
435        &self,
436        _module_id: &ModuleId,
437        _location_id: &LocationId,
438        _control_flow: ControlFlow,
439        _storage: Storage,
440    ) -> Result<(ControlFlow, Storage), SessionError> {
441        todo!()
442    }
443
444    fn create_element(&self, name: &str, location_id: &LocationId) -> Result<ERef, SessionError> {
445        let id = self.generate();
446        let packet = ServerPackets::CreateElement {
447            id,
448            location_id: location_id.clone(),
449            name: name.to_string(),
450        };
451
452        self.send(packet);
453        if let Some(ClientPackets::CreateElement(_, response)) = self.waiting_for(id) {
454            match response {
455                Ok(ok) => Ok(self.eref_get_or_add(ok)),
456                Err(err) => Err(err),
457            }
458        } else {
459            Err(SessionError::ServerTimeOut)
460        }
461    }
462
463    fn move_element(
464        &self,
465        element: &ElementId,
466        location_id: &LocationId,
467    ) -> Result<(), SessionError> {
468        let id = self.generate();
469        let packet = ServerPackets::MoveElement {
470            id,
471            element_id: element.clone(),
472            location_id: location_id.clone(),
473        };
474
475        self.send(packet);
476        if let Some(ClientPackets::MoveElement(_, response)) = self.waiting_for(id) {
477            response
478        } else {
479            Err(SessionError::ServerTimeOut)
480        }
481    }
482
483    fn destroy_element(&self, element_id: ElementId) -> Result<ERow, SessionError> {
484        let id = self.generate();
485        let packet = ServerPackets::DestroyElement { id, element_id };
486
487        self.send(packet);
488        if let Some(ClientPackets::DestroyElement(_, response)) = self.waiting_for(id) {
489            match response {
490                Ok(_) => Err(SessionError::Custom("Cannot Transfer ERow".into())),
491                Err(err) => Err(err),
492            }
493        } else {
494            Err(SessionError::ServerTimeOut)
495        }
496    }
497
498    fn element_get_name(&self, element_id: &ElementId) -> Result<String, SessionError> {
499        let id = self.generate();
500        let packet = ServerPackets::ElementGetName {
501            id,
502            element_id: element_id.clone(),
503        };
504
505        self.send(packet);
506        if let Some(ClientPackets::ElementGetName(_, response)) = self.waiting_for(id) {
507            response
508        } else {
509            Err(SessionError::ServerTimeOut)
510        }
511    }
512
513    fn element_set_name(&self, element_id: &ElementId, name: &str) -> Result<(), SessionError> {
514        let id = self.generate();
515        let packet = ServerPackets::ElementSetName {
516            id,
517            element_id: element_id.clone(),
518            to: name.to_string(),
519        };
520
521        self.send(packet);
522        if let Some(ClientPackets::ElementSetName(_, response)) = self.waiting_for(id) {
523            response
524        } else {
525            Err(SessionError::ServerTimeOut)
526        }
527    }
528
529    fn element_get_desc(&self, element_id: &ElementId) -> Result<String, SessionError> {
530        let id = self.generate();
531        let packet = ServerPackets::ElementGetDesc {
532            id,
533            element_id: element_id.clone(),
534        };
535
536        self.send(packet);
537        if let Some(ClientPackets::ElementGetDesc(_, response)) = self.waiting_for(id) {
538            response
539        } else {
540            Err(SessionError::ServerTimeOut)
541        }
542    }
543
544    fn element_set_desc(&self, element_id: &ElementId, desc: &str) -> Result<(), SessionError> {
545        let id = self.generate();
546        let packet = ServerPackets::ElementSetDesc {
547            id,
548            element_id: element_id.clone(),
549            to: desc.to_string(),
550        };
551
552        self.send(packet);
553        if let Some(ClientPackets::ElementSetDesc(_, response)) = self.waiting_for(id) {
554            response
555        } else {
556            Err(SessionError::ServerTimeOut)
557        }
558    }
559
560    fn element_get_meta(&self, element_id: &ElementId) -> Result<String, SessionError> {
561        let id = self.generate();
562        let packet = ServerPackets::ElementGetMeta {
563            id,
564            element_id: element_id.clone(),
565        };
566
567        self.send(packet);
568        if let Some(ClientPackets::ElementGetMeta(_, response)) = self.waiting_for(id) {
569            response
570        } else {
571            Err(SessionError::ServerTimeOut)
572        }
573    }
574
575    fn element_set_meta(&self, element_id: &ElementId, meta: &str) -> Result<(), SessionError> {
576        let id = self.generate();
577        let packet = ServerPackets::ElementSetMeta {
578            id,
579            element_id: element_id.clone(),
580            to: meta.to_string(),
581        };
582
583        self.send(packet);
584        if let Some(ClientPackets::ElementSetMeta(_, response)) = self.waiting_for(id) {
585            response
586        } else {
587            Err(SessionError::ServerTimeOut)
588        }
589    }
590
591    fn element_get_url(&self, element_id: &ElementId) -> Result<Option<String>, SessionError> {
592        let id = self.generate();
593        let packet = ServerPackets::ElementGetUrl {
594            id,
595            element_id: element_id.clone(),
596        };
597        self.send(packet);
598
599        if let Some(ClientPackets::ElementGetUrl(_, response)) = self.waiting_for(id) {
600            response
601        } else {
602            Err(SessionError::ServerTimeOut)
603        }
604    }
605
606    fn element_set_url(
607        &self,
608        element_id: &ElementId,
609        url: Option<String>,
610    ) -> Result<(), SessionError> {
611        let id = self.generate();
612        let packet = ServerPackets::ElementSetUrl {
613            id,
614            element_id: element_id.clone(),
615            to: url,
616        };
617        self.send(packet);
618
619        if let Some(ClientPackets::ElementSetUrl(_, response)) = self.waiting_for(id) {
620            response
621        } else {
622            Err(SessionError::ServerTimeOut)
623        }
624    }
625
626    fn element_get_element_data(&self, element_id: &ElementId) -> Result<Data, SessionError> {
627        let id = self.generate();
628        let packet = ServerPackets::ElementGetElementData {
629            id,
630            element_id: element_id.clone(),
631        };
632
633        self.send(packet);
634        if let Some(ClientPackets::ElementGetElementData(_, response)) = self.waiting_for(id) {
635            response
636        } else {
637            Err(SessionError::ServerTimeOut)
638        }
639    }
640
641    fn element_set_element_data(
642        &self,
643        element_id: &ElementId,
644        data: Data,
645    ) -> Result<(), SessionError> {
646        let id = self.generate();
647        let packet = ServerPackets::ElementSetElementData {
648            id,
649            element_id: element_id.clone(),
650            to: data,
651        };
652
653        self.send(packet);
654        if let Some(ClientPackets::ElementSetElementData(_, response)) = self.waiting_for(id) {
655            response
656        } else {
657            Err(SessionError::ServerTimeOut)
658        }
659    }
660
661    fn element_get_module_data(&self, element_id: &ElementId) -> Result<Data, SessionError> {
662        let id = self.generate();
663        let packet = ServerPackets::ElementGetModuleData {
664            id,
665            element_id: element_id.clone(),
666        };
667
668        self.send(packet);
669        if let Some(ClientPackets::ElementGetModuleData(_, response)) = self.waiting_for(id) {
670            response
671        } else {
672            Err(SessionError::ServerTimeOut)
673        }
674    }
675
676    fn element_set_module_data(
677        &self,
678        element_id: &ElementId,
679        data: Data,
680    ) -> Result<(), SessionError> {
681        let id = self.generate();
682        let packet = ServerPackets::ElementSetModuleData {
683            id,
684            element_id: element_id.clone(),
685            to: data,
686        };
687
688        self.send(packet);
689        if let Some(ClientPackets::ElementSetModuleData(_, response)) = self.waiting_for(id) {
690            response
691        } else {
692            Err(SessionError::ServerTimeOut)
693        }
694    }
695
696    fn element_get_module(&self, element_id: &ElementId) -> Result<Option<MRef>, SessionError> {
697        let id = self.generate();
698        let packet = ServerPackets::ElementGetModule {
699            id,
700            element_id: element_id.clone(),
701        };
702
703        self.send(packet);
704        if let Some(ClientPackets::ElementGetModule(_, response)) = self.waiting_for(id) {
705            match response {
706                Ok(ok) => match ok {
707                    Some(some) => Ok(Some(self.mref_get_or_add(some))),
708                    None => Ok(None),
709                },
710                Err(err) => Err(err),
711            }
712        } else {
713            Err(SessionError::ServerTimeOut)
714        }
715    }
716
717    fn element_set_module(
718        &self,
719        element_id: &ElementId,
720        module: Option<ModuleId>,
721    ) -> Result<(), SessionError> {
722        let id = self.generate();
723        let packet = ServerPackets::ElementSetModule {
724            id,
725            element_id: element_id.clone(),
726            module,
727        };
728
729        self.send(packet);
730        if let Some(ClientPackets::ElementSetModule(_, response)) = self.waiting_for(id) {
731            response
732        } else {
733            Err(SessionError::ServerTimeOut)
734        }
735    }
736
737    fn element_get_statuses(&self, element_id: &ElementId) -> Result<Vec<String>, SessionError> {
738        let id = self.generate();
739        let packet = ServerPackets::ElementGetStatuses {
740            id,
741            element_id: element_id.clone(),
742        };
743
744        self.send(packet);
745        if let Some(ClientPackets::ElementGetStatuses(_, response)) = self.waiting_for(id) {
746            response
747        } else {
748            Err(SessionError::ServerTimeOut)
749        }
750    }
751
752    fn element_set_statuses(
753        &self,
754        element_id: &ElementId,
755        statuses: Vec<String>,
756    ) -> Result<(), SessionError> {
757        let id = self.generate();
758        let packet = ServerPackets::ElementSetStatuses {
759            id,
760            element_id: element_id.clone(),
761            to: statuses,
762        };
763
764        self.send(packet);
765        if let Some(ClientPackets::ElementSetStatuses(_, response)) = self.waiting_for(id) {
766            response
767        } else {
768            Err(SessionError::ServerTimeOut)
769        }
770    }
771
772    fn element_get_status(&self, element_id: &ElementId) -> Result<usize, SessionError> {
773        let id = self.generate();
774        let packet = ServerPackets::ElementGetStatus {
775            id,
776            element_id: element_id.clone(),
777        };
778
779        self.send(packet);
780        if let Some(ClientPackets::ElementGetStatus(_, response)) = self.waiting_for(id) {
781            response
782        } else {
783            Err(SessionError::ServerTimeOut)
784        }
785    }
786
787    fn element_set_status(
788        &self,
789        element_id: &ElementId,
790        status: usize,
791    ) -> Result<(), SessionError> {
792        let id = self.generate();
793        let packet = ServerPackets::ElementSetStatus {
794            id,
795            element_id: element_id.clone(),
796            to: status,
797        };
798
799        self.send(packet);
800        if let Some(ClientPackets::ElementSetStatus(_, response)) = self.waiting_for(id) {
801            response
802        } else {
803            Err(SessionError::ServerTimeOut)
804        }
805    }
806
807    fn element_get_data(&self, element_id: &ElementId) -> Result<FileOrData, SessionError> {
808        let id = self.generate();
809        let packet = ServerPackets::ElementGetData {
810            id,
811            element_id: element_id.clone(),
812        };
813
814        self.send(packet);
815        if let Some(ClientPackets::ElementGetData(_, response)) = self.waiting_for(id) {
816            response
817        } else {
818            Err(SessionError::ServerTimeOut)
819        }
820    }
821
822    fn element_set_data(
823        &self,
824        element_id: &ElementId,
825        data: FileOrData,
826    ) -> Result<(), SessionError> {
827        let id = self.generate();
828        let packet = ServerPackets::ElementSetData {
829            id,
830            element_id: element_id.clone(),
831            to: data,
832        };
833
834        self.send(packet);
835        if let Some(ClientPackets::ElementSetData(_, response)) = self.waiting_for(id) {
836            response
837        } else {
838            Err(SessionError::ServerTimeOut)
839        }
840    }
841
842    fn element_get_progress(&self, element_id: &ElementId) -> Result<f32, SessionError> {
843        let id = self.generate();
844        let packet = ServerPackets::ElementGetProgress {
845            id,
846            element_id: element_id.clone(),
847        };
848
849        self.send(packet);
850        if let Some(ClientPackets::ElementGetProgress(_, response)) = self.waiting_for(id) {
851            response
852        } else {
853            Err(SessionError::ServerTimeOut)
854        }
855    }
856
857    fn element_set_progress(
858        &self,
859        element_id: &ElementId,
860        progress: f32,
861    ) -> Result<(), SessionError> {
862        let id = self.generate();
863        let packet = ServerPackets::ElementSetProgress {
864            id,
865            element_id: element_id.clone(),
866            to: progress,
867        };
868
869        self.send(packet);
870        if let Some(ClientPackets::ElementSetProgress(_, response)) = self.waiting_for(id) {
871            response
872        } else {
873            Err(SessionError::ServerTimeOut)
874        }
875    }
876
877    fn element_get_should_save(&self, element_id: &ElementId) -> Result<bool, SessionError> {
878        let id = self.generate();
879        let packet = ServerPackets::ElementGetShouldSave {
880            id,
881            element_id: element_id.clone(),
882        };
883
884        self.send(packet);
885        if let Some(ClientPackets::ElementGetShouldSave(_, response)) = self.waiting_for(id) {
886            response
887        } else {
888            Err(SessionError::ServerTimeOut)
889        }
890    }
891
892    fn element_set_should_save(
893        &self,
894        element_id: &ElementId,
895        should_save: bool,
896    ) -> Result<(), SessionError> {
897        let id = self.generate();
898        let packet = ServerPackets::ElementSetShouldSave {
899            id,
900            element_id: element_id.clone(),
901            to: should_save,
902        };
903
904        self.send(packet);
905        if let Some(ClientPackets::ElementSetShouldSave(_, response)) = self.waiting_for(id) {
906            response
907        } else {
908            Err(SessionError::ServerTimeOut)
909        }
910    }
911
912    fn element_get_enabled(&self, element_id: &ElementId) -> Result<bool, SessionError> {
913        let id = self.generate();
914        let packet = ServerPackets::ElementGetEnabled {
915            id,
916            element_id: element_id.clone(),
917        };
918
919        self.send(packet);
920        if let Some(ClientPackets::ElementGetEnabled(_, response)) = self.waiting_for(id) {
921            response
922        } else {
923            Err(SessionError::ServerTimeOut)
924        }
925    }
926
927    fn element_set_enabled(
928        &self,
929        element_id: &ElementId,
930        enabled: bool,
931        storage: Option<Storage>,
932    ) -> Result<(), SessionError> {
933        if storage.is_some() {
934            // TODO: Find a method to implement this!
935            todo!()
936        }
937
938        let id = self.generate();
939        let packet = ServerPackets::ElementSetEnabled {
940            id,
941            element_id: element_id.clone(),
942            to: enabled,
943        };
944
945        self.send(packet);
946        if let Some(ClientPackets::ElementSetEnabled(_, response)) = self.waiting_for(id) {
947            response
948        } else {
949            Err(SessionError::ServerTimeOut)
950        }
951    }
952
953    fn element_resolv_module(&self, element_id: &ElementId) -> Result<bool, SessionError> {
954        let id = self.generate();
955        let packet = ServerPackets::ElementResolvModule {
956            id,
957            element_id: element_id.clone(),
958        };
959
960        self.send(packet);
961        if let Some(ClientPackets::ElementResolvModule(_, response)) = self.waiting_for(id) {
962            response
963        } else {
964            Err(SessionError::ServerTimeOut)
965        }
966    }
967
968    fn element_wait(&self, element_id: &ElementId) -> Result<(), SessionError> {
969        // TODO: Fix daemon problem in ServerPackets::ElementWait
970
971        let id = self.generate();
972        let packet = ServerPackets::ElementWait {
973            id,
974            element_id: element_id.clone(),
975        };
976
977        self.send(packet);
978        if let Some(ClientPackets::ElementWait(_, response)) = self.waiting_for(id) {
979            response
980        } else {
981            Err(SessionError::ServerTimeOut)
982        }
983    }
984
985    fn element_get_element_info(
986        &self,
987        element_id: &ElementId,
988    ) -> Result<ElementInfo, SessionError> {
989        let id = self.generate();
990        let packet = ServerPackets::ElementGetInfo {
991            id,
992            element_id: element_id.clone(),
993        };
994
995        self.send(packet);
996        if let Some(ClientPackets::ElementGetInfo(_, response)) = self.waiting_for(id) {
997            *response
998        } else {
999            Err(SessionError::ServerTimeOut)
1000        }
1001    }
1002
1003    fn element_notify(&self, element_id: &ElementId, event: Event) -> Result<(), SessionError> {
1004        let id = self.generate();
1005        let packet = ServerPackets::ElementNotify {
1006            id,
1007            element_id: element_id.clone(),
1008            event,
1009        };
1010
1011        self.send(packet);
1012        if let Some(ClientPackets::ElementNotify(_, response)) = self.waiting_for(id) {
1013            response
1014        } else {
1015            Err(SessionError::ServerTimeOut)
1016        }
1017    }
1018
1019    fn element_emit(&self, element_id: &ElementId, event: Event) -> Result<(), SessionError> {
1020        let id = self.generate();
1021        let packet = ServerPackets::ElementEmit {
1022            id,
1023            element_id: element_id.clone(),
1024            event,
1025        };
1026
1027        self.send(packet);
1028        if let Some(ClientPackets::ElementEmit(_, response)) = self.waiting_for(id) {
1029            response
1030        } else {
1031            Err(SessionError::ServerTimeOut)
1032        }
1033    }
1034
1035    fn element_subscribe(&self, element_id: &ElementId, _ref: ID) -> Result<(), SessionError> {
1036        let id = self.generate();
1037        let packet = ServerPackets::ElementSubscribe {
1038            id,
1039            element_id: element_id.clone(),
1040            to: _ref,
1041        };
1042
1043        self.send(packet);
1044        if let Some(ClientPackets::ElementSubscribe(_, response)) = self.waiting_for(id) {
1045            response
1046        } else {
1047            Err(SessionError::ServerTimeOut)
1048        }
1049    }
1050
1051    fn element_unsubscribe(&self, element_id: &ElementId, _ref: ID) -> Result<(), SessionError> {
1052        let id = self.generate();
1053        let packet = ServerPackets::ElementUnSubscribe {
1054            id,
1055            element_id: element_id.clone(),
1056            to: _ref,
1057        };
1058
1059        self.send(packet);
1060        if let Some(ClientPackets::ElementUnSubscribe(_, response)) = self.waiting_for(id) {
1061            response
1062        } else {
1063            Err(SessionError::ServerTimeOut)
1064        }
1065    }
1066
1067    fn create_location(&self, name: &str, location_id: &LocationId) -> Result<LRef, SessionError> {
1068        let id = self.generate();
1069        let packet = ServerPackets::CreateLocation {
1070            id,
1071            name: name.to_owned(),
1072            location_id: location_id.clone(),
1073        };
1074
1075        self.send(packet);
1076        if let Some(ClientPackets::CreateLocation(_, response)) = self.waiting_for(id) {
1077            match response {
1078                Ok(ok) => Ok(self.lref_get_or_add(ok)),
1079                Err(err) => Err(err),
1080            }
1081        } else {
1082            Err(SessionError::ServerTimeOut)
1083        }
1084    }
1085
1086    fn get_locations_len(&self, location_id: &LocationId) -> Result<usize, SessionError> {
1087        let id = self.generate();
1088        let packet = ServerPackets::GetLocationsLen {
1089            id,
1090            location_id: location_id.clone(),
1091        };
1092
1093        self.send(packet);
1094        if let Some(ClientPackets::GetLocationsLen(_, response)) = self.waiting_for(id) {
1095            response
1096        } else {
1097            Err(SessionError::ServerTimeOut)
1098        }
1099    }
1100
1101    fn get_locations(
1102        &self,
1103        location_id: &LocationId,
1104        range: std::ops::Range<usize>,
1105    ) -> Result<Vec<LRef>, SessionError> {
1106        let id = self.generate();
1107        let packet = ServerPackets::GetLocations {
1108            id,
1109            location_id: location_id.clone(),
1110            range,
1111        };
1112
1113        self.send(packet);
1114        if let Some(ClientPackets::GetLocations(_, response)) = self.waiting_for(id) {
1115            match response {
1116                Ok(ok) => {
1117                    let mut tmp = Vec::with_capacity(ok.len());
1118
1119                    for k in ok {
1120                        tmp.push(self.lref_get_or_add(k))
1121                    }
1122
1123                    Ok(tmp)
1124                }
1125                Err(err) => Err(err),
1126            }
1127        } else {
1128            Err(SessionError::ServerTimeOut)
1129        }
1130    }
1131
1132    fn destroy_location(&self, location_id: LocationId) -> Result<LRow, SessionError> {
1133        let id = self.generate();
1134        let packet = ServerPackets::DestroyLocation { id, location_id };
1135
1136        self.send(packet);
1137        if let Some(ClientPackets::DestroyLocation(_, response)) = self.waiting_for(id) {
1138            match response {
1139                Ok(_) => Err(SessionError::Custom("LRow Cannot be transfered!".into())),
1140                Err(err) => Err(err),
1141            }
1142        } else {
1143            Err(SessionError::ServerTimeOut)
1144        }
1145    }
1146
1147    fn get_default_location(&self) -> Result<LRef, SessionError> {
1148        let id = self.generate();
1149        let packet = ServerPackets::GetDefaultLocation { id };
1150        self.send(packet);
1151        if let Some(packet) = self.waiting_for(id) {
1152            if let ClientPackets::GetDefaultLocation(_, response) = packet {
1153                match response {
1154                    Ok(ok) => Ok(self.lref_get_or_add(ok)),
1155                    Err(err) => Err(err),
1156                }
1157            } else {
1158                panic!()
1159            }
1160        } else {
1161            Err(SessionError::ServerTimeOut)
1162        }
1163    }
1164
1165    fn move_location(&self, location_id: &LocationId, to: &LocationId) -> Result<(), SessionError> {
1166        let id = self.generate();
1167        let packet = ServerPackets::MoveLocation {
1168            id,
1169            location_id: location_id.clone(),
1170            to: to.clone(),
1171        };
1172        self.send(packet);
1173        if let Some(ClientPackets::MoveLocation(_, response)) = self.waiting_for(id) {
1174            response
1175        } else {
1176            Err(SessionError::ServerTimeOut)
1177        }
1178    }
1179
1180    fn location_get_name(&self, location_id: &LocationId) -> Result<String, SessionError> {
1181        let id = self.generate();
1182        let packet = ServerPackets::LocationGetName {
1183            id,
1184            from: location_id.clone(),
1185        };
1186        self.send(packet);
1187        if let Some(ClientPackets::LocationGetName(_, response)) = self.waiting_for(id) {
1188            response
1189        } else {
1190            Err(SessionError::ServerTimeOut)
1191        }
1192    }
1193
1194    fn location_set_name(&self, location_id: &LocationId, name: &str) -> Result<(), SessionError> {
1195        let id = self.generate();
1196        let packet = ServerPackets::LocationSetName {
1197            id,
1198            from: location_id.clone(),
1199            to: name.to_string(),
1200        };
1201        self.send(packet);
1202        if let Some(ClientPackets::LocationSetName(_, response)) = self.waiting_for(id) {
1203            response
1204        } else {
1205            Err(SessionError::ServerTimeOut)
1206        }
1207    }
1208
1209    fn location_get_desc(&self, location_id: &LocationId) -> Result<String, SessionError> {
1210        let id = self.generate();
1211        let packet = ServerPackets::LocationGetDesc {
1212            id,
1213            from: location_id.clone(),
1214        };
1215        self.send(packet);
1216        if let Some(ClientPackets::LocationGetDesc(_, response)) = self.waiting_for(id) {
1217            response
1218        } else {
1219            Err(SessionError::ServerTimeOut)
1220        }
1221    }
1222
1223    fn location_set_desc(&self, location_id: &LocationId, desc: &str) -> Result<(), SessionError> {
1224        let id = self.generate();
1225        let packet = ServerPackets::LocationSetDesc {
1226            id,
1227            from: location_id.clone(),
1228            to: desc.to_string(),
1229        };
1230        self.send(packet);
1231        if let Some(ClientPackets::LocationSetDesc(_, response)) = self.waiting_for(id) {
1232            response
1233        } else {
1234            Err(SessionError::ServerTimeOut)
1235        }
1236    }
1237
1238    fn location_get_path(&self, location_id: &LocationId) -> Result<PathBuf, SessionError> {
1239        let id = self.generate();
1240        let packet = ServerPackets::LocationGetPath {
1241            id,
1242            location_id: location_id.clone(),
1243        };
1244        self.send(packet);
1245        if let Some(ClientPackets::LocationGetPath(_, response)) = self.waiting_for(id) {
1246            response
1247        } else {
1248            Err(SessionError::ServerTimeOut)
1249        }
1250    }
1251
1252    fn location_set_path(
1253        &self,
1254        location_id: &LocationId,
1255        path: PathBuf,
1256    ) -> Result<(), SessionError> {
1257        let id = self.generate();
1258        let packet = ServerPackets::LocationSetPath {
1259            id,
1260            location_id: location_id.clone(),
1261            to: path,
1262        };
1263        self.send(packet);
1264        if let Some(ClientPackets::LocationSetPath(_, response)) = self.waiting_for(id) {
1265            response
1266        } else {
1267            Err(SessionError::ServerTimeOut)
1268        }
1269    }
1270
1271    fn location_get_where_is(
1272        &self,
1273        _location_id: &LocationId,
1274    ) -> Result<WhereIsLocation, SessionError> {
1275        todo!()
1276    }
1277
1278    fn location_set_where_is(
1279        &self,
1280        _location_id: &LocationId,
1281        _where_is: WhereIsLocation,
1282    ) -> Result<(), SessionError> {
1283        todo!()
1284    }
1285
1286    fn location_get_should_save(&self, location_id: &LocationId) -> Result<bool, SessionError> {
1287        let id = self.generate();
1288        let packet = ServerPackets::LocationGetShouldSave {
1289            id,
1290            location_id: location_id.clone(),
1291        };
1292        self.send(packet);
1293        if let Some(ClientPackets::LocationGetShouldSave(_, response)) = self.waiting_for(id) {
1294            response
1295        } else {
1296            Err(SessionError::ServerTimeOut)
1297        }
1298    }
1299
1300    fn location_set_should_save(
1301        &self,
1302        location_id: &LocationId,
1303        should_save: bool,
1304    ) -> Result<(), SessionError> {
1305        let id = self.generate();
1306        let packet = ServerPackets::LocationSetShouldSave {
1307            id,
1308            location_id: location_id.clone(),
1309            to: should_save,
1310        };
1311        self.send(packet);
1312        if let Some(ClientPackets::LocationSetShouldSave(_, response)) = self.waiting_for(id) {
1313            response
1314        } else {
1315            Err(SessionError::ServerTimeOut)
1316        }
1317    }
1318
1319    fn location_get_elements_len(&self, location_id: &LocationId) -> Result<usize, SessionError> {
1320        let id = self.generate();
1321        let packet = ServerPackets::LocationGetElementsLen {
1322            id,
1323            location_id: location_id.clone(),
1324        };
1325        self.send(packet);
1326        if let Some(ClientPackets::LocationGetElementsLen(_, response)) = self.waiting_for(id) {
1327            response
1328        } else {
1329            Err(SessionError::ServerTimeOut)
1330        }
1331    }
1332
1333    fn location_get_elements(
1334        &self,
1335        location_id: &LocationId,
1336        range: std::ops::Range<usize>,
1337    ) -> Result<Vec<ERef>, SessionError> {
1338        let id = self.generate();
1339        let packet = ServerPackets::LocationGetElements {
1340            id,
1341            location_id: location_id.clone(),
1342            range,
1343        };
1344        self.send(packet);
1345        if let Some(ClientPackets::LocationGetElements(_, response)) = self.waiting_for(id) {
1346            match response {
1347                Ok(ok) => {
1348                    let mut tmp = Vec::with_capacity(ok.len());
1349
1350                    for k in ok {
1351                        tmp.push(self.eref_get_or_add(k))
1352                    }
1353
1354                    Ok(tmp)
1355                }
1356                Err(err) => Err(err),
1357            }
1358        } else {
1359            Err(SessionError::ServerTimeOut)
1360        }
1361    }
1362
1363    fn location_get_location_info(
1364        &self,
1365        location_id: &LocationId,
1366    ) -> Result<LocationInfo, SessionError> {
1367        let id = self.generate();
1368        let packet = ServerPackets::LocationGetInfo {
1369            id,
1370            from: location_id.clone(),
1371        };
1372        self.send(packet);
1373        if let Some(ClientPackets::LocationGetInfo(_, response)) = self.waiting_for(id) {
1374            response
1375        } else {
1376            Err(SessionError::ServerTimeOut)
1377        }
1378    }
1379
1380    fn location_notify(&self, location_id: &LocationId, event: Event) -> Result<(), SessionError> {
1381        let id = self.generate();
1382        let packet = ServerPackets::LocationNotify {
1383            id,
1384            location_id: location_id.clone(),
1385            event,
1386        };
1387        self.send(packet);
1388        if let Some(ClientPackets::LocationNotify(_, response)) = self.waiting_for(id) {
1389            response
1390        } else {
1391            Err(SessionError::ServerTimeOut)
1392        }
1393    }
1394
1395    fn location_emit(&self, location_id: &LocationId, event: Event) -> Result<(), SessionError> {
1396        let id = self.generate();
1397        let packet = ServerPackets::LocationEmit {
1398            id,
1399            location_id: location_id.clone(),
1400            event,
1401        };
1402        self.send(packet);
1403        if let Some(ClientPackets::LocationEmit(_, response)) = self.waiting_for(id) {
1404            response
1405        } else {
1406            Err(SessionError::ServerTimeOut)
1407        }
1408    }
1409
1410    fn location_subscribe(&self, location_id: &LocationId, _ref: ID) -> Result<(), SessionError> {
1411        let id = self.generate();
1412        let packet = ServerPackets::LocationSubscribe {
1413            id,
1414            location_id: location_id.clone(),
1415            to: _ref,
1416        };
1417        self.send(packet);
1418        if let Some(ClientPackets::LocationSubscribe(_, response)) = self.waiting_for(id) {
1419            response
1420        } else {
1421            Err(SessionError::ServerTimeOut)
1422        }
1423    }
1424
1425    fn location_unsubscribe(&self, location_id: &LocationId, _ref: ID) -> Result<(), SessionError> {
1426        let id = self.generate();
1427        let packet = ServerPackets::LocationUnSubscribe {
1428            id,
1429            location_id: location_id.clone(),
1430            to: _ref,
1431        };
1432        self.send(packet);
1433        if let Some(ClientPackets::LocationUnSubscribe(_, response)) = self.waiting_for(id) {
1434            response
1435        } else {
1436            Err(SessionError::ServerTimeOut)
1437        }
1438    }
1439
1440    fn get_module_ref(&self, id: &ModuleId) -> Result<MRef, SessionError> {
1441        Ok(self.mref_get_or_add(*id))
1442    }
1443
1444    fn get_element_ref(&self, id: &ElementId) -> Result<ERef, SessionError> {
1445        Ok(self.eref_get_or_add(id.clone()))
1446    }
1447
1448    fn get_location_ref(&self, id: &LocationId) -> Result<LRef, SessionError> {
1449        Ok(self.lref_get_or_add(id.clone()))
1450    }
1451
1452    fn c(&self) -> Box<dyn TSession> {
1453        Box::new(self.cl())
1454    }
1455}
muzzman_daemon/session.rs

muzzman_daemon/
session.rs
