Struct dropbox_sdk::sharing::LinkPermissions

pub struct LinkPermissions {
    pub can_revoke: bool,
    pub resolved_visibility: Option<ResolvedVisibility>,
    pub requested_visibility: Option<RequestedVisibility>,
    pub revoke_failure_reason: Option<SharedLinkAccessFailureReason>,
    pub effective_audience: Option<LinkAudience>,
    pub link_access_level: Option<LinkAccessLevel>,
}

This is supported on crate feature dbx_sharing only.

Fields

can_revoke: bool

Whether the caller can revoke the shared link.

resolved_visibility: Option<ResolvedVisibility>

The current visibility of the link after considering the shared links policies of the the team (in case the link's owner is part of a team) and the shared folder (in case the linked file is part of a shared folder). This field is shown only if the caller has access to this info (the link's owner always has access to this data). For some links, an effective_audience value is returned instead.

requested_visibility: Option<RequestedVisibility>

The shared link's requested visibility. This can be overridden by the team and shared folder policies. The final visibility, after considering these policies, can be found in resolved_visibility. This is shown only if the caller is the link's owner and resolved_visibility is returned instead of effective_audience.

revoke_failure_reason: Option<SharedLinkAccessFailureReason>

The failure reason for revoking the link. This field will only be present if the can_revoke is false.

effective_audience: Option<LinkAudience>

The type of audience who can benefit from the access level specified by the link_access_level field.

link_access_level: Option<LinkAccessLevel>

The access level that the link will grant to its users. A link can grant additional rights to a user beyond their current access level. For example, if a user was invited as a viewer to a file, and then opens a link with link_access_level set to editor, then they will gain editor privileges. The link_access_level is a property of the link, and does not depend on who is calling this API. In particular, link_access_level does not take into account the API caller's current permissions to the content.

Implementations

impl LinkPermissions

pub fn new(can_revoke: bool) -> Self

pub fn with_resolved_visibility(self, value: Option<ResolvedVisibility>) -> Self

pub fn with_requested_visibility(
    self,
    value: Option<RequestedVisibility>
) -> Self

pub fn with_revoke_failure_reason(
    self,
    value: Option<SharedLinkAccessFailureReason>
) -> Self

pub fn with_effective_audience(self, value: Option<LinkAudience>) -> Self

pub fn with_link_access_level(self, value: Option<LinkAccessLevel>) -> Self

Trait Implementations

impl Debug for LinkPermissions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LinkPermissions

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Serialize for LinkPermissions

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.