mirror of
https://github.com/OMGeeky/google-apis-rs.git
synced 2026-02-23 15:49:49 +01:00
1243 lines
66 KiB
Rust
1243 lines
66 KiB
Rust
use std::collections::HashMap;
|
||
use std::cell::RefCell;
|
||
use std::default::Default;
|
||
use std::collections::BTreeMap;
|
||
use std::error::Error as StdError;
|
||
use serde_json as json;
|
||
use std::io;
|
||
use std::fs;
|
||
use std::mem;
|
||
use std::thread::sleep;
|
||
|
||
use http::Uri;
|
||
use hyper::client::connect;
|
||
use tokio::io::{AsyncRead, AsyncWrite};
|
||
use tower_service;
|
||
use crate::client;
|
||
|
||
// ##############
|
||
// UTILITIES ###
|
||
// ############
|
||
|
||
|
||
|
||
|
||
// ########
|
||
// HUB ###
|
||
// ######
|
||
|
||
/// Central instance to access all Digitalassetlinks related resource activities
|
||
///
|
||
/// # Examples
|
||
///
|
||
/// Instantiate a new hub
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// extern crate hyper;
|
||
/// extern crate hyper_rustls;
|
||
/// extern crate google_digitalassetlinks1 as digitalassetlinks1;
|
||
/// use digitalassetlinks1::api::BulkCheckRequest;
|
||
/// use digitalassetlinks1::{Result, Error};
|
||
/// # async fn dox() {
|
||
/// use std::default::Default;
|
||
/// use digitalassetlinks1::{Digitalassetlinks, oauth2, hyper, hyper_rustls};
|
||
///
|
||
/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and
|
||
/// // `client_secret`, among other things.
|
||
/// let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// // Instantiate the authenticator. It will choose a suitable authentication flow for you,
|
||
/// // unless you replace `None` with the desired Flow.
|
||
/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about
|
||
/// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and
|
||
/// // retrieve them from storage.
|
||
/// let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// secret,
|
||
/// oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// ).build().await.unwrap();
|
||
/// let mut hub = Digitalassetlinks::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().enable_http2().build()), auth);
|
||
/// // As the method needs a request, you would usually fill it with the desired information
|
||
/// // into the respective structure. Some of the parts shown here might not be applicable !
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let mut req = BulkCheckRequest::default();
|
||
///
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.assetlinks().bulk_check(req)
|
||
/// .doit().await;
|
||
///
|
||
/// match result {
|
||
/// Err(e) => match e {
|
||
/// // The Error enum provides details about what exactly happened.
|
||
/// // You can also just use its `Debug`, `Display` or `Error` traits
|
||
/// Error::HttpError(_)
|
||
/// |Error::Io(_)
|
||
/// |Error::MissingAPIKey
|
||
/// |Error::MissingToken(_)
|
||
/// |Error::Cancelled
|
||
/// |Error::UploadSizeLimitExceeded(_, _)
|
||
/// |Error::Failure(_)
|
||
/// |Error::BadRequest(_)
|
||
/// |Error::FieldClash(_)
|
||
/// |Error::JsonDecodeError(_, _) => println!("{}", e),
|
||
/// },
|
||
/// Ok(res) => println!("Success: {:?}", res),
|
||
/// }
|
||
/// # }
|
||
/// ```
|
||
#[derive(Clone)]
|
||
pub struct Digitalassetlinks<S> {
|
||
pub client: hyper::Client<S, hyper::body::Body>,
|
||
pub auth: oauth2::authenticator::Authenticator<S>,
|
||
_user_agent: String,
|
||
_base_url: String,
|
||
_root_url: String,
|
||
}
|
||
|
||
impl<'a, S> client::Hub for Digitalassetlinks<S> {}
|
||
|
||
impl<'a, S> Digitalassetlinks<S> {
|
||
|
||
pub fn new(client: hyper::Client<S, hyper::body::Body>, authenticator: oauth2::authenticator::Authenticator<S>) -> Digitalassetlinks<S> {
|
||
Digitalassetlinks {
|
||
client,
|
||
auth: authenticator,
|
||
_user_agent: "google-api-rust-client/4.0.1".to_string(),
|
||
_base_url: "https://digitalassetlinks.googleapis.com/".to_string(),
|
||
_root_url: "https://digitalassetlinks.googleapis.com/".to_string(),
|
||
}
|
||
}
|
||
|
||
pub fn assetlinks(&'a self) -> AssetlinkMethods<'a, S> {
|
||
AssetlinkMethods { hub: &self }
|
||
}
|
||
pub fn statements(&'a self) -> StatementMethods<'a, S> {
|
||
StatementMethods { hub: &self }
|
||
}
|
||
|
||
/// Set the user-agent header field to use in all requests to the server.
|
||
/// It defaults to `google-api-rust-client/4.0.1`.
|
||
///
|
||
/// Returns the previously set user-agent.
|
||
pub fn user_agent(&mut self, agent_name: String) -> String {
|
||
mem::replace(&mut self._user_agent, agent_name)
|
||
}
|
||
|
||
/// Set the base url to use in all requests to the server.
|
||
/// It defaults to `https://digitalassetlinks.googleapis.com/`.
|
||
///
|
||
/// Returns the previously set base url.
|
||
pub fn base_url(&mut self, new_base_url: String) -> String {
|
||
mem::replace(&mut self._base_url, new_base_url)
|
||
}
|
||
|
||
/// Set the root url to use in all requests to the server.
|
||
/// It defaults to `https://digitalassetlinks.googleapis.com/`.
|
||
///
|
||
/// Returns the previously set root url.
|
||
pub fn root_url(&mut self, new_root_url: String) -> String {
|
||
mem::replace(&mut self._root_url, new_root_url)
|
||
}
|
||
}
|
||
|
||
|
||
// ############
|
||
// SCHEMAS ###
|
||
// ##########
|
||
/// Describes an android app asset.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct AndroidAppAsset {
|
||
/// Because there is no global enforcement of package name uniqueness, we also require a signing certificate, which in combination with the package name uniquely identifies an app. Some apps' signing keys are rotated, so they may be signed by different keys over time. We treat these as distinct assets, since we use (package name, cert) as the unique ID. This should not normally pose any problems as both versions of the app will make the same or similar statements. Other assets making statements about the app will have to be updated when a key is rotated, however. (Note that the syntaxes for publishing and querying for statements contain syntactic sugar to easily let you specify apps that are known by multiple certificates.) REQUIRED
|
||
pub certificate: Option<CertificateInfo>,
|
||
/// Android App assets are naturally identified by their Java package name. For example, the Google Maps app uses the package name `com.google.android.apps.maps`. REQUIRED
|
||
#[serde(rename="packageName")]
|
||
pub package_name: Option<String>,
|
||
}
|
||
|
||
impl client::Part for AndroidAppAsset {}
|
||
|
||
|
||
/// Uniquely identifies an asset. A digital asset is an identifiable and addressable online entity that typically provides some service or content. Examples of assets are websites, Android apps, Twitter feeds, and Plus Pages.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Asset {
|
||
/// Set if this is an Android App asset.
|
||
#[serde(rename="androidApp")]
|
||
pub android_app: Option<AndroidAppAsset>,
|
||
/// Set if this is a web asset.
|
||
pub web: Option<WebAsset>,
|
||
}
|
||
|
||
impl client::Part for Asset {}
|
||
|
||
|
||
/// Message used to check for the existence of multiple digital asset links within a single RPC.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [bulk check assetlinks](AssetlinkBulkCheckCall) (request)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct BulkCheckRequest {
|
||
/// Same configuration as in Check request, all statements checks will use same configurations.
|
||
#[serde(rename="allowGoogleInternalDataSources")]
|
||
pub allow_google_internal_data_sources: Option<bool>,
|
||
/// If specified, will be used in any given template statement that doesn’t specify a relation.
|
||
#[serde(rename="defaultRelation")]
|
||
pub default_relation: Option<String>,
|
||
/// If specified, will be used in any given template statement that doesn’t specify a source.
|
||
#[serde(rename="defaultSource")]
|
||
pub default_source: Option<Asset>,
|
||
/// If specified, will be used in any given template statement that doesn’t specify a target.
|
||
#[serde(rename="defaultTarget")]
|
||
pub default_target: Option<Asset>,
|
||
/// Same configuration as in Check request, all statements checks will use same configurations.
|
||
#[serde(rename="skipCacheLookup")]
|
||
pub skip_cache_lookup: Option<bool>,
|
||
/// List of statements to check. For each statement, you can omit a field if the corresponding default_* field below was supplied. Minimum 1 statement; maximum 1,000 statements. Any additional statements will be ignored.
|
||
pub statements: Option<Vec<StatementTemplate>>,
|
||
}
|
||
|
||
impl client::RequestValue for BulkCheckRequest {}
|
||
|
||
|
||
/// Response for BulkCheck call. Results are sent in a list in the same order in which they were sent. Individual check errors are described in the appropriate check_results entry. If the entire call fails, the response will include a bulk_error_code field describing the error.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [bulk check assetlinks](AssetlinkBulkCheckCall) (response)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct BulkCheckResponse {
|
||
/// Error code for the entire request. Present only if the entire request failed. Individual check errors will not trigger the presence of this field.
|
||
#[serde(rename="bulkErrorCode")]
|
||
pub bulk_error_code: Option<String>,
|
||
/// List of results for each check request. Results are returned in the same order in which they were sent in the request.
|
||
#[serde(rename="checkResults")]
|
||
pub check_results: Option<Vec<CheckResponse>>,
|
||
}
|
||
|
||
impl client::ResponseResult for BulkCheckResponse {}
|
||
|
||
|
||
/// Describes an X509 certificate.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct CertificateInfo {
|
||
/// The uppercase SHA-265 fingerprint of the certificate. From the PEM certificate, it can be acquired like this: $ keytool -printcert -file $CERTFILE | grep SHA256: SHA256: 14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83: \ 42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 or like this: $ openssl x509 -in $CERTFILE -noout -fingerprint -sha256 SHA256 Fingerprint=14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64: \ 16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 In this example, the contents of this field would be `14:6D:E9:83:C5:73: 06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF: 44:E5`. If these tools are not available to you, you can convert the PEM certificate into the DER format, compute the SHA-256 hash of that string and represent the result as a hexstring (that is, uppercase hexadecimal representations of each octet, separated by colons).
|
||
#[serde(rename="sha256Fingerprint")]
|
||
pub sha256_fingerprint: Option<String>,
|
||
}
|
||
|
||
impl client::Part for CertificateInfo {}
|
||
|
||
|
||
/// Response message for the CheckAssetLinks call.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [check assetlinks](AssetlinkCheckCall) (response)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct CheckResponse {
|
||
/// Human-readable message containing information intended to help end users understand, reproduce and debug the result. The message will be in English and we are currently not planning to offer any translations. Please note that no guarantees are made about the contents or format of this string. Any aspect of it may be subject to change without notice. You should not attempt to programmatically parse this data. For programmatic access, use the error_code field below.
|
||
#[serde(rename="debugString")]
|
||
pub debug_string: Option<String>,
|
||
/// Error codes that describe the result of the Check operation.
|
||
#[serde(rename="errorCode")]
|
||
pub error_code: Option<Vec<String>>,
|
||
/// Set to true if the assets specified in the request are linked by the relation specified in the request.
|
||
pub linked: Option<bool>,
|
||
/// From serving time, how much longer the response should be considered valid barring further updates. REQUIRED
|
||
#[serde(rename="maxAge")]
|
||
pub max_age: Option<String>,
|
||
}
|
||
|
||
impl client::ResponseResult for CheckResponse {}
|
||
|
||
|
||
/// Response message for the List call.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [list statements](StatementListCall) (response)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct ListResponse {
|
||
/// Human-readable message containing information intended to help end users understand, reproduce and debug the result. The message will be in English and we are currently not planning to offer any translations. Please note that no guarantees are made about the contents or format of this string. Any aspect of it may be subject to change without notice. You should not attempt to programmatically parse this data. For programmatic access, use the error_code field below.
|
||
#[serde(rename="debugString")]
|
||
pub debug_string: Option<String>,
|
||
/// Error codes that describe the result of the List operation.
|
||
#[serde(rename="errorCode")]
|
||
pub error_code: Option<Vec<String>>,
|
||
/// From serving time, how much longer the response should be considered valid barring further updates. REQUIRED
|
||
#[serde(rename="maxAge")]
|
||
pub max_age: Option<String>,
|
||
/// A list of all the matching statements that have been found.
|
||
pub statements: Option<Vec<Statement>>,
|
||
}
|
||
|
||
impl client::ResponseResult for ListResponse {}
|
||
|
||
|
||
/// Describes a reliable statement that has been made about the relationship between a source asset and a target asset. Statements are always made by the source asset, either directly or by delegating to a statement list that is stored elsewhere. For more detailed definitions of statements and assets, please refer to our [API documentation landing page](/digital-asset-links/v1/getting-started).
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [list statements](StatementListCall) (none)
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Statement {
|
||
/// The relation identifies the use of the statement as intended by the source asset's owner (that is, the person or entity who issued the statement). Every complete statement has a relation. We identify relations with strings of the format `/`, where `` must be one of a set of pre-defined purpose categories, and `` is a free-form lowercase alphanumeric string that describes the specific use case of the statement. Refer to [our API documentation](/digital-asset-links/v1/relation-strings) for the current list of supported relations. Example: `delegate_permission/common.handle_all_urls` REQUIRED
|
||
pub relation: Option<String>,
|
||
/// Every statement has a source asset. REQUIRED
|
||
pub source: Option<Asset>,
|
||
/// Every statement has a target asset. REQUIRED
|
||
pub target: Option<Asset>,
|
||
}
|
||
|
||
impl client::Resource for Statement {}
|
||
|
||
|
||
/// A single statement to check in a bulk call using BulkCheck. See CheckRequest for details about each field.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct StatementTemplate {
|
||
/// The relationship being asserted between the source and target. If omitted, you must specify a BulkCheckRequest.default_relation value to use here.
|
||
pub relation: Option<String>,
|
||
/// The source asset that is asserting the statement. If omitted, you must specify a BulkCheckRequest.default_source value to use here.
|
||
pub source: Option<Asset>,
|
||
/// The target that the source is declaring the relationship with. If omitted, you must specify a BulkCheckRequest.default_target to use here.
|
||
pub target: Option<Asset>,
|
||
}
|
||
|
||
impl client::Part for StatementTemplate {}
|
||
|
||
|
||
/// Describes a web asset.
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct WebAsset {
|
||
/// Web assets are identified by a URL that contains only the scheme, hostname and port parts. The format is http[s]://[:] Hostnames must be fully qualified: they must end in a single period ("`.`"). Only the schemes "http" and "https" are currently allowed. Port numbers are given as a decimal number, and they must be omitted if the standard port numbers are used: 80 for http and 443 for https. We call this limited URL the "site". All URLs that share the same scheme, hostname and port are considered to be a part of the site and thus belong to the web asset. Example: the asset with the site `https://www.google.com` contains all these URLs: * `https://www.google.com/` * `https://www.google.com:443/` * `https://www.google.com/foo` * `https://www.google.com/foo?bar` * `https://www.google.com/foo#bar` * `https://user@password:www.google.com/` But it does not contain these URLs: * `http://www.google.com/` (wrong scheme) * `https://google.com/` (hostname does not match) * `https://www.google.com:444/` (port does not match) REQUIRED
|
||
pub site: Option<String>,
|
||
}
|
||
|
||
impl client::Part for WebAsset {}
|
||
|
||
|
||
|
||
// ###################
|
||
// MethodBuilders ###
|
||
// #################
|
||
|
||
/// A builder providing access to all methods supported on *assetlink* resources.
|
||
/// It is not used directly, but through the `Digitalassetlinks` hub.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// extern crate hyper;
|
||
/// extern crate hyper_rustls;
|
||
/// extern crate google_digitalassetlinks1 as digitalassetlinks1;
|
||
///
|
||
/// # async fn dox() {
|
||
/// use std::default::Default;
|
||
/// use digitalassetlinks1::{Digitalassetlinks, oauth2, hyper, hyper_rustls};
|
||
///
|
||
/// let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// secret,
|
||
/// oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// ).build().await.unwrap();
|
||
/// let mut hub = Digitalassetlinks::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().enable_http2().build()), auth);
|
||
/// // Usually you wouldn't bind this to a variable, but keep calling *CallBuilders*
|
||
/// // like `bulk_check(...)` and `check(...)`
|
||
/// // to build up your call.
|
||
/// let rb = hub.assetlinks();
|
||
/// # }
|
||
/// ```
|
||
pub struct AssetlinkMethods<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Digitalassetlinks<S>,
|
||
}
|
||
|
||
impl<'a, S> client::MethodsBuilder for AssetlinkMethods<'a, S> {}
|
||
|
||
impl<'a, S> AssetlinkMethods<'a, S> {
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Send a bundle of statement checks in a single RPC to minimize latency and service load. Statements need not be all for the same source and/or target. We recommend using this method when you need to check more than one statement in a short period of time.
|
||
///
|
||
/// # Arguments
|
||
///
|
||
/// * `request` - No description provided.
|
||
pub fn bulk_check(&self, request: BulkCheckRequest) -> AssetlinkBulkCheckCall<'a, S> {
|
||
AssetlinkBulkCheckCall {
|
||
hub: self.hub,
|
||
_request: request,
|
||
_delegate: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Determines whether the specified (directional) relationship exists between the specified source and target assets. The relation describes the intent of the link between the two assets as claimed by the source asset. An example for such relationships is the delegation of privileges or permissions. This command is most often used by infrastructure systems to check preconditions for an action. For example, a client may want to know if it is OK to send a web URL to a particular mobile app instead. The client can check for the relevant asset link from the website to the mobile app to decide if the operation should be allowed. A note about security: if you specify a secure asset as the source, such as an HTTPS website or an Android app, the API will ensure that any statements used to generate the response have been made in a secure way by the owner of that asset. Conversely, if the source asset is an insecure HTTP website (that is, the URL starts with `http://` instead of `https://`), the API cannot verify its statements securely, and it is not possible to ensure that the website's statements have not been altered by a third party. For more information, see the [Digital Asset Links technical design specification](https://github.com/google/digitalassetlinks/blob/master/well-known/details.md).
|
||
pub fn check(&self) -> AssetlinkCheckCall<'a, S> {
|
||
AssetlinkCheckCall {
|
||
hub: self.hub,
|
||
_target_web_site: Default::default(),
|
||
_target_android_app_package_name: Default::default(),
|
||
_target_android_app_certificate_sha256_fingerprint: Default::default(),
|
||
_source_web_site: Default::default(),
|
||
_source_android_app_package_name: Default::default(),
|
||
_source_android_app_certificate_sha256_fingerprint: Default::default(),
|
||
_relation: Default::default(),
|
||
_delegate: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/// A builder providing access to all methods supported on *statement* resources.
|
||
/// It is not used directly, but through the `Digitalassetlinks` hub.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// extern crate hyper;
|
||
/// extern crate hyper_rustls;
|
||
/// extern crate google_digitalassetlinks1 as digitalassetlinks1;
|
||
///
|
||
/// # async fn dox() {
|
||
/// use std::default::Default;
|
||
/// use digitalassetlinks1::{Digitalassetlinks, oauth2, hyper, hyper_rustls};
|
||
///
|
||
/// let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// secret,
|
||
/// oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// ).build().await.unwrap();
|
||
/// let mut hub = Digitalassetlinks::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().enable_http2().build()), auth);
|
||
/// // Usually you wouldn't bind this to a variable, but keep calling *CallBuilders*
|
||
/// // like `list(...)`
|
||
/// // to build up your call.
|
||
/// let rb = hub.statements();
|
||
/// # }
|
||
/// ```
|
||
pub struct StatementMethods<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Digitalassetlinks<S>,
|
||
}
|
||
|
||
impl<'a, S> client::MethodsBuilder for StatementMethods<'a, S> {}
|
||
|
||
impl<'a, S> StatementMethods<'a, S> {
|
||
|
||
/// Create a builder to help you perform the following task:
|
||
///
|
||
/// Retrieves a list of all statements from a given source that match the specified target and statement string. The API guarantees that all statements with secure source assets, such as HTTPS websites or Android apps, have been made in a secure way by the owner of those assets, as described in the [Digital Asset Links technical design specification](https://github.com/google/digitalassetlinks/blob/master/well-known/details.md). Specifically, you should consider that for insecure websites (that is, where the URL starts with `http://` instead of `https://`), this guarantee cannot be made. The `List` command is most useful in cases where the API client wants to know all the ways in which two assets are related, or enumerate all the relationships from a particular source asset. Example: a feature that helps users navigate to related items. When a mobile app is running on a device, the feature would make it easy to navigate to the corresponding web site or Google+ profile.
|
||
pub fn list(&self) -> StatementListCall<'a, S> {
|
||
StatementListCall {
|
||
hub: self.hub,
|
||
_source_web_site: Default::default(),
|
||
_source_android_app_package_name: Default::default(),
|
||
_source_android_app_certificate_sha256_fingerprint: Default::default(),
|
||
_relation: Default::default(),
|
||
_delegate: Default::default(),
|
||
_additional_params: Default::default(),
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
// ###################
|
||
// CallBuilders ###
|
||
// #################
|
||
|
||
/// Send a bundle of statement checks in a single RPC to minimize latency and service load. Statements need not be all for the same source and/or target. We recommend using this method when you need to check more than one statement in a short period of time.
|
||
///
|
||
/// A builder for the *bulkCheck* method supported by a *assetlink* resource.
|
||
/// It is not used directly, but through a `AssetlinkMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate hyper_rustls;
|
||
/// # extern crate google_digitalassetlinks1 as digitalassetlinks1;
|
||
/// use digitalassetlinks1::api::BulkCheckRequest;
|
||
/// # async fn dox() {
|
||
/// # use std::default::Default;
|
||
/// # use digitalassetlinks1::{Digitalassetlinks, oauth2, hyper, hyper_rustls};
|
||
///
|
||
/// # let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// # let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// # secret,
|
||
/// # oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// # ).build().await.unwrap();
|
||
/// # let mut hub = Digitalassetlinks::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().enable_http2().build()), auth);
|
||
/// // As the method needs a request, you would usually fill it with the desired information
|
||
/// // into the respective structure. Some of the parts shown here might not be applicable !
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let mut req = BulkCheckRequest::default();
|
||
///
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.assetlinks().bulk_check(req)
|
||
/// .doit().await;
|
||
/// # }
|
||
/// ```
|
||
pub struct AssetlinkBulkCheckCall<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Digitalassetlinks<S>,
|
||
_request: BulkCheckRequest,
|
||
_delegate: Option<&'a mut dyn client::Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
}
|
||
|
||
impl<'a, S> client::CallBuilder for AssetlinkBulkCheckCall<'a, S> {}
|
||
|
||
impl<'a, S> AssetlinkBulkCheckCall<'a, S>
|
||
where
|
||
S: tower_service::Service<Uri> + Clone + Send + Sync + 'static,
|
||
S::Response: hyper::client::connect::Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
|
||
S::Future: Send + Unpin + 'static,
|
||
S::Error: Into<Box<dyn StdError + Send + Sync>>,
|
||
{
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub async fn doit(mut self) -> client::Result<(hyper::Response<hyper::body::Body>, BulkCheckResponse)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
|
||
use client::ToParts;
|
||
let mut dd = client::DefaultDelegate;
|
||
let mut dlg: &mut dyn client::Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(client::MethodInfo { id: "digitalassetlinks.assetlinks.bulkCheck",
|
||
http_method: hyper::Method::POST });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity(3 + self._additional_params.len());
|
||
for &field in ["alt"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(client::Error::FieldClash(field));
|
||
}
|
||
}
|
||
for (name, value) in self._additional_params.iter() {
|
||
params.push((&name, value.clone()));
|
||
}
|
||
|
||
params.push(("alt", "json".to_string()));
|
||
|
||
let mut url = self.hub._base_url.clone() + "v1/assetlinks:bulkCheck";
|
||
|
||
let key = dlg.api_key();
|
||
match key {
|
||
Some(value) => params.push(("key", value)),
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(client::Error::MissingAPIKey)
|
||
}
|
||
}
|
||
|
||
|
||
let url = url::Url::parse_with_params(&url, params).unwrap();
|
||
|
||
let mut json_mime_type: mime::Mime = "application/json".parse().unwrap();
|
||
let mut request_value_reader =
|
||
{
|
||
let mut value = json::value::to_value(&self._request).expect("serde to work");
|
||
client::remove_json_null_values(&mut value);
|
||
let mut dst = io::Cursor::new(Vec::with_capacity(128));
|
||
json::to_writer(&mut dst, &value).unwrap();
|
||
dst
|
||
};
|
||
let request_size = request_value_reader.seek(io::SeekFrom::End(0)).unwrap();
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
|
||
|
||
loop {
|
||
request_value_reader.seek(io::SeekFrom::Start(0)).unwrap();
|
||
let mut req_result = {
|
||
let client = &self.hub.client;
|
||
dlg.pre_request();
|
||
let mut req_builder = hyper::Request::builder().method(hyper::Method::POST).uri(url.clone().into_string())
|
||
.header(USER_AGENT, self.hub._user_agent.clone());
|
||
|
||
|
||
let request = req_builder
|
||
.header(CONTENT_TYPE, format!("{}", json_mime_type.to_string()))
|
||
.header(CONTENT_LENGTH, request_size as u64)
|
||
.body(hyper::body::Body::from(request_value_reader.get_ref().clone()));
|
||
|
||
client.request(request.unwrap()).await
|
||
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let client::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(client::Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status().is_success() {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
let (parts, _) = res.into_parts();
|
||
let body = hyper::Body::from(res_body_string.clone());
|
||
let restored_response = hyper::Response::from_parts(parts, body);
|
||
|
||
let server_response = json::from_str::<serde_json::Value>(&res_body_string).ok();
|
||
|
||
if let client::Retry::After(d) = dlg.http_failure(&restored_response, server_response.clone()) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
|
||
dlg.finished(false);
|
||
|
||
return match server_response {
|
||
Some(error_value) => Err(client::Error::BadRequest(error_value)),
|
||
None => Err(client::Error::Failure(restored_response)),
|
||
}
|
||
}
|
||
let result_value = {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
|
||
match json::from_str(&res_body_string) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&res_body_string, &err);
|
||
return Err(client::Error::JsonDecodeError(res_body_string, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
///
|
||
/// Sets the *request* property to the given value.
|
||
///
|
||
/// Even though the property as already been set when instantiating this call,
|
||
/// we provide this method for API completeness.
|
||
pub fn request(mut self, new_value: BulkCheckRequest) -> AssetlinkBulkCheckCall<'a, S> {
|
||
self._request = new_value;
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> AssetlinkBulkCheckCall<'a, S> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known parameters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
pub fn param<T>(mut self, name: T, value: T) -> AssetlinkBulkCheckCall<'a, S>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
}
|
||
|
||
|
||
/// Determines whether the specified (directional) relationship exists between the specified source and target assets. The relation describes the intent of the link between the two assets as claimed by the source asset. An example for such relationships is the delegation of privileges or permissions. This command is most often used by infrastructure systems to check preconditions for an action. For example, a client may want to know if it is OK to send a web URL to a particular mobile app instead. The client can check for the relevant asset link from the website to the mobile app to decide if the operation should be allowed. A note about security: if you specify a secure asset as the source, such as an HTTPS website or an Android app, the API will ensure that any statements used to generate the response have been made in a secure way by the owner of that asset. Conversely, if the source asset is an insecure HTTP website (that is, the URL starts with `http://` instead of `https://`), the API cannot verify its statements securely, and it is not possible to ensure that the website's statements have not been altered by a third party. For more information, see the [Digital Asset Links technical design specification](https://github.com/google/digitalassetlinks/blob/master/well-known/details.md).
|
||
///
|
||
/// A builder for the *check* method supported by a *assetlink* resource.
|
||
/// It is not used directly, but through a `AssetlinkMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate hyper_rustls;
|
||
/// # extern crate google_digitalassetlinks1 as digitalassetlinks1;
|
||
/// # async fn dox() {
|
||
/// # use std::default::Default;
|
||
/// # use digitalassetlinks1::{Digitalassetlinks, oauth2, hyper, hyper_rustls};
|
||
///
|
||
/// # let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// # let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// # secret,
|
||
/// # oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// # ).build().await.unwrap();
|
||
/// # let mut hub = Digitalassetlinks::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().enable_http2().build()), auth);
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.assetlinks().check()
|
||
/// .target_web_site("et")
|
||
/// .target_android_app_package_name("magna")
|
||
/// .target_android_app_certificate_sha256_fingerprint("no")
|
||
/// .source_web_site("ipsum")
|
||
/// .source_android_app_package_name("voluptua.")
|
||
/// .source_android_app_certificate_sha256_fingerprint("At")
|
||
/// .relation("sanctus")
|
||
/// .doit().await;
|
||
/// # }
|
||
/// ```
|
||
pub struct AssetlinkCheckCall<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Digitalassetlinks<S>,
|
||
_target_web_site: Option<String>,
|
||
_target_android_app_package_name: Option<String>,
|
||
_target_android_app_certificate_sha256_fingerprint: Option<String>,
|
||
_source_web_site: Option<String>,
|
||
_source_android_app_package_name: Option<String>,
|
||
_source_android_app_certificate_sha256_fingerprint: Option<String>,
|
||
_relation: Option<String>,
|
||
_delegate: Option<&'a mut dyn client::Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
}
|
||
|
||
impl<'a, S> client::CallBuilder for AssetlinkCheckCall<'a, S> {}
|
||
|
||
impl<'a, S> AssetlinkCheckCall<'a, S>
|
||
where
|
||
S: tower_service::Service<Uri> + Clone + Send + Sync + 'static,
|
||
S::Response: hyper::client::connect::Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
|
||
S::Future: Send + Unpin + 'static,
|
||
S::Error: Into<Box<dyn StdError + Send + Sync>>,
|
||
{
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub async fn doit(mut self) -> client::Result<(hyper::Response<hyper::body::Body>, CheckResponse)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
|
||
use client::ToParts;
|
||
let mut dd = client::DefaultDelegate;
|
||
let mut dlg: &mut dyn client::Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(client::MethodInfo { id: "digitalassetlinks.assetlinks.check",
|
||
http_method: hyper::Method::GET });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity(9 + self._additional_params.len());
|
||
if let Some(value) = self._target_web_site {
|
||
params.push(("target.web.site", value.to_string()));
|
||
}
|
||
if let Some(value) = self._target_android_app_package_name {
|
||
params.push(("target.androidApp.packageName", value.to_string()));
|
||
}
|
||
if let Some(value) = self._target_android_app_certificate_sha256_fingerprint {
|
||
params.push(("target.androidApp.certificate.sha256Fingerprint", value.to_string()));
|
||
}
|
||
if let Some(value) = self._source_web_site {
|
||
params.push(("source.web.site", value.to_string()));
|
||
}
|
||
if let Some(value) = self._source_android_app_package_name {
|
||
params.push(("source.androidApp.packageName", value.to_string()));
|
||
}
|
||
if let Some(value) = self._source_android_app_certificate_sha256_fingerprint {
|
||
params.push(("source.androidApp.certificate.sha256Fingerprint", value.to_string()));
|
||
}
|
||
if let Some(value) = self._relation {
|
||
params.push(("relation", value.to_string()));
|
||
}
|
||
for &field in ["alt", "target.web.site", "target.androidApp.packageName", "target.androidApp.certificate.sha256Fingerprint", "source.web.site", "source.androidApp.packageName", "source.androidApp.certificate.sha256Fingerprint", "relation"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(client::Error::FieldClash(field));
|
||
}
|
||
}
|
||
for (name, value) in self._additional_params.iter() {
|
||
params.push((&name, value.clone()));
|
||
}
|
||
|
||
params.push(("alt", "json".to_string()));
|
||
|
||
let mut url = self.hub._base_url.clone() + "v1/assetlinks:check";
|
||
|
||
let key = dlg.api_key();
|
||
match key {
|
||
Some(value) => params.push(("key", value)),
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(client::Error::MissingAPIKey)
|
||
}
|
||
}
|
||
|
||
|
||
let url = url::Url::parse_with_params(&url, params).unwrap();
|
||
|
||
|
||
|
||
loop {
|
||
let mut req_result = {
|
||
let client = &self.hub.client;
|
||
dlg.pre_request();
|
||
let mut req_builder = hyper::Request::builder().method(hyper::Method::GET).uri(url.clone().into_string())
|
||
.header(USER_AGENT, self.hub._user_agent.clone());
|
||
|
||
|
||
let request = req_builder
|
||
.body(hyper::body::Body::empty());
|
||
|
||
client.request(request.unwrap()).await
|
||
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let client::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(client::Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status().is_success() {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
let (parts, _) = res.into_parts();
|
||
let body = hyper::Body::from(res_body_string.clone());
|
||
let restored_response = hyper::Response::from_parts(parts, body);
|
||
|
||
let server_response = json::from_str::<serde_json::Value>(&res_body_string).ok();
|
||
|
||
if let client::Retry::After(d) = dlg.http_failure(&restored_response, server_response.clone()) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
|
||
dlg.finished(false);
|
||
|
||
return match server_response {
|
||
Some(error_value) => Err(client::Error::BadRequest(error_value)),
|
||
None => Err(client::Error::Failure(restored_response)),
|
||
}
|
||
}
|
||
let result_value = {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
|
||
match json::from_str(&res_body_string) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&res_body_string, &err);
|
||
return Err(client::Error::JsonDecodeError(res_body_string, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// Web assets are identified by a URL that contains only the scheme, hostname and port parts. The format is http[s]://[:] Hostnames must be fully qualified: they must end in a single period ("`.`"). Only the schemes "http" and "https" are currently allowed. Port numbers are given as a decimal number, and they must be omitted if the standard port numbers are used: 80 for http and 443 for https. We call this limited URL the "site". All URLs that share the same scheme, hostname and port are considered to be a part of the site and thus belong to the web asset. Example: the asset with the site `https://www.google.com` contains all these URLs: * `https://www.google.com/` * `https://www.google.com:443/` * `https://www.google.com/foo` * `https://www.google.com/foo?bar` * `https://www.google.com/foo#bar` * `https://user@password:www.google.com/` But it does not contain these URLs: * `http://www.google.com/` (wrong scheme) * `https://google.com/` (hostname does not match) * `https://www.google.com:444/` (port does not match) REQUIRED
|
||
///
|
||
/// Sets the *target.web.site* query property to the given value.
|
||
pub fn target_web_site(mut self, new_value: &str) -> AssetlinkCheckCall<'a, S> {
|
||
self._target_web_site = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// Android App assets are naturally identified by their Java package name. For example, the Google Maps app uses the package name `com.google.android.apps.maps`. REQUIRED
|
||
///
|
||
/// Sets the *target.android app.package name* query property to the given value.
|
||
pub fn target_android_app_package_name(mut self, new_value: &str) -> AssetlinkCheckCall<'a, S> {
|
||
self._target_android_app_package_name = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The uppercase SHA-265 fingerprint of the certificate. From the PEM certificate, it can be acquired like this: $ keytool -printcert -file $CERTFILE | grep SHA256: SHA256: 14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83: \ 42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 or like this: $ openssl x509 -in $CERTFILE -noout -fingerprint -sha256 SHA256 Fingerprint=14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64: \ 16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 In this example, the contents of this field would be `14:6D:E9:83:C5:73: 06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF: 44:E5`. If these tools are not available to you, you can convert the PEM certificate into the DER format, compute the SHA-256 hash of that string and represent the result as a hexstring (that is, uppercase hexadecimal representations of each octet, separated by colons).
|
||
///
|
||
/// Sets the *target.android app.certificate.sha256 fingerprint* query property to the given value.
|
||
pub fn target_android_app_certificate_sha256_fingerprint(mut self, new_value: &str) -> AssetlinkCheckCall<'a, S> {
|
||
self._target_android_app_certificate_sha256_fingerprint = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// Web assets are identified by a URL that contains only the scheme, hostname and port parts. The format is http[s]://[:] Hostnames must be fully qualified: they must end in a single period ("`.`"). Only the schemes "http" and "https" are currently allowed. Port numbers are given as a decimal number, and they must be omitted if the standard port numbers are used: 80 for http and 443 for https. We call this limited URL the "site". All URLs that share the same scheme, hostname and port are considered to be a part of the site and thus belong to the web asset. Example: the asset with the site `https://www.google.com` contains all these URLs: * `https://www.google.com/` * `https://www.google.com:443/` * `https://www.google.com/foo` * `https://www.google.com/foo?bar` * `https://www.google.com/foo#bar` * `https://user@password:www.google.com/` But it does not contain these URLs: * `http://www.google.com/` (wrong scheme) * `https://google.com/` (hostname does not match) * `https://www.google.com:444/` (port does not match) REQUIRED
|
||
///
|
||
/// Sets the *source.web.site* query property to the given value.
|
||
pub fn source_web_site(mut self, new_value: &str) -> AssetlinkCheckCall<'a, S> {
|
||
self._source_web_site = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// Android App assets are naturally identified by their Java package name. For example, the Google Maps app uses the package name `com.google.android.apps.maps`. REQUIRED
|
||
///
|
||
/// Sets the *source.android app.package name* query property to the given value.
|
||
pub fn source_android_app_package_name(mut self, new_value: &str) -> AssetlinkCheckCall<'a, S> {
|
||
self._source_android_app_package_name = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The uppercase SHA-265 fingerprint of the certificate. From the PEM certificate, it can be acquired like this: $ keytool -printcert -file $CERTFILE | grep SHA256: SHA256: 14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83: \ 42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 or like this: $ openssl x509 -in $CERTFILE -noout -fingerprint -sha256 SHA256 Fingerprint=14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64: \ 16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 In this example, the contents of this field would be `14:6D:E9:83:C5:73: 06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF: 44:E5`. If these tools are not available to you, you can convert the PEM certificate into the DER format, compute the SHA-256 hash of that string and represent the result as a hexstring (that is, uppercase hexadecimal representations of each octet, separated by colons).
|
||
///
|
||
/// Sets the *source.android app.certificate.sha256 fingerprint* query property to the given value.
|
||
pub fn source_android_app_certificate_sha256_fingerprint(mut self, new_value: &str) -> AssetlinkCheckCall<'a, S> {
|
||
self._source_android_app_certificate_sha256_fingerprint = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// Query string for the relation. We identify relations with strings of the format `/`, where `` must be one of a set of pre-defined purpose categories, and `` is a free-form lowercase alphanumeric string that describes the specific use case of the statement. Refer to [our API documentation](/digital-asset-links/v1/relation-strings) for the current list of supported relations. For a query to match an asset link, both the query's and the asset link's relation strings must match exactly. Example: A query with relation `delegate_permission/common.handle_all_urls` matches an asset link with relation `delegate_permission/common.handle_all_urls`.
|
||
///
|
||
/// Sets the *relation* query property to the given value.
|
||
pub fn relation(mut self, new_value: &str) -> AssetlinkCheckCall<'a, S> {
|
||
self._relation = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> AssetlinkCheckCall<'a, S> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known parameters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
pub fn param<T>(mut self, name: T, value: T) -> AssetlinkCheckCall<'a, S>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
}
|
||
|
||
|
||
/// Retrieves a list of all statements from a given source that match the specified target and statement string. The API guarantees that all statements with secure source assets, such as HTTPS websites or Android apps, have been made in a secure way by the owner of those assets, as described in the [Digital Asset Links technical design specification](https://github.com/google/digitalassetlinks/blob/master/well-known/details.md). Specifically, you should consider that for insecure websites (that is, where the URL starts with `http://` instead of `https://`), this guarantee cannot be made. The `List` command is most useful in cases where the API client wants to know all the ways in which two assets are related, or enumerate all the relationships from a particular source asset. Example: a feature that helps users navigate to related items. When a mobile app is running on a device, the feature would make it easy to navigate to the corresponding web site or Google+ profile.
|
||
///
|
||
/// A builder for the *list* method supported by a *statement* resource.
|
||
/// It is not used directly, but through a `StatementMethods` instance.
|
||
///
|
||
/// # Example
|
||
///
|
||
/// Instantiate a resource method builder
|
||
///
|
||
/// ```test_harness,no_run
|
||
/// # extern crate hyper;
|
||
/// # extern crate hyper_rustls;
|
||
/// # extern crate google_digitalassetlinks1 as digitalassetlinks1;
|
||
/// # async fn dox() {
|
||
/// # use std::default::Default;
|
||
/// # use digitalassetlinks1::{Digitalassetlinks, oauth2, hyper, hyper_rustls};
|
||
///
|
||
/// # let secret: oauth2::ApplicationSecret = Default::default();
|
||
/// # let auth = oauth2::InstalledFlowAuthenticator::builder(
|
||
/// # secret,
|
||
/// # oauth2::InstalledFlowReturnMethod::HTTPRedirect,
|
||
/// # ).build().await.unwrap();
|
||
/// # let mut hub = Digitalassetlinks::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().enable_http2().build()), auth);
|
||
/// // You can configure optional parameters by calling the respective setters at will, and
|
||
/// // execute the final call using `doit()`.
|
||
/// // Values shown here are possibly random and not representative !
|
||
/// let result = hub.statements().list()
|
||
/// .source_web_site("sed")
|
||
/// .source_android_app_package_name("amet.")
|
||
/// .source_android_app_certificate_sha256_fingerprint("takimata")
|
||
/// .relation("amet.")
|
||
/// .doit().await;
|
||
/// # }
|
||
/// ```
|
||
pub struct StatementListCall<'a, S>
|
||
where S: 'a {
|
||
|
||
hub: &'a Digitalassetlinks<S>,
|
||
_source_web_site: Option<String>,
|
||
_source_android_app_package_name: Option<String>,
|
||
_source_android_app_certificate_sha256_fingerprint: Option<String>,
|
||
_relation: Option<String>,
|
||
_delegate: Option<&'a mut dyn client::Delegate>,
|
||
_additional_params: HashMap<String, String>,
|
||
}
|
||
|
||
impl<'a, S> client::CallBuilder for StatementListCall<'a, S> {}
|
||
|
||
impl<'a, S> StatementListCall<'a, S>
|
||
where
|
||
S: tower_service::Service<Uri> + Clone + Send + Sync + 'static,
|
||
S::Response: hyper::client::connect::Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
|
||
S::Future: Send + Unpin + 'static,
|
||
S::Error: Into<Box<dyn StdError + Send + Sync>>,
|
||
{
|
||
|
||
|
||
/// Perform the operation you have build so far.
|
||
pub async fn doit(mut self) -> client::Result<(hyper::Response<hyper::body::Body>, ListResponse)> {
|
||
use std::io::{Read, Seek};
|
||
use hyper::header::{CONTENT_TYPE, CONTENT_LENGTH, AUTHORIZATION, USER_AGENT, LOCATION};
|
||
use client::ToParts;
|
||
let mut dd = client::DefaultDelegate;
|
||
let mut dlg: &mut dyn client::Delegate = match self._delegate {
|
||
Some(d) => d,
|
||
None => &mut dd
|
||
};
|
||
dlg.begin(client::MethodInfo { id: "digitalassetlinks.statements.list",
|
||
http_method: hyper::Method::GET });
|
||
let mut params: Vec<(&str, String)> = Vec::with_capacity(6 + self._additional_params.len());
|
||
if let Some(value) = self._source_web_site {
|
||
params.push(("source.web.site", value.to_string()));
|
||
}
|
||
if let Some(value) = self._source_android_app_package_name {
|
||
params.push(("source.androidApp.packageName", value.to_string()));
|
||
}
|
||
if let Some(value) = self._source_android_app_certificate_sha256_fingerprint {
|
||
params.push(("source.androidApp.certificate.sha256Fingerprint", value.to_string()));
|
||
}
|
||
if let Some(value) = self._relation {
|
||
params.push(("relation", value.to_string()));
|
||
}
|
||
for &field in ["alt", "source.web.site", "source.androidApp.packageName", "source.androidApp.certificate.sha256Fingerprint", "relation"].iter() {
|
||
if self._additional_params.contains_key(field) {
|
||
dlg.finished(false);
|
||
return Err(client::Error::FieldClash(field));
|
||
}
|
||
}
|
||
for (name, value) in self._additional_params.iter() {
|
||
params.push((&name, value.clone()));
|
||
}
|
||
|
||
params.push(("alt", "json".to_string()));
|
||
|
||
let mut url = self.hub._base_url.clone() + "v1/statements:list";
|
||
|
||
let key = dlg.api_key();
|
||
match key {
|
||
Some(value) => params.push(("key", value)),
|
||
None => {
|
||
dlg.finished(false);
|
||
return Err(client::Error::MissingAPIKey)
|
||
}
|
||
}
|
||
|
||
|
||
let url = url::Url::parse_with_params(&url, params).unwrap();
|
||
|
||
|
||
|
||
loop {
|
||
let mut req_result = {
|
||
let client = &self.hub.client;
|
||
dlg.pre_request();
|
||
let mut req_builder = hyper::Request::builder().method(hyper::Method::GET).uri(url.clone().into_string())
|
||
.header(USER_AGENT, self.hub._user_agent.clone());
|
||
|
||
|
||
let request = req_builder
|
||
.body(hyper::body::Body::empty());
|
||
|
||
client.request(request.unwrap()).await
|
||
|
||
};
|
||
|
||
match req_result {
|
||
Err(err) => {
|
||
if let client::Retry::After(d) = dlg.http_error(&err) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
dlg.finished(false);
|
||
return Err(client::Error::HttpError(err))
|
||
}
|
||
Ok(mut res) => {
|
||
if !res.status().is_success() {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
let (parts, _) = res.into_parts();
|
||
let body = hyper::Body::from(res_body_string.clone());
|
||
let restored_response = hyper::Response::from_parts(parts, body);
|
||
|
||
let server_response = json::from_str::<serde_json::Value>(&res_body_string).ok();
|
||
|
||
if let client::Retry::After(d) = dlg.http_failure(&restored_response, server_response.clone()) {
|
||
sleep(d);
|
||
continue;
|
||
}
|
||
|
||
dlg.finished(false);
|
||
|
||
return match server_response {
|
||
Some(error_value) => Err(client::Error::BadRequest(error_value)),
|
||
None => Err(client::Error::Failure(restored_response)),
|
||
}
|
||
}
|
||
let result_value = {
|
||
let res_body_string = client::get_body_as_string(res.body_mut()).await;
|
||
|
||
match json::from_str(&res_body_string) {
|
||
Ok(decoded) => (res, decoded),
|
||
Err(err) => {
|
||
dlg.response_json_decode_error(&res_body_string, &err);
|
||
return Err(client::Error::JsonDecodeError(res_body_string, err));
|
||
}
|
||
}
|
||
};
|
||
|
||
dlg.finished(true);
|
||
return Ok(result_value)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/// Web assets are identified by a URL that contains only the scheme, hostname and port parts. The format is http[s]://[:] Hostnames must be fully qualified: they must end in a single period ("`.`"). Only the schemes "http" and "https" are currently allowed. Port numbers are given as a decimal number, and they must be omitted if the standard port numbers are used: 80 for http and 443 for https. We call this limited URL the "site". All URLs that share the same scheme, hostname and port are considered to be a part of the site and thus belong to the web asset. Example: the asset with the site `https://www.google.com` contains all these URLs: * `https://www.google.com/` * `https://www.google.com:443/` * `https://www.google.com/foo` * `https://www.google.com/foo?bar` * `https://www.google.com/foo#bar` * `https://user@password:www.google.com/` But it does not contain these URLs: * `http://www.google.com/` (wrong scheme) * `https://google.com/` (hostname does not match) * `https://www.google.com:444/` (port does not match) REQUIRED
|
||
///
|
||
/// Sets the *source.web.site* query property to the given value.
|
||
pub fn source_web_site(mut self, new_value: &str) -> StatementListCall<'a, S> {
|
||
self._source_web_site = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// Android App assets are naturally identified by their Java package name. For example, the Google Maps app uses the package name `com.google.android.apps.maps`. REQUIRED
|
||
///
|
||
/// Sets the *source.android app.package name* query property to the given value.
|
||
pub fn source_android_app_package_name(mut self, new_value: &str) -> StatementListCall<'a, S> {
|
||
self._source_android_app_package_name = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The uppercase SHA-265 fingerprint of the certificate. From the PEM certificate, it can be acquired like this: $ keytool -printcert -file $CERTFILE | grep SHA256: SHA256: 14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83: \ 42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 or like this: $ openssl x509 -in $CERTFILE -noout -fingerprint -sha256 SHA256 Fingerprint=14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64: \ 16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5 In this example, the contents of this field would be `14:6D:E9:83:C5:73: 06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF: 44:E5`. If these tools are not available to you, you can convert the PEM certificate into the DER format, compute the SHA-256 hash of that string and represent the result as a hexstring (that is, uppercase hexadecimal representations of each octet, separated by colons).
|
||
///
|
||
/// Sets the *source.android app.certificate.sha256 fingerprint* query property to the given value.
|
||
pub fn source_android_app_certificate_sha256_fingerprint(mut self, new_value: &str) -> StatementListCall<'a, S> {
|
||
self._source_android_app_certificate_sha256_fingerprint = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// Use only associations that match the specified relation. See the [`Statement`](#Statement) message for a detailed definition of relation strings. For a query to match a statement, one of the following must be true: * both the query's and the statement's relation strings match exactly, or * the query's relation string is empty or missing. Example: A query with relation `delegate_permission/common.handle_all_urls` matches an asset link with relation `delegate_permission/common.handle_all_urls`.
|
||
///
|
||
/// Sets the *relation* query property to the given value.
|
||
pub fn relation(mut self, new_value: &str) -> StatementListCall<'a, S> {
|
||
self._relation = Some(new_value.to_string());
|
||
self
|
||
}
|
||
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
|
||
/// while executing the actual API request.
|
||
///
|
||
/// It should be used to handle progress information, and to implement a certain level of resilience.
|
||
///
|
||
/// Sets the *delegate* property to the given value.
|
||
pub fn delegate(mut self, new_value: &'a mut dyn client::Delegate) -> StatementListCall<'a, S> {
|
||
self._delegate = Some(new_value);
|
||
self
|
||
}
|
||
|
||
/// Set any additional parameter of the query string used in the request.
|
||
/// It should be used to set parameters which are not yet available through their own
|
||
/// setters.
|
||
///
|
||
/// Please note that this method must not be used to set any of the known parameters
|
||
/// which have their own setter method. If done anyway, the request will fail.
|
||
///
|
||
/// # Additional Parameters
|
||
///
|
||
/// * *$.xgafv* (query-string) - V1 error format.
|
||
/// * *access_token* (query-string) - OAuth access token.
|
||
/// * *alt* (query-string) - Data format for response.
|
||
/// * *callback* (query-string) - JSONP
|
||
/// * *fields* (query-string) - Selector specifying which fields to include in a partial response.
|
||
/// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
|
||
/// * *oauth_token* (query-string) - OAuth 2.0 token for the current user.
|
||
/// * *prettyPrint* (query-boolean) - Returns response with indentations and line breaks.
|
||
/// * *quotaUser* (query-string) - Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
|
||
/// * *uploadType* (query-string) - Legacy upload protocol for media (e.g. "media", "multipart").
|
||
/// * *upload_protocol* (query-string) - Upload protocol for media (e.g. "raw", "multipart").
|
||
pub fn param<T>(mut self, name: T, value: T) -> StatementListCall<'a, S>
|
||
where T: AsRef<str> {
|
||
self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string());
|
||
self
|
||
}
|
||
|
||
}
|
||
|
||
|