ImportTask.h

 
#pragma once
#include <aws/discovery/ApplicationDiscoveryService_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/discovery/model/ImportStatus.h>
#include <aws/core/utils/DateTime.h>
#include <aws/discovery/model/FileClassification.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace ApplicationDiscoveryService
{
namespace Model
{
 
  class ImportTask
  {
  public:
    AWS_APPLICATIONDISCOVERYSERVICE_API ImportTask() = default;
    AWS_APPLICATIONDISCOVERYSERVICE_API ImportTask(Aws::Utils::Json::JsonView jsonValue);
    AWS_APPLICATIONDISCOVERYSERVICE_API ImportTask& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_APPLICATIONDISCOVERYSERVICE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const Aws::String& GetImportTaskId() const { return m_importTaskId; }
    inline bool ImportTaskIdHasBeenSet() const { return m_importTaskIdHasBeenSet; }
    template<typename ImportTaskIdT = Aws::String>
    void SetImportTaskId(ImportTaskIdT&& value) { m_importTaskIdHasBeenSet = true; m_importTaskId = std::forward<ImportTaskIdT>(value); }
    template<typename ImportTaskIdT = Aws::String>
    ImportTask& WithImportTaskId(ImportTaskIdT&& value) { SetImportTaskId(std::forward<ImportTaskIdT>(value)); return *this;}
 
 
    inline const Aws::String& GetClientRequestToken() const { return m_clientRequestToken; }
    inline bool ClientRequestTokenHasBeenSet() const { return m_clientRequestTokenHasBeenSet; }
    template<typename ClientRequestTokenT = Aws::String>
    void SetClientRequestToken(ClientRequestTokenT&& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = std::forward<ClientRequestTokenT>(value); }
    template<typename ClientRequestTokenT = Aws::String>
    ImportTask& WithClientRequestToken(ClientRequestTokenT&& value) { SetClientRequestToken(std::forward<ClientRequestTokenT>(value)); return *this;}
 
 
    inline const Aws::String& GetName() const { return m_name; }
    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
    template<typename NameT = Aws::String>
    void SetName(NameT&& value) { m_nameHasBeenSet = true; m_name = std::forward<NameT>(value); }
    template<typename NameT = Aws::String>
    ImportTask& WithName(NameT&& value) { SetName(std::forward<NameT>(value)); return *this;}
 
 
    inline const Aws::String& GetImportUrl() const { return m_importUrl; }
    inline bool ImportUrlHasBeenSet() const { return m_importUrlHasBeenSet; }
    template<typename ImportUrlT = Aws::String>
    void SetImportUrl(ImportUrlT&& value) { m_importUrlHasBeenSet = true; m_importUrl = std::forward<ImportUrlT>(value); }
    template<typename ImportUrlT = Aws::String>
    ImportTask& WithImportUrl(ImportUrlT&& value) { SetImportUrl(std::forward<ImportUrlT>(value)); return *this;}
 
 
    inline ImportStatus GetStatus() const { return m_status; }
    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
    inline void SetStatus(ImportStatus value) { m_statusHasBeenSet = true; m_status = value; }
    inline ImportTask& WithStatus(ImportStatus value) { SetStatus(value); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetImportRequestTime() const { return m_importRequestTime; }
    inline bool ImportRequestTimeHasBeenSet() const { return m_importRequestTimeHasBeenSet; }
    template<typename ImportRequestTimeT = Aws::Utils::DateTime>
    void SetImportRequestTime(ImportRequestTimeT&& value) { m_importRequestTimeHasBeenSet = true; m_importRequestTime = std::forward<ImportRequestTimeT>(value); }
    template<typename ImportRequestTimeT = Aws::Utils::DateTime>
    ImportTask& WithImportRequestTime(ImportRequestTimeT&& value) { SetImportRequestTime(std::forward<ImportRequestTimeT>(value)); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetImportCompletionTime() const { return m_importCompletionTime; }
    inline bool ImportCompletionTimeHasBeenSet() const { return m_importCompletionTimeHasBeenSet; }
    template<typename ImportCompletionTimeT = Aws::Utils::DateTime>
    void SetImportCompletionTime(ImportCompletionTimeT&& value) { m_importCompletionTimeHasBeenSet = true; m_importCompletionTime = std::forward<ImportCompletionTimeT>(value); }
    template<typename ImportCompletionTimeT = Aws::Utils::DateTime>
    ImportTask& WithImportCompletionTime(ImportCompletionTimeT&& value) { SetImportCompletionTime(std::forward<ImportCompletionTimeT>(value)); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetImportDeletedTime() const { return m_importDeletedTime; }
    inline bool ImportDeletedTimeHasBeenSet() const { return m_importDeletedTimeHasBeenSet; }
    template<typename ImportDeletedTimeT = Aws::Utils::DateTime>
    void SetImportDeletedTime(ImportDeletedTimeT&& value) { m_importDeletedTimeHasBeenSet = true; m_importDeletedTime = std::forward<ImportDeletedTimeT>(value); }
    template<typename ImportDeletedTimeT = Aws::Utils::DateTime>
    ImportTask& WithImportDeletedTime(ImportDeletedTimeT&& value) { SetImportDeletedTime(std::forward<ImportDeletedTimeT>(value)); return *this;}
 
 
    inline FileClassification GetFileClassification() const { return m_fileClassification; }
    inline bool FileClassificationHasBeenSet() const { return m_fileClassificationHasBeenSet; }
    inline void SetFileClassification(FileClassification value) { m_fileClassificationHasBeenSet = true; m_fileClassification = value; }
    inline ImportTask& WithFileClassification(FileClassification value) { SetFileClassification(value); return *this;}
 
 
    inline int GetServerImportSuccess() const { return m_serverImportSuccess; }
    inline bool ServerImportSuccessHasBeenSet() const { return m_serverImportSuccessHasBeenSet; }
    inline void SetServerImportSuccess(int value) { m_serverImportSuccessHasBeenSet = true; m_serverImportSuccess = value; }
    inline ImportTask& WithServerImportSuccess(int value) { SetServerImportSuccess(value); return *this;}
 
 
    inline int GetServerImportFailure() const { return m_serverImportFailure; }
    inline bool ServerImportFailureHasBeenSet() const { return m_serverImportFailureHasBeenSet; }
    inline void SetServerImportFailure(int value) { m_serverImportFailureHasBeenSet = true; m_serverImportFailure = value; }
    inline ImportTask& WithServerImportFailure(int value) { SetServerImportFailure(value); return *this;}
 
 
    inline int GetApplicationImportSuccess() const { return m_applicationImportSuccess; }
    inline bool ApplicationImportSuccessHasBeenSet() const { return m_applicationImportSuccessHasBeenSet; }
    inline void SetApplicationImportSuccess(int value) { m_applicationImportSuccessHasBeenSet = true; m_applicationImportSuccess = value; }
    inline ImportTask& WithApplicationImportSuccess(int value) { SetApplicationImportSuccess(value); return *this;}
 
 
    inline int GetApplicationImportFailure() const { return m_applicationImportFailure; }
    inline bool ApplicationImportFailureHasBeenSet() const { return m_applicationImportFailureHasBeenSet; }
    inline void SetApplicationImportFailure(int value) { m_applicationImportFailureHasBeenSet = true; m_applicationImportFailure = value; }
    inline ImportTask& WithApplicationImportFailure(int value) { SetApplicationImportFailure(value); return *this;}
 
 
    inline const Aws::String& GetErrorsAndFailedEntriesZip() const { return m_errorsAndFailedEntriesZip; }
    inline bool ErrorsAndFailedEntriesZipHasBeenSet() const { return m_errorsAndFailedEntriesZipHasBeenSet; }
    template<typename ErrorsAndFailedEntriesZipT = Aws::String>
    void SetErrorsAndFailedEntriesZip(ErrorsAndFailedEntriesZipT&& value) { m_errorsAndFailedEntriesZipHasBeenSet = true; m_errorsAndFailedEntriesZip = std::forward<ErrorsAndFailedEntriesZipT>(value); }
    template<typename ErrorsAndFailedEntriesZipT = Aws::String>
    ImportTask& WithErrorsAndFailedEntriesZip(ErrorsAndFailedEntriesZipT&& value) { SetErrorsAndFailedEntriesZip(std::forward<ErrorsAndFailedEntriesZipT>(value)); return *this;}
  private:
 
    Aws::String m_importTaskId;
    bool m_importTaskIdHasBeenSet = false;
 
    Aws::String m_clientRequestToken;
    bool m_clientRequestTokenHasBeenSet = false;
 
    Aws::String m_name;
    bool m_nameHasBeenSet = false;
 
    Aws::String m_importUrl;
    bool m_importUrlHasBeenSet = false;
 
    ImportStatus m_status{ImportStatus::NOT_SET};
    bool m_statusHasBeenSet = false;
 
    Aws::Utils::DateTime m_importRequestTime{};
    bool m_importRequestTimeHasBeenSet = false;
 
    Aws::Utils::DateTime m_importCompletionTime{};
    bool m_importCompletionTimeHasBeenSet = false;
 
    Aws::Utils::DateTime m_importDeletedTime{};
    bool m_importDeletedTimeHasBeenSet = false;
 
    FileClassification m_fileClassification{FileClassification::NOT_SET};
    bool m_fileClassificationHasBeenSet = false;
 
    int m_serverImportSuccess{0};
    bool m_serverImportSuccessHasBeenSet = false;
 
    int m_serverImportFailure{0};
    bool m_serverImportFailureHasBeenSet = false;
 
    int m_applicationImportSuccess{0};
    bool m_applicationImportSuccessHasBeenSet = false;
 
    int m_applicationImportFailure{0};
    bool m_applicationImportFailureHasBeenSet = false;
 
    Aws::String m_errorsAndFailedEntriesZip;
    bool m_errorsAndFailedEntriesZipHasBeenSet = false;
  };
 
} // namespace Model
} // namespace ApplicationDiscoveryService
} // namespace Aws