CreateHITRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/mturk-requester/MTurkRequest.h>
#include <aws/mturk-requester/MTurk_EXPORTS.h>
#include <aws/mturk-requester/model/HITLayoutParameter.h>
#include <aws/mturk-requester/model/QualificationRequirement.h>
#include <aws/mturk-requester/model/ReviewPolicy.h>
 
#include <utility>
 
namespace Aws {
namespace MTurk {
namespace Model {
 
class CreateHITRequest : public MTurkRequest {
 public:
  AWS_MTURK_API CreateHITRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "CreateHIT"; }
 
  AWS_MTURK_API Aws::String SerializePayload() const override;
 
  AWS_MTURK_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
 
 
  inline int GetMaxAssignments() const { return m_maxAssignments; }
  inline bool MaxAssignmentsHasBeenSet() const { return m_maxAssignmentsHasBeenSet; }
  inline void SetMaxAssignments(int value) {
    m_maxAssignmentsHasBeenSet = true;
    m_maxAssignments = value;
  }
  inline CreateHITRequest& WithMaxAssignments(int value) {
    SetMaxAssignments(value);
    return *this;
  }
 
 
  inline long long GetAutoApprovalDelayInSeconds() const { return m_autoApprovalDelayInSeconds; }
  inline bool AutoApprovalDelayInSecondsHasBeenSet() const { return m_autoApprovalDelayInSecondsHasBeenSet; }
  inline void SetAutoApprovalDelayInSeconds(long long value) {
    m_autoApprovalDelayInSecondsHasBeenSet = true;
    m_autoApprovalDelayInSeconds = value;
  }
  inline CreateHITRequest& WithAutoApprovalDelayInSeconds(long long value) {
    SetAutoApprovalDelayInSeconds(value);
    return *this;
  }
 
 
  inline long long GetLifetimeInSeconds() const { return m_lifetimeInSeconds; }
  inline bool LifetimeInSecondsHasBeenSet() const { return m_lifetimeInSecondsHasBeenSet; }
  inline void SetLifetimeInSeconds(long long value) {
    m_lifetimeInSecondsHasBeenSet = true;
    m_lifetimeInSeconds = value;
  }
  inline CreateHITRequest& WithLifetimeInSeconds(long long value) {
    SetLifetimeInSeconds(value);
    return *this;
  }
 
 
  inline long long GetAssignmentDurationInSeconds() const { return m_assignmentDurationInSeconds; }
  inline bool AssignmentDurationInSecondsHasBeenSet() const { return m_assignmentDurationInSecondsHasBeenSet; }
  inline void SetAssignmentDurationInSeconds(long long value) {
    m_assignmentDurationInSecondsHasBeenSet = true;
    m_assignmentDurationInSeconds = value;
  }
  inline CreateHITRequest& WithAssignmentDurationInSeconds(long long value) {
    SetAssignmentDurationInSeconds(value);
    return *this;
  }
 
 
  inline const Aws::String& GetReward() const { return m_reward; }
  inline bool RewardHasBeenSet() const { return m_rewardHasBeenSet; }
  template <typename RewardT = Aws::String>
  void SetReward(RewardT&& value) {
    m_rewardHasBeenSet = true;
    m_reward = std::forward<RewardT>(value);
  }
  template <typename RewardT = Aws::String>
  CreateHITRequest& WithReward(RewardT&& value) {
    SetReward(std::forward<RewardT>(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>
  CreateHITRequest& WithTitle(TitleT&& value) {
    SetTitle(std::forward<TitleT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetKeywords() const { return m_keywords; }
  inline bool KeywordsHasBeenSet() const { return m_keywordsHasBeenSet; }
  template <typename KeywordsT = Aws::String>
  void SetKeywords(KeywordsT&& value) {
    m_keywordsHasBeenSet = true;
    m_keywords = std::forward<KeywordsT>(value);
  }
  template <typename KeywordsT = Aws::String>
  CreateHITRequest& WithKeywords(KeywordsT&& value) {
    SetKeywords(std::forward<KeywordsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  CreateHITRequest& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetQuestion() const { return m_question; }
  inline bool QuestionHasBeenSet() const { return m_questionHasBeenSet; }
  template <typename QuestionT = Aws::String>
  void SetQuestion(QuestionT&& value) {
    m_questionHasBeenSet = true;
    m_question = std::forward<QuestionT>(value);
  }
  template <typename QuestionT = Aws::String>
  CreateHITRequest& WithQuestion(QuestionT&& value) {
    SetQuestion(std::forward<QuestionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRequesterAnnotation() const { return m_requesterAnnotation; }
  inline bool RequesterAnnotationHasBeenSet() const { return m_requesterAnnotationHasBeenSet; }
  template <typename RequesterAnnotationT = Aws::String>
  void SetRequesterAnnotation(RequesterAnnotationT&& value) {
    m_requesterAnnotationHasBeenSet = true;
    m_requesterAnnotation = std::forward<RequesterAnnotationT>(value);
  }
  template <typename RequesterAnnotationT = Aws::String>
  CreateHITRequest& WithRequesterAnnotation(RequesterAnnotationT&& value) {
    SetRequesterAnnotation(std::forward<RequesterAnnotationT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<QualificationRequirement>& GetQualificationRequirements() const { return m_qualificationRequirements; }
  inline bool QualificationRequirementsHasBeenSet() const { return m_qualificationRequirementsHasBeenSet; }
  template <typename QualificationRequirementsT = Aws::Vector<QualificationRequirement>>
  void SetQualificationRequirements(QualificationRequirementsT&& value) {
    m_qualificationRequirementsHasBeenSet = true;
    m_qualificationRequirements = std::forward<QualificationRequirementsT>(value);
  }
  template <typename QualificationRequirementsT = Aws::Vector<QualificationRequirement>>
  CreateHITRequest& WithQualificationRequirements(QualificationRequirementsT&& value) {
    SetQualificationRequirements(std::forward<QualificationRequirementsT>(value));
    return *this;
  }
  template <typename QualificationRequirementsT = QualificationRequirement>
  CreateHITRequest& AddQualificationRequirements(QualificationRequirementsT&& value) {
    m_qualificationRequirementsHasBeenSet = true;
    m_qualificationRequirements.emplace_back(std::forward<QualificationRequirementsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetUniqueRequestToken() const { return m_uniqueRequestToken; }
  inline bool UniqueRequestTokenHasBeenSet() const { return m_uniqueRequestTokenHasBeenSet; }
  template <typename UniqueRequestTokenT = Aws::String>
  void SetUniqueRequestToken(UniqueRequestTokenT&& value) {
    m_uniqueRequestTokenHasBeenSet = true;
    m_uniqueRequestToken = std::forward<UniqueRequestTokenT>(value);
  }
  template <typename UniqueRequestTokenT = Aws::String>
  CreateHITRequest& WithUniqueRequestToken(UniqueRequestTokenT&& value) {
    SetUniqueRequestToken(std::forward<UniqueRequestTokenT>(value));
    return *this;
  }
 
 
  inline const ReviewPolicy& GetAssignmentReviewPolicy() const { return m_assignmentReviewPolicy; }
  inline bool AssignmentReviewPolicyHasBeenSet() const { return m_assignmentReviewPolicyHasBeenSet; }
  template <typename AssignmentReviewPolicyT = ReviewPolicy>
  void SetAssignmentReviewPolicy(AssignmentReviewPolicyT&& value) {
    m_assignmentReviewPolicyHasBeenSet = true;
    m_assignmentReviewPolicy = std::forward<AssignmentReviewPolicyT>(value);
  }
  template <typename AssignmentReviewPolicyT = ReviewPolicy>
  CreateHITRequest& WithAssignmentReviewPolicy(AssignmentReviewPolicyT&& value) {
    SetAssignmentReviewPolicy(std::forward<AssignmentReviewPolicyT>(value));
    return *this;
  }
 
 
  inline const ReviewPolicy& GetHITReviewPolicy() const { return m_hITReviewPolicy; }
  inline bool HITReviewPolicyHasBeenSet() const { return m_hITReviewPolicyHasBeenSet; }
  template <typename HITReviewPolicyT = ReviewPolicy>
  void SetHITReviewPolicy(HITReviewPolicyT&& value) {
    m_hITReviewPolicyHasBeenSet = true;
    m_hITReviewPolicy = std::forward<HITReviewPolicyT>(value);
  }
  template <typename HITReviewPolicyT = ReviewPolicy>
  CreateHITRequest& WithHITReviewPolicy(HITReviewPolicyT&& value) {
    SetHITReviewPolicy(std::forward<HITReviewPolicyT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetHITLayoutId() const { return m_hITLayoutId; }
  inline bool HITLayoutIdHasBeenSet() const { return m_hITLayoutIdHasBeenSet; }
  template <typename HITLayoutIdT = Aws::String>
  void SetHITLayoutId(HITLayoutIdT&& value) {
    m_hITLayoutIdHasBeenSet = true;
    m_hITLayoutId = std::forward<HITLayoutIdT>(value);
  }
  template <typename HITLayoutIdT = Aws::String>
  CreateHITRequest& WithHITLayoutId(HITLayoutIdT&& value) {
    SetHITLayoutId(std::forward<HITLayoutIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<HITLayoutParameter>& GetHITLayoutParameters() const { return m_hITLayoutParameters; }
  inline bool HITLayoutParametersHasBeenSet() const { return m_hITLayoutParametersHasBeenSet; }
  template <typename HITLayoutParametersT = Aws::Vector<HITLayoutParameter>>
  void SetHITLayoutParameters(HITLayoutParametersT&& value) {
    m_hITLayoutParametersHasBeenSet = true;
    m_hITLayoutParameters = std::forward<HITLayoutParametersT>(value);
  }
  template <typename HITLayoutParametersT = Aws::Vector<HITLayoutParameter>>
  CreateHITRequest& WithHITLayoutParameters(HITLayoutParametersT&& value) {
    SetHITLayoutParameters(std::forward<HITLayoutParametersT>(value));
    return *this;
  }
  template <typename HITLayoutParametersT = HITLayoutParameter>
  CreateHITRequest& AddHITLayoutParameters(HITLayoutParametersT&& value) {
    m_hITLayoutParametersHasBeenSet = true;
    m_hITLayoutParameters.emplace_back(std::forward<HITLayoutParametersT>(value));
    return *this;
  }
 private:
  int m_maxAssignments{0};
 
  long long m_autoApprovalDelayInSeconds{0};
 
  long long m_lifetimeInSeconds{0};
 
  long long m_assignmentDurationInSeconds{0};
 
  Aws::String m_reward;
 
  Aws::String m_title;
 
  Aws::String m_keywords;
 
  Aws::String m_description;
 
  Aws::String m_question;
 
  Aws::String m_requesterAnnotation;
 
  Aws::Vector<QualificationRequirement> m_qualificationRequirements;
 
  Aws::String m_uniqueRequestToken;
 
  ReviewPolicy m_assignmentReviewPolicy;
 
  ReviewPolicy m_hITReviewPolicy;
 
  Aws::String m_hITLayoutId;
 
  Aws::Vector<HITLayoutParameter> m_hITLayoutParameters;
  bool m_maxAssignmentsHasBeenSet = false;
  bool m_autoApprovalDelayInSecondsHasBeenSet = false;
  bool m_lifetimeInSecondsHasBeenSet = false;
  bool m_assignmentDurationInSecondsHasBeenSet = false;
  bool m_rewardHasBeenSet = false;
  bool m_titleHasBeenSet = false;
  bool m_keywordsHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_questionHasBeenSet = false;
  bool m_requesterAnnotationHasBeenSet = false;
  bool m_qualificationRequirementsHasBeenSet = false;
  bool m_uniqueRequestTokenHasBeenSet = false;
  bool m_assignmentReviewPolicyHasBeenSet = false;
  bool m_hITReviewPolicyHasBeenSet = false;
  bool m_hITLayoutIdHasBeenSet = false;
  bool m_hITLayoutParametersHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MTurk
}  // namespace Aws