Track and resend organization invitation emails

crates/api/src/conversions.rs

@@ -648,6 +648,44 @@ pub fn services_invitation_email_status_to_api(
     }
 }
 
+pub fn api_invitation_status_to_services(
+    status: crate::models::InvitationStatus,
+) -> services::organization::InvitationStatus {
+    match status {
+        crate::models::InvitationStatus::Pending => {
+            services::organization::InvitationStatus::Pending
+        }
+        crate::models::InvitationStatus::Accepted => {
+            services::organization::InvitationStatus::Accepted
+        }
+        crate::models::InvitationStatus::Declined => {
+            services::organization::InvitationStatus::Declined
+        }
+        crate::models::InvitationStatus::Expired => {
+            services::organization::InvitationStatus::Expired
+        }
+    }
+}
+
+pub fn api_invitation_email_status_to_services(
+    status: crate::models::InvitationEmailStatus,
+) -> services::organization::InvitationEmailStatus {
+    match status {
+        crate::models::InvitationEmailStatus::NotAttempted => {
+            services::organization::InvitationEmailStatus::NotAttempted
+        }
+        crate::models::InvitationEmailStatus::Sent => {
+            services::organization::InvitationEmailStatus::Sent
+        }
+        crate::models::InvitationEmailStatus::Failed => {
+            services::organization::InvitationEmailStatus::Failed
+        }
+        crate::models::InvitationEmailStatus::Skipped => {
+            services::organization::InvitationEmailStatus::Skipped
+        }
+    }
+}
+
 /// Convert services OrganizationInvitation to API OrganizationInvitationResponse
 pub fn services_invitation_to_api(
     invitation: services::organization::OrganizationInvitation,
@@ -680,6 +718,47 @@ pub fn services_invitation_to_api_with_org(
     }
 }
 
+pub fn services_invitation_email_delivery_to_api(
+    delivery: services::organization::OrganizationInvitationEmailDelivery,
+) -> crate::models::AdminInvitationEmailDeliveryResponse {
+    let invitation = delivery.invitation;
+
+    crate::models::AdminInvitationEmailDeliveryResponse {
+        organization_id: invitation.organization_id.0.to_string(),
+        organization_name: delivery.organization_name,
+        invitation_id: invitation.id.to_string(),
+        recipient_email: invitation.email,
+        role: services_role_to_api_role(invitation.role),
+        invitation_status: services_invitation_status_to_api(invitation.status),
+        email_status: services_invitation_email_status_to_api(invitation.email_status),
+        email_sent_at: invitation.email_sent_at,
+        email_last_error: invitation.email_last_error,
+        email_message_id: invitation.email_message_id,
+        invited_by_user_id: invitation.invited_by_user_id.0.to_string(),
+        invited_by_email: delivery.invited_by_email,
+        invited_by_display_name: delivery.invited_by_display_name,
+        created_at: invitation.created_at,
+        expires_at: invitation.expires_at,
+        responded_at: invitation.responded_at,
+    }
+}
+
+pub fn services_invitation_resend_result_to_api(
+    result: services::organization::InvitationEmailResendResult,
+) -> crate::models::AdminInvitationEmailResendResultResponse {
+    crate::models::AdminInvitationEmailResendResultResponse {
+        invitation_id: result.invitation_id.to_string(),
+        recipient_email: result.recipient_email,
+        success: result.success,
+        email_sent: result.email_sent,
+        email_status: services_invitation_email_status_to_api(result.email_status),
+        email_sent_at: result.email_sent_at,
+        email_message_id: result.email_message_id,
+        email_last_error: result.email_last_error,
+        error: result.error,
+    }
+}
+
 /// Convert database::User to AdminUserResponse (for owners/admins only)  
 pub fn db_user_to_admin_user(user: &database::User) -> AdminUserResponse {
     AdminUserResponse {

crates/api/src/lib.rs

@@ -874,10 +874,13 @@ pub fn build_app_with_config(
         database.clone(),
         &auth_components.auth_state_middleware,
         config.clone(),
-        app_state.inference_provider_pool.clone(),
-        analytics_service,
-        domain_services.models_service.clone(),
-        domain_services.completion_service.clone(),
+        AdminRouteDependencies {
+            inference_provider_pool: app_state.inference_provider_pool.clone(),
+            analytics_service,
+            models_service: domain_services.models_service.clone(),
+            completion_service: domain_services.completion_service.clone(),
+            organization_service: domain_services.organization_service.clone(),
+        },
     );
 
     let invitation_routes =
@@ -1529,23 +1532,30 @@ fn cache_control_layer(value: &'static str) -> CacheControlLayer {
 }
 
 /// Build admin routes (authenticated endpoints)
+pub struct AdminRouteDependencies {
+    pub inference_provider_pool: Arc<services::inference_provider_pool::InferenceProviderPool>,
+    pub analytics_service: Arc<services::admin::AnalyticsService>,
+    pub models_service: Arc<services::models::ModelsServiceImpl>,
+    pub completion_service: Arc<services::CompletionServiceImpl>,
+    pub organization_service:
+        Arc<dyn services::organization::OrganizationServiceTrait + Send + Sync>,
+}
+
 pub fn build_admin_routes(
     database: Arc<Database>,
     auth_state_middleware: &AuthState,
     config: Arc<ApiConfig>,
-    inference_provider_pool: Arc<services::inference_provider_pool::InferenceProviderPool>,
-    analytics_service: Arc<services::admin::AnalyticsService>,
-    models_service: Arc<services::models::ModelsServiceImpl>,
-    completion_service: Arc<services::CompletionServiceImpl>,
+    dependencies: AdminRouteDependencies,
 ) -> Router {
     use crate::middleware::admin_middleware;
     use crate::routes::admin::{
         batch_upsert_models, create_admin_access_token, create_service, delete_admin_access_token,
         delete_model, deprecate_model, get_model_history, get_organization_concurrent_limit,
         get_organization_limits_history, get_organization_metrics, get_organization_timeseries,
-        get_platform_metrics, list_admin_access_tokens, list_models as admin_list_models,
-        list_organizations, list_users, update_organization_concurrent_limit,
-        update_organization_limits, update_service, AdminAppState,
+        get_platform_metrics, list_admin_access_tokens, list_invitation_email_deliveries,
+        list_models as admin_list_models, list_organizations, list_users, resend_invitation_email,
+        update_organization_concurrent_limit, update_organization_limits, update_service,
+        AdminAppState,
     };
     use database::repositories::{AdminAccessTokenRepository, AdminCompositeRepository};
     use services::admin::AdminServiceImpl;
@@ -1567,17 +1577,19 @@ pub fn build_admin_routes(
     // `/v1/admin/organizations/{org_id}/concurrent-limit`.
     let admin_service = Arc::new(AdminServiceImpl::new(
         admin_repository as Arc<dyn services::admin::AdminRepository>,
-        models_service as Arc<dyn services::models::ModelsServiceTrait>,
-        completion_service.clone() as Arc<dyn services::completions::CompletionServiceTrait>,
+        dependencies.models_service as Arc<dyn services::models::ModelsServiceTrait>,
+        dependencies.completion_service.clone()
+            as Arc<dyn services::completions::CompletionServiceTrait>,
     )) as Arc<dyn services::admin::AdminService + Send + Sync>;
 
     let admin_app_state = AdminAppState {
         admin_service,
-        analytics_service,
+        analytics_service: dependencies.analytics_service,
+        organization_service: dependencies.organization_service,
         auth_service: auth_state_middleware.auth_service.clone(),
         config,
         admin_access_token_repository,
-        inference_provider_pool,
+        inference_provider_pool: dependencies.inference_provider_pool,
     };
 
     Router::new()
@@ -1624,6 +1636,14 @@ pub fn build_admin_routes(
             "/admin/platform/metrics",
             axum::routing::get(get_platform_metrics),
         )
+        .route(
+            "/admin/invitation-email-deliveries",
+            axum::routing::get(list_invitation_email_deliveries),
+        )
+        .route(
+            "/admin/invitation-email-deliveries/{invitation_id}/resend",
+            axum::routing::post(resend_invitation_email),
+        )
         .route("/admin/users", axum::routing::get(list_users))
         .route(
             "/admin/organizations",

crates/api/src/models.rs

@@ -2561,6 +2561,50 @@ pub struct OrganizationInvitationWithOrgResponse {
     pub invited_by_display_name: Option<String>,
 }
 
+/// Admin view of invitation email delivery metadata.
+#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
+pub struct AdminInvitationEmailDeliveryResponse {
+    pub organization_id: String,
+    pub organization_name: String,
+    pub invitation_id: String,
+    pub recipient_email: String,
+    pub role: MemberRole,
+    pub invitation_status: InvitationStatus,
+    pub email_status: InvitationEmailStatus,
+    pub email_sent_at: Option<DateTime<Utc>>,
+    pub email_last_error: Option<String>,
+    pub email_message_id: Option<String>,
+    pub invited_by_user_id: String,
+    pub invited_by_email: Option<String>,
+    pub invited_by_display_name: Option<String>,
+    pub created_at: DateTime<Utc>,
+    pub expires_at: DateTime<Utc>,
+    pub responded_at: Option<DateTime<Utc>>,
+}
+
+/// Paginated admin invitation email delivery response.
+#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
+pub struct ListAdminInvitationEmailDeliveriesResponse {
+    pub deliveries: Vec<AdminInvitationEmailDeliveryResponse>,
+    pub total: i64,
+    pub limit: i64,
+    pub offset: i64,
+}
+
+/// Admin invitation email resend result.
+#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
+pub struct AdminInvitationEmailResendResultResponse {
+    pub invitation_id: String,
+    pub recipient_email: String,
+    pub success: bool,
+    pub email_sent: bool,
+    pub email_status: InvitationEmailStatus,
+    pub email_sent_at: Option<DateTime<Utc>>,
+    pub email_message_id: Option<String>,
+    pub email_last_error: Option<String>,
+    pub error: Option<String>,
+}
+
 /// Accept invitation response
 #[derive(Debug, Serialize, Deserialize, ToSchema)]
 pub struct AcceptInvitationResponse {

crates/api/src/openapi.rs

@@ -143,6 +143,8 @@ use utoipa::{Modify, OpenApi};
         crate::routes::admin::get_organization_metrics,
         crate::routes::admin::get_platform_metrics,
         crate::routes::admin::get_organization_timeseries,
+        crate::routes::admin::list_invitation_email_deliveries,
+        crate::routes::admin::resend_invitation_email,
         crate::routes::admin::list_users,
         crate::routes::admin::create_admin_access_token,
         crate::routes::admin::list_admin_access_tokens,
@@ -232,6 +234,9 @@ use utoipa::{Modify, OpenApi};
             // Organization concurrent limit models (Admin)
             UpdateOrganizationConcurrentLimitRequest, UpdateOrganizationConcurrentLimitResponse,
             GetOrganizationConcurrentLimitResponse,
+            // Invitation email delivery models (Admin)
+            AdminInvitationEmailDeliveryResponse, ListAdminInvitationEmailDeliveriesResponse,
+            AdminInvitationEmailResendResultResponse,
             // User models (Admin)
             ListUsersResponse, AdminUserResponse,
             // Admin access token models