use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateRepositoryRequest {
#[serde(rename = "ClientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "Repository")]
pub repository: Repository,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateRepositoryResponse {
#[serde(rename = "RepositoryAssociation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_association: Option<RepositoryAssociation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CodeCommitRepository {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CodeReview {
#[serde(rename = "CodeReviewArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_review_arn: Option<String>,
#[serde(rename = "CreatedTimeStamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time_stamp: Option<f64>,
#[serde(rename = "LastUpdatedTimeStamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time_stamp: Option<f64>,
#[serde(rename = "Metrics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metrics: Option<Metrics>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "ProviderType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_type: Option<String>,
#[serde(rename = "PullRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_id: Option<String>,
#[serde(rename = "RepositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
#[serde(rename = "SourceCodeType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_code_type: Option<SourceCodeType>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "StateReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_reason: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CodeReviewSummary {
#[serde(rename = "CodeReviewArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_review_arn: Option<String>,
#[serde(rename = "CreatedTimeStamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time_stamp: Option<f64>,
#[serde(rename = "LastUpdatedTimeStamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time_stamp: Option<f64>,
#[serde(rename = "MetricsSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metrics_summary: Option<MetricsSummary>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "ProviderType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_type: Option<String>,
#[serde(rename = "PullRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_id: Option<String>,
#[serde(rename = "RepositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CommitDiffSourceCodeType {
#[serde(rename = "DestinationCommit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_commit: Option<String>,
#[serde(rename = "SourceCommit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_commit: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCodeReviewRequest {
#[serde(rename = "CodeReviewArn")]
pub code_review_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeCodeReviewResponse {
#[serde(rename = "CodeReview")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_review: Option<CodeReview>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeRecommendationFeedbackRequest {
#[serde(rename = "CodeReviewArn")]
pub code_review_arn: String,
#[serde(rename = "RecommendationId")]
pub recommendation_id: String,
#[serde(rename = "UserId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeRecommendationFeedbackResponse {
#[serde(rename = "RecommendationFeedback")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommendation_feedback: Option<RecommendationFeedback>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeRepositoryAssociationRequest {
#[serde(rename = "AssociationArn")]
pub association_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeRepositoryAssociationResponse {
#[serde(rename = "RepositoryAssociation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_association: Option<RepositoryAssociation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateRepositoryRequest {
#[serde(rename = "AssociationArn")]
pub association_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateRepositoryResponse {
#[serde(rename = "RepositoryAssociation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_association: Option<RepositoryAssociation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListCodeReviewsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ProviderTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_types: Option<Vec<String>>,
#[serde(rename = "RepositoryNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_names: Option<Vec<String>>,
#[serde(rename = "States")]
#[serde(skip_serializing_if = "Option::is_none")]
pub states: Option<Vec<String>>,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListCodeReviewsResponse {
#[serde(rename = "CodeReviewSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_review_summaries: Option<Vec<CodeReviewSummary>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRecommendationFeedbackRequest {
#[serde(rename = "CodeReviewArn")]
pub code_review_arn: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "RecommendationIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommendation_ids: Option<Vec<String>>,
#[serde(rename = "UserIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_ids: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListRecommendationFeedbackResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "RecommendationFeedbackSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommendation_feedback_summaries: Option<Vec<RecommendationFeedbackSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRecommendationsRequest {
#[serde(rename = "CodeReviewArn")]
pub code_review_arn: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListRecommendationsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "RecommendationSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommendation_summaries: Option<Vec<RecommendationSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRepositoryAssociationsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "Names")]
#[serde(skip_serializing_if = "Option::is_none")]
pub names: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Owners")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owners: Option<Vec<String>>,
#[serde(rename = "ProviderTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_types: Option<Vec<String>>,
#[serde(rename = "States")]
#[serde(skip_serializing_if = "Option::is_none")]
pub states: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListRepositoryAssociationsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "RepositoryAssociationSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_association_summaries: Option<Vec<RepositoryAssociationSummary>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Metrics {
#[serde(rename = "FindingsCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub findings_count: Option<i64>,
#[serde(rename = "MeteredLinesOfCodeCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metered_lines_of_code_count: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MetricsSummary {
#[serde(rename = "FindingsCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub findings_count: Option<i64>,
#[serde(rename = "MeteredLinesOfCodeCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metered_lines_of_code_count: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutRecommendationFeedbackRequest {
#[serde(rename = "CodeReviewArn")]
pub code_review_arn: String,
#[serde(rename = "Reactions")]
pub reactions: Vec<String>,
#[serde(rename = "RecommendationId")]
pub recommendation_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutRecommendationFeedbackResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecommendationFeedback {
#[serde(rename = "CodeReviewArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_review_arn: Option<String>,
#[serde(rename = "CreatedTimeStamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time_stamp: Option<f64>,
#[serde(rename = "LastUpdatedTimeStamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time_stamp: Option<f64>,
#[serde(rename = "Reactions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reactions: Option<Vec<String>>,
#[serde(rename = "RecommendationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommendation_id: Option<String>,
#[serde(rename = "UserId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecommendationFeedbackSummary {
#[serde(rename = "Reactions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reactions: Option<Vec<String>>,
#[serde(rename = "RecommendationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommendation_id: Option<String>,
#[serde(rename = "UserId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecommendationSummary {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "EndLine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_line: Option<i64>,
#[serde(rename = "FilePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_path: Option<String>,
#[serde(rename = "RecommendationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommendation_id: Option<String>,
#[serde(rename = "StartLine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_line: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Repository {
#[serde(rename = "Bitbucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bitbucket: Option<ThirdPartySourceRepository>,
#[serde(rename = "CodeCommit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_commit: Option<CodeCommitRepository>,
#[serde(rename = "GitHubEnterpriseServer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub git_hub_enterprise_server: Option<ThirdPartySourceRepository>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RepositoryAssociation {
#[serde(rename = "AssociationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub association_arn: Option<String>,
#[serde(rename = "AssociationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub association_id: Option<String>,
#[serde(rename = "ConnectionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_arn: Option<String>,
#[serde(rename = "CreatedTimeStamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time_stamp: Option<f64>,
#[serde(rename = "LastUpdatedTimeStamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time_stamp: Option<f64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "ProviderType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_type: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "StateReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_reason: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RepositoryAssociationSummary {
#[serde(rename = "AssociationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub association_arn: Option<String>,
#[serde(rename = "AssociationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub association_id: Option<String>,
#[serde(rename = "ConnectionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_arn: Option<String>,
#[serde(rename = "LastUpdatedTimeStamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time_stamp: Option<f64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "ProviderType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_type: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SourceCodeType {
#[serde(rename = "CommitDiff")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_diff: Option<CommitDiffSourceCodeType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ThirdPartySourceRepository {
#[serde(rename = "ConnectionArn")]
pub connection_arn: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Owner")]
pub owner: String,
}
#[derive(Debug, PartialEq)]
pub enum AssociateRepositoryError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
Throttling(String),
}
impl AssociateRepositoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateRepositoryError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AssociateRepositoryError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(AssociateRepositoryError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(AssociateRepositoryError::InternalServer(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(AssociateRepositoryError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateRepositoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateRepositoryError::AccessDenied(ref cause) => write!(f, "{}", cause),
AssociateRepositoryError::Conflict(ref cause) => write!(f, "{}", cause),
AssociateRepositoryError::InternalServer(ref cause) => write!(f, "{}", cause),
AssociateRepositoryError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AssociateRepositoryError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCodeReviewError {
AccessDenied(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeCodeReviewError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeCodeReviewError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DescribeCodeReviewError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(DescribeCodeReviewError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeCodeReviewError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeCodeReviewError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeCodeReviewError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCodeReviewError::AccessDenied(ref cause) => write!(f, "{}", cause),
DescribeCodeReviewError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeCodeReviewError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeCodeReviewError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeCodeReviewError {}
#[derive(Debug, PartialEq)]
pub enum DescribeRecommendationFeedbackError {
AccessDenied(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeRecommendationFeedbackError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeRecommendationFeedbackError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DescribeRecommendationFeedbackError::AccessDenied(
err.msg,
))
}
"InternalServerException" => {
return RusotoError::Service(
DescribeRecommendationFeedbackError::InternalServer(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeRecommendationFeedbackError::ResourceNotFound(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(DescribeRecommendationFeedbackError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeRecommendationFeedbackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeRecommendationFeedbackError::AccessDenied(ref cause) => write!(f, "{}", cause),
DescribeRecommendationFeedbackError::InternalServer(ref cause) => {
write!(f, "{}", cause)
}
DescribeRecommendationFeedbackError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DescribeRecommendationFeedbackError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeRecommendationFeedbackError {}
#[derive(Debug, PartialEq)]
pub enum DescribeRepositoryAssociationError {
AccessDenied(String),
InternalServer(String),
NotFound(String),
Throttling(String),
}
impl DescribeRepositoryAssociationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeRepositoryAssociationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DescribeRepositoryAssociationError::AccessDenied(
err.msg,
))
}
"InternalServerException" => {
return RusotoError::Service(
DescribeRepositoryAssociationError::InternalServer(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(DescribeRepositoryAssociationError::NotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeRepositoryAssociationError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeRepositoryAssociationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeRepositoryAssociationError::AccessDenied(ref cause) => write!(f, "{}", cause),
DescribeRepositoryAssociationError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeRepositoryAssociationError::NotFound(ref cause) => write!(f, "{}", cause),
DescribeRepositoryAssociationError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeRepositoryAssociationError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateRepositoryError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
NotFound(String),
Throttling(String),
}
impl DisassociateRepositoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisassociateRepositoryError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DisassociateRepositoryError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(DisassociateRepositoryError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(DisassociateRepositoryError::InternalServer(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(DisassociateRepositoryError::NotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DisassociateRepositoryError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateRepositoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateRepositoryError::AccessDenied(ref cause) => write!(f, "{}", cause),
DisassociateRepositoryError::Conflict(ref cause) => write!(f, "{}", cause),
DisassociateRepositoryError::InternalServer(ref cause) => write!(f, "{}", cause),
DisassociateRepositoryError::NotFound(ref cause) => write!(f, "{}", cause),
DisassociateRepositoryError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DisassociateRepositoryError {}
#[derive(Debug, PartialEq)]
pub enum ListCodeReviewsError {
AccessDenied(String),
InternalServer(String),
Throttling(String),
}
impl ListCodeReviewsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListCodeReviewsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListCodeReviewsError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(ListCodeReviewsError::InternalServer(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListCodeReviewsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListCodeReviewsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListCodeReviewsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListCodeReviewsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListCodeReviewsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListCodeReviewsError {}
#[derive(Debug, PartialEq)]
pub enum ListRecommendationFeedbackError {
AccessDenied(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListRecommendationFeedbackError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListRecommendationFeedbackError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListRecommendationFeedbackError::AccessDenied(
err.msg,
))
}
"InternalServerException" => {
return RusotoError::Service(ListRecommendationFeedbackError::InternalServer(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListRecommendationFeedbackError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListRecommendationFeedbackError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRecommendationFeedbackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRecommendationFeedbackError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListRecommendationFeedbackError::InternalServer(ref cause) => write!(f, "{}", cause),
ListRecommendationFeedbackError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListRecommendationFeedbackError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListRecommendationFeedbackError {}
#[derive(Debug, PartialEq)]
pub enum ListRecommendationsError {
AccessDenied(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListRecommendationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListRecommendationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListRecommendationsError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(ListRecommendationsError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListRecommendationsError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListRecommendationsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRecommendationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRecommendationsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListRecommendationsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListRecommendationsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListRecommendationsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListRecommendationsError {}
#[derive(Debug, PartialEq)]
pub enum ListRepositoryAssociationsError {
InternalServer(String),
Throttling(String),
}
impl ListRepositoryAssociationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListRepositoryAssociationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListRepositoryAssociationsError::InternalServer(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListRepositoryAssociationsError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRepositoryAssociationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRepositoryAssociationsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListRepositoryAssociationsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListRepositoryAssociationsError {}
#[derive(Debug, PartialEq)]
pub enum PutRecommendationFeedbackError {
AccessDenied(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl PutRecommendationFeedbackError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutRecommendationFeedbackError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(PutRecommendationFeedbackError::AccessDenied(
err.msg,
))
}
"InternalServerException" => {
return RusotoError::Service(PutRecommendationFeedbackError::InternalServer(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(PutRecommendationFeedbackError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(PutRecommendationFeedbackError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutRecommendationFeedbackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutRecommendationFeedbackError::AccessDenied(ref cause) => write!(f, "{}", cause),
PutRecommendationFeedbackError::InternalServer(ref cause) => write!(f, "{}", cause),
PutRecommendationFeedbackError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
PutRecommendationFeedbackError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutRecommendationFeedbackError {}
#[async_trait]
pub trait CodeGuruReviewer {
async fn associate_repository(
&self,
input: AssociateRepositoryRequest,
) -> Result<AssociateRepositoryResponse, RusotoError<AssociateRepositoryError>>;
async fn describe_code_review(
&self,
input: DescribeCodeReviewRequest,
) -> Result<DescribeCodeReviewResponse, RusotoError<DescribeCodeReviewError>>;
async fn describe_recommendation_feedback(
&self,
input: DescribeRecommendationFeedbackRequest,
) -> Result<
DescribeRecommendationFeedbackResponse,
RusotoError<DescribeRecommendationFeedbackError>,
>;
async fn describe_repository_association(
&self,
input: DescribeRepositoryAssociationRequest,
) -> Result<
DescribeRepositoryAssociationResponse,
RusotoError<DescribeRepositoryAssociationError>,
>;
async fn disassociate_repository(
&self,
input: DisassociateRepositoryRequest,
) -> Result<DisassociateRepositoryResponse, RusotoError<DisassociateRepositoryError>>;
async fn list_code_reviews(
&self,
input: ListCodeReviewsRequest,
) -> Result<ListCodeReviewsResponse, RusotoError<ListCodeReviewsError>>;
async fn list_recommendation_feedback(
&self,
input: ListRecommendationFeedbackRequest,
) -> Result<ListRecommendationFeedbackResponse, RusotoError<ListRecommendationFeedbackError>>;
async fn list_recommendations(
&self,
input: ListRecommendationsRequest,
) -> Result<ListRecommendationsResponse, RusotoError<ListRecommendationsError>>;
async fn list_repository_associations(
&self,
input: ListRepositoryAssociationsRequest,
) -> Result<ListRepositoryAssociationsResponse, RusotoError<ListRepositoryAssociationsError>>;
async fn put_recommendation_feedback(
&self,
input: PutRecommendationFeedbackRequest,
) -> Result<PutRecommendationFeedbackResponse, RusotoError<PutRecommendationFeedbackError>>;
}
#[derive(Clone)]
pub struct CodeGuruReviewerClient {
client: Client,
region: region::Region,
}
impl CodeGuruReviewerClient {
pub fn new(region: region::Region) -> CodeGuruReviewerClient {
CodeGuruReviewerClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> CodeGuruReviewerClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
CodeGuruReviewerClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> CodeGuruReviewerClient {
CodeGuruReviewerClient { client, region }
}
}
#[async_trait]
impl CodeGuruReviewer for CodeGuruReviewerClient {
#[allow(unused_mut)]
async fn associate_repository(
&self,
input: AssociateRepositoryRequest,
) -> Result<AssociateRepositoryResponse, RusotoError<AssociateRepositoryError>> {
let request_uri = "/associations";
let mut request =
SignedRequest::new("POST", "codeguru-reviewer", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateRepositoryResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AssociateRepositoryError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_code_review(
&self,
input: DescribeCodeReviewRequest,
) -> Result<DescribeCodeReviewResponse, RusotoError<DescribeCodeReviewError>> {
let request_uri = format!(
"/codereviews/{code_review_arn}",
code_review_arn = input.code_review_arn
);
let mut request =
SignedRequest::new("GET", "codeguru-reviewer", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeCodeReviewResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeCodeReviewError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_recommendation_feedback(
&self,
input: DescribeRecommendationFeedbackRequest,
) -> Result<
DescribeRecommendationFeedbackResponse,
RusotoError<DescribeRecommendationFeedbackError>,
> {
let request_uri = format!(
"/feedback/{code_review_arn}",
code_review_arn = input.code_review_arn
);
let mut request =
SignedRequest::new("GET", "codeguru-reviewer", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("RecommendationId", &input.recommendation_id);
if let Some(ref x) = input.user_id {
params.put("UserId", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeRecommendationFeedbackResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeRecommendationFeedbackError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_repository_association(
&self,
input: DescribeRepositoryAssociationRequest,
) -> Result<
DescribeRepositoryAssociationResponse,
RusotoError<DescribeRepositoryAssociationError>,
> {
let request_uri = format!(
"/associations/{association_arn}",
association_arn = input.association_arn
);
let mut request =
SignedRequest::new("GET", "codeguru-reviewer", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeRepositoryAssociationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeRepositoryAssociationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn disassociate_repository(
&self,
input: DisassociateRepositoryRequest,
) -> Result<DisassociateRepositoryResponse, RusotoError<DisassociateRepositoryError>> {
let request_uri = format!(
"/associations/{association_arn}",
association_arn = input.association_arn
);
let mut request =
SignedRequest::new("DELETE", "codeguru-reviewer", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateRepositoryResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DisassociateRepositoryError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_code_reviews(
&self,
input: ListCodeReviewsRequest,
) -> Result<ListCodeReviewsResponse, RusotoError<ListCodeReviewsError>> {
let request_uri = "/codereviews";
let mut request =
SignedRequest::new("GET", "codeguru-reviewer", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
if let Some(ref x) = input.provider_types {
for item in x.iter() {
params.put("ProviderTypes", item);
}
}
if let Some(ref x) = input.repository_names {
for item in x.iter() {
params.put("RepositoryNames", item);
}
}
if let Some(ref x) = input.states {
for item in x.iter() {
params.put("States", item);
}
}
params.put("Type", &input.type_);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListCodeReviewsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListCodeReviewsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_recommendation_feedback(
&self,
input: ListRecommendationFeedbackRequest,
) -> Result<ListRecommendationFeedbackResponse, RusotoError<ListRecommendationFeedbackError>>
{
let request_uri = format!(
"/feedback/{code_review_arn}/RecommendationFeedback",
code_review_arn = input.code_review_arn
);
let mut request =
SignedRequest::new("GET", "codeguru-reviewer", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
if let Some(ref x) = input.recommendation_ids {
for item in x.iter() {
params.put("RecommendationIds", item);
}
}
if let Some(ref x) = input.user_ids {
for item in x.iter() {
params.put("UserIds", item);
}
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListRecommendationFeedbackResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListRecommendationFeedbackError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_recommendations(
&self,
input: ListRecommendationsRequest,
) -> Result<ListRecommendationsResponse, RusotoError<ListRecommendationsError>> {
let request_uri = format!(
"/codereviews/{code_review_arn}/Recommendations",
code_review_arn = input.code_review_arn
);
let mut request =
SignedRequest::new("GET", "codeguru-reviewer", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListRecommendationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListRecommendationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_repository_associations(
&self,
input: ListRepositoryAssociationsRequest,
) -> Result<ListRepositoryAssociationsResponse, RusotoError<ListRepositoryAssociationsError>>
{
let request_uri = "/associations";
let mut request =
SignedRequest::new("GET", "codeguru-reviewer", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.names {
for item in x.iter() {
params.put("Name", item);
}
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
if let Some(ref x) = input.owners {
for item in x.iter() {
params.put("Owner", item);
}
}
if let Some(ref x) = input.provider_types {
for item in x.iter() {
params.put("ProviderType", item);
}
}
if let Some(ref x) = input.states {
for item in x.iter() {
params.put("State", item);
}
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListRepositoryAssociationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListRepositoryAssociationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_recommendation_feedback(
&self,
input: PutRecommendationFeedbackRequest,
) -> Result<PutRecommendationFeedbackResponse, RusotoError<PutRecommendationFeedbackError>>
{
let request_uri = "/feedback";
let mut request =
SignedRequest::new("PUT", "codeguru-reviewer", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutRecommendationFeedbackResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutRecommendationFeedbackError::from_response(response))
}
}
}