viewpoint_core/context/permissions/
mod.rs

1//! Permission management for BrowserContext.
2//!
3//! This module provides methods for granting and clearing browser permissions.
4
5use tracing::{debug, instrument};
6
7use viewpoint_cdp::protocol::browser::{GrantPermissionsParams, ResetPermissionsParams};
8
9use super::types::Permission;
10use super::BrowserContext;
11use crate::error::ContextError;
12
13impl BrowserContext {
14    /// Grant permissions to the browser context.
15    ///
16    /// # Example
17    ///
18    /// ```no_run
19    /// use viewpoint_core::{BrowserContext, context::Permission};
20    ///
21    /// # async fn example(context: &BrowserContext) -> Result<(), viewpoint_core::CoreError> {
22    /// context.grant_permissions(vec![
23    ///     Permission::Geolocation,
24    ///     Permission::Notifications,
25    /// ]).await?;
26    /// # Ok(())
27    /// # }
28    /// ```
29    ///
30    /// # Errors
31    ///
32    /// Returns an error if granting permissions fails.
33    #[instrument(level = "debug", skip(self, permissions))]
34    pub async fn grant_permissions(&self, permissions: Vec<Permission>) -> Result<(), ContextError> {
35        if self.is_closed() {
36            return Err(ContextError::Closed);
37        }
38
39        debug!(count = permissions.len(), "Granting permissions");
40
41        let cdp_permissions: Vec<_> = permissions
42            .into_iter()
43            .map(|p| p.to_cdp_permission())
44            .collect();
45
46        self.connection()
47            .send_command::<_, serde_json::Value>(
48                "Browser.grantPermissions",
49                Some(
50                    GrantPermissionsParams::new(cdp_permissions)
51                        .browser_context_id(self.context_id()),
52                ),
53                None,
54            )
55            .await?;
56
57        Ok(())
58    }
59
60    /// Grant permissions for a specific origin.
61    ///
62    /// # Errors
63    ///
64    /// Returns an error if granting permissions fails.
65    #[instrument(level = "debug", skip(self, permissions, origin))]
66    pub async fn grant_permissions_for_origin(
67        &self,
68        permissions: Vec<Permission>,
69        origin: impl Into<String>,
70    ) -> Result<(), ContextError> {
71        if self.is_closed() {
72            return Err(ContextError::Closed);
73        }
74
75        let origin = origin.into();
76        debug!(count = permissions.len(), origin = %origin, "Granting permissions for origin");
77
78        let cdp_permissions: Vec<_> = permissions
79            .into_iter()
80            .map(|p| p.to_cdp_permission())
81            .collect();
82
83        self.connection()
84            .send_command::<_, serde_json::Value>(
85                "Browser.grantPermissions",
86                Some(
87                    GrantPermissionsParams::new(cdp_permissions)
88                        .origin(origin)
89                        .browser_context_id(self.context_id()),
90                ),
91                None,
92            )
93            .await?;
94
95        Ok(())
96    }
97
98    /// Clear all granted permissions.
99    ///
100    /// # Errors
101    ///
102    /// Returns an error if clearing permissions fails.
103    #[instrument(level = "debug", skip(self))]
104    pub async fn clear_permissions(&self) -> Result<(), ContextError> {
105        if self.is_closed() {
106            return Err(ContextError::Closed);
107        }
108
109        self.connection()
110            .send_command::<_, serde_json::Value>(
111                "Browser.resetPermissions",
112                Some(ResetPermissionsParams::new().browser_context_id(self.context_id())),
113                None,
114            )
115            .await?;
116
117        Ok(())
118    }
119}