PentestJob.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/securityagent/SecurityAgent_EXPORTS.h>
#include <aws/securityagent/model/Actor.h>
#include <aws/securityagent/model/CleanUpStrategy.h>
#include <aws/securityagent/model/CloudWatchLog.h>
#include <aws/securityagent/model/CodeRemediationStrategy.h>
#include <aws/securityagent/model/DocumentInfo.h>
#include <aws/securityagent/model/Endpoint.h>
#include <aws/securityagent/model/ErrorInformation.h>
#include <aws/securityagent/model/ExecutionContext.h>
#include <aws/securityagent/model/IntegratedRepository.h>
#include <aws/securityagent/model/JobStatus.h>
#include <aws/securityagent/model/NetworkTrafficConfig.h>
#include <aws/securityagent/model/RiskType.h>
#include <aws/securityagent/model/SkillType.h>
#include <aws/securityagent/model/SourceCodeRepository.h>
#include <aws/securityagent/model/Step.h>
#include <aws/securityagent/model/VpcConfig.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace SecurityAgent {
namespace Model {
 
class PentestJob {
 public:
  AWS_SECURITYAGENT_API PentestJob() = default;
  AWS_SECURITYAGENT_API PentestJob(Aws::Utils::Json::JsonView jsonValue);
  AWS_SECURITYAGENT_API PentestJob& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_SECURITYAGENT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetPentestJobId() const { return m_pentestJobId; }
  inline bool PentestJobIdHasBeenSet() const { return m_pentestJobIdHasBeenSet; }
  template <typename PentestJobIdT = Aws::String>
  void SetPentestJobId(PentestJobIdT&& value) {
    m_pentestJobIdHasBeenSet = true;
    m_pentestJobId = std::forward<PentestJobIdT>(value);
  }
  template <typename PentestJobIdT = Aws::String>
  PentestJob& WithPentestJobId(PentestJobIdT&& value) {
    SetPentestJobId(std::forward<PentestJobIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPentestId() const { return m_pentestId; }
  inline bool PentestIdHasBeenSet() const { return m_pentestIdHasBeenSet; }
  template <typename PentestIdT = Aws::String>
  void SetPentestId(PentestIdT&& value) {
    m_pentestIdHasBeenSet = true;
    m_pentestId = std::forward<PentestIdT>(value);
  }
  template <typename PentestIdT = Aws::String>
  PentestJob& WithPentestId(PentestIdT&& value) {
    SetPentestId(std::forward<PentestIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTitle() const { return m_title; }
  inline bool TitleHasBeenSet() const { return m_titleHasBeenSet; }
  template <typename TitleT = Aws::String>
  void SetTitle(TitleT&& value) {
    m_titleHasBeenSet = true;
    m_title = std::forward<TitleT>(value);
  }
  template <typename TitleT = Aws::String>
  PentestJob& WithTitle(TitleT&& value) {
    SetTitle(std::forward<TitleT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOverview() const { return m_overview; }
  inline bool OverviewHasBeenSet() const { return m_overviewHasBeenSet; }
  template <typename OverviewT = Aws::String>
  void SetOverview(OverviewT&& value) {
    m_overviewHasBeenSet = true;
    m_overview = std::forward<OverviewT>(value);
  }
  template <typename OverviewT = Aws::String>
  PentestJob& WithOverview(OverviewT&& value) {
    SetOverview(std::forward<OverviewT>(value));
    return *this;
  }
 
 
  inline JobStatus GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  inline void SetStatus(JobStatus value) {
    m_statusHasBeenSet = true;
    m_status = value;
  }
  inline PentestJob& WithStatus(JobStatus value) {
    SetStatus(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Endpoint>& GetEndpoints() const { return m_endpoints; }
  inline bool EndpointsHasBeenSet() const { return m_endpointsHasBeenSet; }
  template <typename EndpointsT = Aws::Vector<Endpoint>>
  void SetEndpoints(EndpointsT&& value) {
    m_endpointsHasBeenSet = true;
    m_endpoints = std::forward<EndpointsT>(value);
  }
  template <typename EndpointsT = Aws::Vector<Endpoint>>
  PentestJob& WithEndpoints(EndpointsT&& value) {
    SetEndpoints(std::forward<EndpointsT>(value));
    return *this;
  }
  template <typename EndpointsT = Endpoint>
  PentestJob& AddEndpoints(EndpointsT&& value) {
    m_endpointsHasBeenSet = true;
    m_endpoints.emplace_back(std::forward<EndpointsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Actor>& GetActors() const { return m_actors; }
  inline bool ActorsHasBeenSet() const { return m_actorsHasBeenSet; }
  template <typename ActorsT = Aws::Vector<Actor>>
  void SetActors(ActorsT&& value) {
    m_actorsHasBeenSet = true;
    m_actors = std::forward<ActorsT>(value);
  }
  template <typename ActorsT = Aws::Vector<Actor>>
  PentestJob& WithActors(ActorsT&& value) {
    SetActors(std::forward<ActorsT>(value));
    return *this;
  }
  template <typename ActorsT = Actor>
  PentestJob& AddActors(ActorsT&& value) {
    m_actorsHasBeenSet = true;
    m_actors.emplace_back(std::forward<ActorsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<DocumentInfo>& GetDocuments() const { return m_documents; }
  inline bool DocumentsHasBeenSet() const { return m_documentsHasBeenSet; }
  template <typename DocumentsT = Aws::Vector<DocumentInfo>>
  void SetDocuments(DocumentsT&& value) {
    m_documentsHasBeenSet = true;
    m_documents = std::forward<DocumentsT>(value);
  }
  template <typename DocumentsT = Aws::Vector<DocumentInfo>>
  PentestJob& WithDocuments(DocumentsT&& value) {
    SetDocuments(std::forward<DocumentsT>(value));
    return *this;
  }
  template <typename DocumentsT = DocumentInfo>
  PentestJob& AddDocuments(DocumentsT&& value) {
    m_documentsHasBeenSet = true;
    m_documents.emplace_back(std::forward<DocumentsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<SourceCodeRepository>& GetSourceCode() const { return m_sourceCode; }
  inline bool SourceCodeHasBeenSet() const { return m_sourceCodeHasBeenSet; }
  template <typename SourceCodeT = Aws::Vector<SourceCodeRepository>>
  void SetSourceCode(SourceCodeT&& value) {
    m_sourceCodeHasBeenSet = true;
    m_sourceCode = std::forward<SourceCodeT>(value);
  }
  template <typename SourceCodeT = Aws::Vector<SourceCodeRepository>>
  PentestJob& WithSourceCode(SourceCodeT&& value) {
    SetSourceCode(std::forward<SourceCodeT>(value));
    return *this;
  }
  template <typename SourceCodeT = SourceCodeRepository>
  PentestJob& AddSourceCode(SourceCodeT&& value) {
    m_sourceCodeHasBeenSet = true;
    m_sourceCode.emplace_back(std::forward<SourceCodeT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Endpoint>& GetExcludePaths() const { return m_excludePaths; }
  inline bool ExcludePathsHasBeenSet() const { return m_excludePathsHasBeenSet; }
  template <typename ExcludePathsT = Aws::Vector<Endpoint>>
  void SetExcludePaths(ExcludePathsT&& value) {
    m_excludePathsHasBeenSet = true;
    m_excludePaths = std::forward<ExcludePathsT>(value);
  }
  template <typename ExcludePathsT = Aws::Vector<Endpoint>>
  PentestJob& WithExcludePaths(ExcludePathsT&& value) {
    SetExcludePaths(std::forward<ExcludePathsT>(value));
    return *this;
  }
  template <typename ExcludePathsT = Endpoint>
  PentestJob& AddExcludePaths(ExcludePathsT&& value) {
    m_excludePathsHasBeenSet = true;
    m_excludePaths.emplace_back(std::forward<ExcludePathsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Endpoint>& GetAllowedDomains() const { return m_allowedDomains; }
  inline bool AllowedDomainsHasBeenSet() const { return m_allowedDomainsHasBeenSet; }
  template <typename AllowedDomainsT = Aws::Vector<Endpoint>>
  void SetAllowedDomains(AllowedDomainsT&& value) {
    m_allowedDomainsHasBeenSet = true;
    m_allowedDomains = std::forward<AllowedDomainsT>(value);
  }
  template <typename AllowedDomainsT = Aws::Vector<Endpoint>>
  PentestJob& WithAllowedDomains(AllowedDomainsT&& value) {
    SetAllowedDomains(std::forward<AllowedDomainsT>(value));
    return *this;
  }
  template <typename AllowedDomainsT = Endpoint>
  PentestJob& AddAllowedDomains(AllowedDomainsT&& value) {
    m_allowedDomainsHasBeenSet = true;
    m_allowedDomains.emplace_back(std::forward<AllowedDomainsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<RiskType>& GetExcludeRiskTypes() const { return m_excludeRiskTypes; }
  inline bool ExcludeRiskTypesHasBeenSet() const { return m_excludeRiskTypesHasBeenSet; }
  template <typename ExcludeRiskTypesT = Aws::Vector<RiskType>>
  void SetExcludeRiskTypes(ExcludeRiskTypesT&& value) {
    m_excludeRiskTypesHasBeenSet = true;
    m_excludeRiskTypes = std::forward<ExcludeRiskTypesT>(value);
  }
  template <typename ExcludeRiskTypesT = Aws::Vector<RiskType>>
  PentestJob& WithExcludeRiskTypes(ExcludeRiskTypesT&& value) {
    SetExcludeRiskTypes(std::forward<ExcludeRiskTypesT>(value));
    return *this;
  }
  inline PentestJob& AddExcludeRiskTypes(RiskType value) {
    m_excludeRiskTypesHasBeenSet = true;
    m_excludeRiskTypes.push_back(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Step>& GetSteps() const { return m_steps; }
  inline bool StepsHasBeenSet() const { return m_stepsHasBeenSet; }
  template <typename StepsT = Aws::Vector<Step>>
  void SetSteps(StepsT&& value) {
    m_stepsHasBeenSet = true;
    m_steps = std::forward<StepsT>(value);
  }
  template <typename StepsT = Aws::Vector<Step>>
  PentestJob& WithSteps(StepsT&& value) {
    SetSteps(std::forward<StepsT>(value));
    return *this;
  }
  template <typename StepsT = Step>
  PentestJob& AddSteps(StepsT&& value) {
    m_stepsHasBeenSet = true;
    m_steps.emplace_back(std::forward<StepsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ExecutionContext>& GetExecutionContext() const { return m_executionContext; }
  inline bool ExecutionContextHasBeenSet() const { return m_executionContextHasBeenSet; }
  template <typename ExecutionContextT = Aws::Vector<ExecutionContext>>
  void SetExecutionContext(ExecutionContextT&& value) {
    m_executionContextHasBeenSet = true;
    m_executionContext = std::forward<ExecutionContextT>(value);
  }
  template <typename ExecutionContextT = Aws::Vector<ExecutionContext>>
  PentestJob& WithExecutionContext(ExecutionContextT&& value) {
    SetExecutionContext(std::forward<ExecutionContextT>(value));
    return *this;
  }
  template <typename ExecutionContextT = ExecutionContext>
  PentestJob& AddExecutionContext(ExecutionContextT&& value) {
    m_executionContextHasBeenSet = true;
    m_executionContext.emplace_back(std::forward<ExecutionContextT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetServiceRole() const { return m_serviceRole; }
  inline bool ServiceRoleHasBeenSet() const { return m_serviceRoleHasBeenSet; }
  template <typename ServiceRoleT = Aws::String>
  void SetServiceRole(ServiceRoleT&& value) {
    m_serviceRoleHasBeenSet = true;
    m_serviceRole = std::forward<ServiceRoleT>(value);
  }
  template <typename ServiceRoleT = Aws::String>
  PentestJob& WithServiceRole(ServiceRoleT&& value) {
    SetServiceRole(std::forward<ServiceRoleT>(value));
    return *this;
  }
 
 
  inline const CloudWatchLog& GetLogConfig() const { return m_logConfig; }
  inline bool LogConfigHasBeenSet() const { return m_logConfigHasBeenSet; }
  template <typename LogConfigT = CloudWatchLog>
  void SetLogConfig(LogConfigT&& value) {
    m_logConfigHasBeenSet = true;
    m_logConfig = std::forward<LogConfigT>(value);
  }
  template <typename LogConfigT = CloudWatchLog>
  PentestJob& WithLogConfig(LogConfigT&& value) {
    SetLogConfig(std::forward<LogConfigT>(value));
    return *this;
  }
 
 
  inline const VpcConfig& GetVpcConfig() const { return m_vpcConfig; }
  inline bool VpcConfigHasBeenSet() const { return m_vpcConfigHasBeenSet; }
  template <typename VpcConfigT = VpcConfig>
  void SetVpcConfig(VpcConfigT&& value) {
    m_vpcConfigHasBeenSet = true;
    m_vpcConfig = std::forward<VpcConfigT>(value);
  }
  template <typename VpcConfigT = VpcConfig>
  PentestJob& WithVpcConfig(VpcConfigT&& value) {
    SetVpcConfig(std::forward<VpcConfigT>(value));
    return *this;
  }
 
 
  inline const NetworkTrafficConfig& GetNetworkTrafficConfig() const { return m_networkTrafficConfig; }
  inline bool NetworkTrafficConfigHasBeenSet() const { return m_networkTrafficConfigHasBeenSet; }
  template <typename NetworkTrafficConfigT = NetworkTrafficConfig>
  void SetNetworkTrafficConfig(NetworkTrafficConfigT&& value) {
    m_networkTrafficConfigHasBeenSet = true;
    m_networkTrafficConfig = std::forward<NetworkTrafficConfigT>(value);
  }
  template <typename NetworkTrafficConfigT = NetworkTrafficConfig>
  PentestJob& WithNetworkTrafficConfig(NetworkTrafficConfigT&& value) {
    SetNetworkTrafficConfig(std::forward<NetworkTrafficConfigT>(value));
    return *this;
  }
 
 
  inline const ErrorInformation& GetErrorInformation() const { return m_errorInformation; }
  inline bool ErrorInformationHasBeenSet() const { return m_errorInformationHasBeenSet; }
  template <typename ErrorInformationT = ErrorInformation>
  void SetErrorInformation(ErrorInformationT&& value) {
    m_errorInformationHasBeenSet = true;
    m_errorInformation = std::forward<ErrorInformationT>(value);
  }
  template <typename ErrorInformationT = ErrorInformation>
  PentestJob& WithErrorInformation(ErrorInformationT&& value) {
    SetErrorInformation(std::forward<ErrorInformationT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<IntegratedRepository>& GetIntegratedRepositories() const { return m_integratedRepositories; }
  inline bool IntegratedRepositoriesHasBeenSet() const { return m_integratedRepositoriesHasBeenSet; }
  template <typename IntegratedRepositoriesT = Aws::Vector<IntegratedRepository>>
  void SetIntegratedRepositories(IntegratedRepositoriesT&& value) {
    m_integratedRepositoriesHasBeenSet = true;
    m_integratedRepositories = std::forward<IntegratedRepositoriesT>(value);
  }
  template <typename IntegratedRepositoriesT = Aws::Vector<IntegratedRepository>>
  PentestJob& WithIntegratedRepositories(IntegratedRepositoriesT&& value) {
    SetIntegratedRepositories(std::forward<IntegratedRepositoriesT>(value));
    return *this;
  }
  template <typename IntegratedRepositoriesT = IntegratedRepository>
  PentestJob& AddIntegratedRepositories(IntegratedRepositoriesT&& value) {
    m_integratedRepositoriesHasBeenSet = true;
    m_integratedRepositories.emplace_back(std::forward<IntegratedRepositoriesT>(value));
    return *this;
  }
 
 
  inline CodeRemediationStrategy GetCodeRemediationStrategy() const { return m_codeRemediationStrategy; }
  inline bool CodeRemediationStrategyHasBeenSet() const { return m_codeRemediationStrategyHasBeenSet; }
  inline void SetCodeRemediationStrategy(CodeRemediationStrategy value) {
    m_codeRemediationStrategyHasBeenSet = true;
    m_codeRemediationStrategy = value;
  }
  inline PentestJob& WithCodeRemediationStrategy(CodeRemediationStrategy value) {
    SetCodeRemediationStrategy(value);
    return *this;
  }
 
 
  inline CleanUpStrategy GetCleanUpStrategy() const { return m_cleanUpStrategy; }
  inline bool CleanUpStrategyHasBeenSet() const { return m_cleanUpStrategyHasBeenSet; }
  inline void SetCleanUpStrategy(CleanUpStrategy value) {
    m_cleanUpStrategyHasBeenSet = true;
    m_cleanUpStrategy = value;
  }
  inline PentestJob& WithCleanUpStrategy(CleanUpStrategy value) {
    SetCleanUpStrategy(value);
    return *this;
  }
 
 
  inline const Aws::Vector<SkillType>& GetDisableManagedSkills() const { return m_disableManagedSkills; }
  inline bool DisableManagedSkillsHasBeenSet() const { return m_disableManagedSkillsHasBeenSet; }
  template <typename DisableManagedSkillsT = Aws::Vector<SkillType>>
  void SetDisableManagedSkills(DisableManagedSkillsT&& value) {
    m_disableManagedSkillsHasBeenSet = true;
    m_disableManagedSkills = std::forward<DisableManagedSkillsT>(value);
  }
  template <typename DisableManagedSkillsT = Aws::Vector<SkillType>>
  PentestJob& WithDisableManagedSkills(DisableManagedSkillsT&& value) {
    SetDisableManagedSkills(std::forward<DisableManagedSkillsT>(value));
    return *this;
  }
  inline PentestJob& AddDisableManagedSkills(SkillType value) {
    m_disableManagedSkillsHasBeenSet = true;
    m_disableManagedSkills.push_back(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreatedAt() const { return m_createdAt; }
  inline bool CreatedAtHasBeenSet() const { return m_createdAtHasBeenSet; }
  template <typename CreatedAtT = Aws::Utils::DateTime>
  void SetCreatedAt(CreatedAtT&& value) {
    m_createdAtHasBeenSet = true;
    m_createdAt = std::forward<CreatedAtT>(value);
  }
  template <typename CreatedAtT = Aws::Utils::DateTime>
  PentestJob& WithCreatedAt(CreatedAtT&& value) {
    SetCreatedAt(std::forward<CreatedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetUpdatedAt() const { return m_updatedAt; }
  inline bool UpdatedAtHasBeenSet() const { return m_updatedAtHasBeenSet; }
  template <typename UpdatedAtT = Aws::Utils::DateTime>
  void SetUpdatedAt(UpdatedAtT&& value) {
    m_updatedAtHasBeenSet = true;
    m_updatedAt = std::forward<UpdatedAtT>(value);
  }
  template <typename UpdatedAtT = Aws::Utils::DateTime>
  PentestJob& WithUpdatedAt(UpdatedAtT&& value) {
    SetUpdatedAt(std::forward<UpdatedAtT>(value));
    return *this;
  }
 private:
  Aws::String m_pentestJobId;
 
  Aws::String m_pentestId;
 
  Aws::String m_title;
 
  Aws::String m_overview;
 
  JobStatus m_status{JobStatus::NOT_SET};
 
  Aws::Vector<Endpoint> m_endpoints;
 
  Aws::Vector<Actor> m_actors;
 
  Aws::Vector<DocumentInfo> m_documents;
 
  Aws::Vector<SourceCodeRepository> m_sourceCode;
 
  Aws::Vector<Endpoint> m_excludePaths;
 
  Aws::Vector<Endpoint> m_allowedDomains;
 
  Aws::Vector<RiskType> m_excludeRiskTypes;
 
  Aws::Vector<Step> m_steps;
 
  Aws::Vector<ExecutionContext> m_executionContext;
 
  Aws::String m_serviceRole;
 
  CloudWatchLog m_logConfig;
 
  VpcConfig m_vpcConfig;
 
  NetworkTrafficConfig m_networkTrafficConfig;
 
  ErrorInformation m_errorInformation;
 
  Aws::Vector<IntegratedRepository> m_integratedRepositories;
 
  CodeRemediationStrategy m_codeRemediationStrategy{CodeRemediationStrategy::NOT_SET};
 
  CleanUpStrategy m_cleanUpStrategy{CleanUpStrategy::NOT_SET};
 
  Aws::Vector<SkillType> m_disableManagedSkills;
 
  Aws::Utils::DateTime m_createdAt{};
 
  Aws::Utils::DateTime m_updatedAt{};
  bool m_pentestJobIdHasBeenSet = false;
  bool m_pentestIdHasBeenSet = false;
  bool m_titleHasBeenSet = false;
  bool m_overviewHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_endpointsHasBeenSet = false;
  bool m_actorsHasBeenSet = false;
  bool m_documentsHasBeenSet = false;
  bool m_sourceCodeHasBeenSet = false;
  bool m_excludePathsHasBeenSet = false;
  bool m_allowedDomainsHasBeenSet = false;
  bool m_excludeRiskTypesHasBeenSet = false;
  bool m_stepsHasBeenSet = false;
  bool m_executionContextHasBeenSet = false;
  bool m_serviceRoleHasBeenSet = false;
  bool m_logConfigHasBeenSet = false;
  bool m_vpcConfigHasBeenSet = false;
  bool m_networkTrafficConfigHasBeenSet = false;
  bool m_errorInformationHasBeenSet = false;
  bool m_integratedRepositoriesHasBeenSet = false;
  bool m_codeRemediationStrategyHasBeenSet = false;
  bool m_cleanUpStrategyHasBeenSet = false;
  bool m_disableManagedSkillsHasBeenSet = false;
  bool m_createdAtHasBeenSet = false;
  bool m_updatedAtHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SecurityAgent
}  // namespace Aws