1use std::sync::Arc;
4
5use openauth_core::db::User;
6use openauth_core::error::OpenAuthError;
7
8use time::OffsetDateTime;
9
10use super::{Invitation, Member, Organization, Team, TeamMember};
11
12#[derive(Clone, Default)]
13pub struct OrganizationHooks {
14 pub before_create_organization: Option<BeforeCreateOrganizationHook>,
15 pub after_create_organization: Option<AfterCreateOrganizationHook>,
16 pub before_update_organization: Option<BeforeUpdateOrganizationHook>,
17 pub after_update_organization: Option<AfterUpdateOrganizationHook>,
18 pub before_delete_organization: Option<BeforeDeleteOrganizationHook>,
19 pub after_delete_organization: Option<AfterDeleteOrganizationHook>,
20 pub before_add_member: Option<BeforeAddMemberHook>,
21 pub after_add_member: Option<AfterAddMemberHook>,
22 pub before_remove_member: Option<BeforeRemoveMemberHook>,
23 pub after_remove_member: Option<AfterRemoveMemberHook>,
24 pub before_update_member_role: Option<BeforeUpdateMemberRoleHook>,
25 pub after_update_member_role: Option<AfterUpdateMemberRoleHook>,
26 pub before_create_invitation: Option<BeforeCreateInvitationHook>,
27 pub after_create_invitation: Option<AfterCreateInvitationHook>,
28 pub before_accept_invitation: Option<BeforeAcceptInvitationHook>,
29 pub after_accept_invitation: Option<AfterAcceptInvitationHook>,
30 pub before_reject_invitation: Option<BeforeRejectInvitationHook>,
31 pub after_reject_invitation: Option<AfterRejectInvitationHook>,
32 pub before_cancel_invitation: Option<BeforeCancelInvitationHook>,
33 pub after_cancel_invitation: Option<AfterCancelInvitationHook>,
34 pub before_create_team: Option<BeforeCreateTeamHook>,
35 pub after_create_team: Option<AfterCreateTeamHook>,
36 pub before_update_team: Option<BeforeUpdateTeamHook>,
37 pub after_update_team: Option<AfterUpdateTeamHook>,
38 pub before_delete_team: Option<BeforeDeleteTeamHook>,
39 pub after_delete_team: Option<AfterDeleteTeamHook>,
40 pub before_add_team_member: Option<BeforeAddTeamMemberHook>,
41 pub after_add_team_member: Option<AfterAddTeamMemberHook>,
42 pub before_remove_team_member: Option<BeforeRemoveTeamMemberHook>,
43 pub after_remove_team_member: Option<AfterRemoveTeamMemberHook>,
44}
45
46pub type BeforeCreateOrganizationHook =
47 Arc<dyn Fn(&BeforeCreateOrganization) -> Result<(), OpenAuthError> + Send + Sync>;
48pub type AfterCreateOrganizationHook =
49 Arc<dyn Fn(&AfterCreateOrganization) -> Result<(), OpenAuthError> + Send + Sync>;
50pub type BeforeUpdateOrganizationHook = Arc<
51 dyn Fn(&BeforeUpdateOrganization) -> Result<OrganizationUpdateData, OpenAuthError>
52 + Send
53 + Sync,
54>;
55pub type AfterUpdateOrganizationHook =
56 Arc<dyn Fn(&AfterUpdateOrganization) -> Result<(), OpenAuthError> + Send + Sync>;
57pub type BeforeDeleteOrganizationHook =
58 Arc<dyn Fn(&BeforeDeleteOrganization) -> Result<(), OpenAuthError> + Send + Sync>;
59pub type AfterDeleteOrganizationHook =
60 Arc<dyn Fn(&AfterDeleteOrganization) -> Result<(), OpenAuthError> + Send + Sync>;
61pub type BeforeAddMemberHook =
62 Arc<dyn Fn(&BeforeAddMember) -> Result<MemberHookData, OpenAuthError> + Send + Sync>;
63pub type AfterAddMemberHook =
64 Arc<dyn Fn(&AfterAddMember) -> Result<(), OpenAuthError> + Send + Sync>;
65pub type BeforeRemoveMemberHook =
66 Arc<dyn Fn(&BeforeRemoveMember) -> Result<(), OpenAuthError> + Send + Sync>;
67pub type AfterRemoveMemberHook =
68 Arc<dyn Fn(&AfterRemoveMember) -> Result<(), OpenAuthError> + Send + Sync>;
69pub type BeforeUpdateMemberRoleHook = Arc<
70 dyn Fn(&BeforeUpdateMemberRole) -> Result<MemberRoleUpdateData, OpenAuthError> + Send + Sync,
71>;
72pub type AfterUpdateMemberRoleHook =
73 Arc<dyn Fn(&AfterUpdateMemberRole) -> Result<(), OpenAuthError> + Send + Sync>;
74pub type BeforeCreateInvitationHook =
75 Arc<dyn Fn(&BeforeCreateInvitation) -> Result<InvitationHookData, OpenAuthError> + Send + Sync>;
76pub type AfterCreateInvitationHook =
77 Arc<dyn Fn(&AfterCreateInvitation) -> Result<(), OpenAuthError> + Send + Sync>;
78pub type BeforeAcceptInvitationHook =
79 Arc<dyn Fn(&BeforeAcceptInvitation) -> Result<(), OpenAuthError> + Send + Sync>;
80pub type AfterAcceptInvitationHook =
81 Arc<dyn Fn(&AfterAcceptInvitation) -> Result<(), OpenAuthError> + Send + Sync>;
82pub type BeforeRejectInvitationHook =
83 Arc<dyn Fn(&BeforeRejectInvitation) -> Result<(), OpenAuthError> + Send + Sync>;
84pub type AfterRejectInvitationHook =
85 Arc<dyn Fn(&AfterRejectInvitation) -> Result<(), OpenAuthError> + Send + Sync>;
86pub type BeforeCancelInvitationHook =
87 Arc<dyn Fn(&BeforeCancelInvitation) -> Result<(), OpenAuthError> + Send + Sync>;
88pub type AfterCancelInvitationHook =
89 Arc<dyn Fn(&AfterCancelInvitation) -> Result<(), OpenAuthError> + Send + Sync>;
90pub type BeforeCreateTeamHook =
91 Arc<dyn Fn(&BeforeCreateTeam) -> Result<TeamHookData, OpenAuthError> + Send + Sync>;
92pub type AfterCreateTeamHook =
93 Arc<dyn Fn(&AfterCreateTeam) -> Result<(), OpenAuthError> + Send + Sync>;
94pub type BeforeUpdateTeamHook =
95 Arc<dyn Fn(&BeforeUpdateTeam) -> Result<TeamHookData, OpenAuthError> + Send + Sync>;
96pub type AfterUpdateTeamHook =
97 Arc<dyn Fn(&AfterUpdateTeam) -> Result<(), OpenAuthError> + Send + Sync>;
98pub type BeforeDeleteTeamHook =
99 Arc<dyn Fn(&BeforeDeleteTeam) -> Result<(), OpenAuthError> + Send + Sync>;
100pub type AfterDeleteTeamHook =
101 Arc<dyn Fn(&AfterDeleteTeam) -> Result<(), OpenAuthError> + Send + Sync>;
102pub type BeforeAddTeamMemberHook =
103 Arc<dyn Fn(&BeforeAddTeamMember) -> Result<TeamMemberHookData, OpenAuthError> + Send + Sync>;
104pub type AfterAddTeamMemberHook =
105 Arc<dyn Fn(&AfterAddTeamMember) -> Result<(), OpenAuthError> + Send + Sync>;
106pub type BeforeRemoveTeamMemberHook =
107 Arc<dyn Fn(&BeforeRemoveTeamMember) -> Result<(), OpenAuthError> + Send + Sync>;
108pub type AfterRemoveTeamMemberHook =
109 Arc<dyn Fn(&AfterRemoveTeamMember) -> Result<(), OpenAuthError> + Send + Sync>;
110
111#[derive(Debug, Clone)]
112pub struct BeforeCreateOrganization {
113 pub name: String,
114 pub slug: String,
115 pub user: User,
116}
117
118#[derive(Debug, Clone)]
119pub struct AfterCreateOrganization {
120 pub organization: Organization,
121 pub member: Member,
122 pub user: User,
123}
124
125#[derive(Debug, Clone, Default)]
126pub struct OrganizationUpdateData {
127 pub name: Option<String>,
128 pub slug: Option<String>,
129 pub logo: Option<String>,
130 pub metadata: Option<serde_json::Value>,
131}
132
133#[derive(Debug, Clone)]
134pub struct BeforeUpdateOrganization {
135 pub organization: Organization,
136 pub user: User,
137 pub data: OrganizationUpdateData,
138}
139
140#[derive(Debug, Clone)]
141pub struct AfterUpdateOrganization {
142 pub organization: Organization,
143 pub user: User,
144}
145
146#[derive(Debug, Clone)]
147pub struct BeforeDeleteOrganization {
148 pub organization: Organization,
149 pub user: User,
150}
151
152#[derive(Debug, Clone)]
153pub struct AfterDeleteOrganization {
154 pub organization: Organization,
155 pub user: User,
156}
157
158#[derive(Debug, Clone)]
159pub struct BeforeAddMember {
160 pub organization: Organization,
161 pub user: User,
162 pub member: MemberHookData,
163}
164
165#[derive(Debug, Clone)]
166pub struct MemberHookData {
167 pub organization_id: String,
168 pub user_id: String,
169 pub role: String,
170}
171
172#[derive(Debug, Clone)]
173pub struct AfterAddMember {
174 pub organization: Organization,
175 pub member: Member,
176 pub user: User,
177}
178
179#[derive(Debug, Clone)]
180pub struct BeforeRemoveMember {
181 pub organization: Organization,
182 pub member: Member,
183 pub user: User,
184}
185
186#[derive(Debug, Clone)]
187pub struct AfterRemoveMember {
188 pub organization: Organization,
189 pub member: Member,
190 pub user: User,
191}
192
193#[derive(Debug, Clone)]
194pub struct MemberRoleUpdateData {
195 pub role: String,
196}
197
198#[derive(Debug, Clone)]
199pub struct BeforeUpdateMemberRole {
200 pub organization: Organization,
201 pub member: Member,
202 pub new_role: String,
203 pub user: User,
204}
205
206#[derive(Debug, Clone)]
207pub struct AfterUpdateMemberRole {
208 pub organization: Organization,
209 pub member: Member,
210 pub previous_role: String,
211 pub user: User,
212}
213
214#[derive(Debug, Clone)]
215pub struct InvitationHookData {
216 pub organization_id: String,
217 pub email: String,
218 pub role: String,
219 pub team_id: Option<String>,
220 pub inviter_id: String,
221 pub expires_at: OffsetDateTime,
222}
223
224#[derive(Debug, Clone)]
225pub struct BeforeCreateInvitation {
226 pub organization: Organization,
227 pub inviter: User,
228 pub invitation: InvitationHookData,
229}
230
231#[derive(Debug, Clone)]
232pub struct AfterCreateInvitation {
233 pub organization: Organization,
234 pub inviter: User,
235 pub invitation: Invitation,
236}
237
238#[derive(Debug, Clone)]
239pub struct BeforeAcceptInvitation {
240 pub organization: Organization,
241 pub invitation: Invitation,
242 pub user: User,
243}
244
245#[derive(Debug, Clone)]
246pub struct AfterAcceptInvitation {
247 pub organization: Organization,
248 pub invitation: Invitation,
249 pub member: Member,
250 pub user: User,
251}
252
253#[derive(Debug, Clone)]
254pub struct BeforeRejectInvitation {
255 pub organization: Organization,
256 pub invitation: Invitation,
257 pub user: User,
258}
259
260#[derive(Debug, Clone)]
261pub struct AfterRejectInvitation {
262 pub organization: Organization,
263 pub invitation: Invitation,
264 pub user: User,
265}
266
267#[derive(Debug, Clone)]
268pub struct BeforeCancelInvitation {
269 pub organization: Organization,
270 pub invitation: Invitation,
271 pub cancelled_by: User,
272}
273
274#[derive(Debug, Clone)]
275pub struct AfterCancelInvitation {
276 pub organization: Organization,
277 pub invitation: Invitation,
278 pub cancelled_by: User,
279}
280
281#[derive(Debug, Clone)]
282pub struct TeamHookData {
283 pub organization_id: String,
284 pub name: String,
285}
286
287#[derive(Debug, Clone)]
288pub struct BeforeCreateTeam {
289 pub organization: Organization,
290 pub team: TeamHookData,
291 pub user: User,
292}
293
294#[derive(Debug, Clone)]
295pub struct AfterCreateTeam {
296 pub organization: Organization,
297 pub team: Team,
298 pub user: User,
299}
300
301#[derive(Debug, Clone)]
302pub struct BeforeUpdateTeam {
303 pub organization: Organization,
304 pub team: Team,
305 pub updates: TeamHookData,
306 pub user: User,
307}
308
309#[derive(Debug, Clone)]
310pub struct AfterUpdateTeam {
311 pub organization: Organization,
312 pub team: Option<Team>,
313 pub user: User,
314}
315
316#[derive(Debug, Clone)]
317pub struct BeforeDeleteTeam {
318 pub organization: Organization,
319 pub team: Team,
320 pub user: User,
321}
322
323#[derive(Debug, Clone)]
324pub struct AfterDeleteTeam {
325 pub organization: Organization,
326 pub team: Team,
327 pub user: User,
328}
329
330#[derive(Debug, Clone)]
331pub struct TeamMemberHookData {
332 pub team_id: String,
333 pub user_id: String,
334}
335
336#[derive(Debug, Clone)]
337pub struct BeforeAddTeamMember {
338 pub organization: Organization,
339 pub team: Team,
340 pub team_member: TeamMemberHookData,
341 pub user: User,
342}
343
344#[derive(Debug, Clone)]
345pub struct AfterAddTeamMember {
346 pub organization: Organization,
347 pub team: Team,
348 pub team_member: TeamMember,
349 pub user: User,
350}
351
352#[derive(Debug, Clone)]
353pub struct BeforeRemoveTeamMember {
354 pub organization: Organization,
355 pub team: Team,
356 pub team_member: TeamMember,
357 pub user: User,
358}
359
360#[derive(Debug, Clone)]
361pub struct AfterRemoveTeamMember {
362 pub organization: Organization,
363 pub team: Team,
364 pub team_member: TeamMember,
365 pub user: User,
366}