botx_api_framework/extensions/
anthill_di.rs1use std::any::TypeId;
2
3use anthill_di::{
4 DependencyContext,
5 LifeCycle,
6 types::*,
7 ServiceMappingBuilder,
8 Constructor
9};
10use async_lock::RwLock;
11use easy_ext::ext;
12use regex::Regex;
13
14use crate::{handlers::{
15 command::*,
16 button::*,
17 internal_bot_notification::*,
18 message::*,
19 added_to_chat::*,
20 chat_created::*,
21 chat_deleted_by_user::*,
22 cts_login::*,
23 cts_logout::*,
24 deleted_from_chat::*,
25 left_from_chat::*,
26 smartapp_event::*,
27 status::*,
28 notification_result::*,
29 edit_event::*,
30 },
31 contexts::{
32 BotXApiFrameworkContext,
33 NotificationContext
34 }
35};
36
37
38#[ext(IAnthillDiExt)]
39#[async_trait_with_sync::async_trait]
40pub impl DependencyContext {
41 async fn register_command_detection_regex(&self, regex: Regex) -> AddDependencyResult<ServiceMappingBuilder<CommandDetectionRegex>> {
42 self.register_closure::<CommandDetectionRegex, _>(
43 move |_| Ok(regex.clone().into()),
44 LifeCycle::Transient,
45 )
46 .await
47 }
48
49 async fn register_command_handler<THandler: ICommandHandler + Constructor + 'static>(&self, command_regex: Regex)
50 -> MapComponentResult<ServiceMappingBuilder<THandler>>
51 {
52 self.register_closure(move |_| Ok(CommandHandlerMatchingRule::<THandler> {
53 command_regex: command_regex.clone().into(),
54 pd: Default::default(),
55 }),
56 LifeCycle::Transient).await.unwrap()
57 .map_as::<dyn ICommandHandlerMatchingRule>().await?;
58
59 self.register_type::<THandler>(LifeCycle::Transient)
60 .await
61 .unwrap()
62 .map_as::<dyn ICommandHandler>()
63 .await
64 }
65
66 async fn register_default_command_handler<THandler: ICommandHandler + 'static>(&self) -> AddDependencyResult<ServiceMappingBuilder<DefaultCommandHandlerId>> {
67 self.register_closure::<DefaultCommandHandlerId, _>(
68 |_| Ok(DefaultCommandHandlerId(TypeId::of::<THandler>())),
69 LifeCycle::Transient
70 ).await
71 }
72
73 async fn register_message_handler<THandler: IMessageHandler + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
74 self.register_type::<THandler>(LifeCycle::Transient)
75 .await
76 .unwrap()
77 .map_as::<dyn IMessageHandler>()
78 .await
79 }
80
81 async fn register_button_handler<THandler: IButtonHandler + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
82 self.register_type::<ButtonHandlerMatchingRule<THandler>>(LifeCycle::Transient)
83 .await
84 .unwrap()
85 .map_as::<dyn IButtonHandlerMatchingRule>()
86 .await?;
87
88 self.register_type::<THandler>(LifeCycle::Transient)
89 .await
90 .unwrap()
91 .map_as::<dyn IButtonHandlerCallProducer>()
92 .await
93 }
94
95 async fn register_default_button_handler<THandler: IButtonHandler<TData = serde_json::Value, TMetaData = serde_json::Value> + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
96 self.register_type::<THandler>(LifeCycle::Transient)
97 .await
98 .unwrap()
99 .map_as::<dyn IButtonHandler<TData = serde_json::Value, TMetaData = serde_json::Value>>()
100 .await
101 }
102
103 async fn register_internal_notification_handler<THandler: IInternalBotNotificationHandler + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
104 self.register_type::<InternalBotNotificationDataProcessor<THandler>>(LifeCycle::Transient)
105 .await
106 .unwrap()
107 .map_as::<dyn IInternalBotNotificationDataProcessor>()
108 .await?;
109
110 self.register_type::<THandler>(LifeCycle::Transient)
111 .await
112 .unwrap()
113 .map_as::<dyn IInternalBotNotificationCallProducer>()
114 .await
115 }
116
117 async fn register_default_internal_notification_handler<THandler: IInternalBotNotificationHandler<TData = serde_json::Value, TOptions = serde_json::Value> + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
118 self.register_type::<THandler>(LifeCycle::Transient)
119 .await
120 .unwrap()
121 .map_as::<dyn IInternalBotNotificationHandler<TData = serde_json::Value, TOptions = serde_json::Value>>().await
122 }
123
124 async fn register_smartapp_event_handler<THandler: ISmartappEventHandler + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
125 self.register_type::<SmartappEventDataProcessor<THandler>>(LifeCycle::Transient)
126 .await
127 .unwrap()
128 .map_as::<dyn ISmartappEventDataProcessor>()
129 .await?;
130
131 self.register_type::<THandler>(LifeCycle::Transient)
132 .await
133 .unwrap()
134 .map_as::<dyn ISmartappEventCallProducer>()
135 .await
136 }
137
138 async fn register_default_smartapp_event_handler<THandler: ISmartappEventHandler<TData = serde_json::Value, TOptions = serde_json::Value> + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
139 self.register_type::<THandler>(LifeCycle::Transient)
140 .await
141 .unwrap()
142 .map_as::<dyn ISmartappEventHandler<TData = serde_json::Value, TOptions = serde_json::Value>>().await
143 }
144
145 async fn register_add_to_chat_handler<THandler: IAddedToChatHandler + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
146 self.register_type::<THandler>(LifeCycle::Transient)
147 .await
148 .unwrap()
149 .map_as::<dyn IAddedToChatHandler>().await
150 }
151
152 async fn register_chat_created_handler<THandler: IChatCreatedHandler + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
153 self.register_type::<THandler>(LifeCycle::Transient)
154 .await
155 .unwrap()
156 .map_as::<dyn IChatCreatedHandler>().await
157 }
158
159 async fn register_chat_deleted_by_user_handler<THandler: IChatDeletedByUserHandler + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
160 self.register_type::<THandler>(LifeCycle::Transient)
161 .await
162 .unwrap()
163 .map_as::<dyn IChatDeletedByUserHandler>().await
164 }
165
166 async fn register_cts_login_handler<THandler: ICtsLoginHandler + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
167 self.register_type::<THandler>(LifeCycle::Transient)
168 .await
169 .unwrap()
170 .map_as::<dyn ICtsLoginHandler>().await
171 }
172
173 async fn register_cts_logout_handler<THandler: ICtsLogoutHandler + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
174 self.register_type::<THandler>(LifeCycle::Transient)
175 .await
176 .unwrap()
177 .map_as::<dyn ICtsLogoutHandler>().await
178 }
179
180 async fn register_delete_from_chat_handler<THandler: IDeletedFromChatHandler + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
181 self.register_type::<THandler>(LifeCycle::Transient)
182 .await
183 .unwrap()
184 .map_as::<dyn IDeletedFromChatHandler>().await
185 }
186
187 async fn register_left_from_chat_handler<THandler: ILeftFromChatHandler + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
188 self.register_type::<THandler>(LifeCycle::Transient)
189 .await
190 .unwrap()
191 .map_as::<dyn ILeftFromChatHandler>().await
192 }
193
194 async fn register_event_edit_handler<THandler: IEventEditHandler + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
195 self.register_type::<THandler>(LifeCycle::Transient)
196 .await
197 .unwrap()
198 .map_as::<dyn IEventEditHandler>().await
199 }
200
201 async fn register_botx_api_framework_context(&self) -> AddDependencyResult<ServiceMappingBuilder<BotXApiFrameworkContext>> {
202 self.register_type::<BotXApiFrameworkContext>(LifeCycle::Transient).await
203 }
204
205 async fn register_notification_callback_handler<THandler: INotificationResultHandler + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
206 self.register_type::<THandler>(LifeCycle::Transient)
207 .await
208 .unwrap()
209 .map_as::<dyn INotificationResultHandler>().await
210 }
211
212 async fn register_status_handler<THandler: IStatusHandler + Constructor + 'static>(&self) -> MapComponentResult<ServiceMappingBuilder<THandler>> {
213 self.register_type::<THandler>(LifeCycle::Transient)
214 .await
215 .unwrap()
216 .map_as::<dyn IStatusHandler>().await
217 }
218
219 async fn register_notification_context(&self) -> AddDependencyResult<ServiceMappingBuilder<RwLock<NotificationContext>>> {
220 self.register_type::<NotificationContext>(LifeCycle::Transient)
221 .await.unwrap();
222 let ctx = self.resolve::<NotificationContext>().await.unwrap();
223 self.register_instance(RwLock::new(ctx)).await
224 }
225}