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 <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();
    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; }
    inline void SetImportTaskId(const Aws::String& value) { m_importTaskIdHasBeenSet = true; m_importTaskId = value; }
    inline void SetImportTaskId(Aws::String&& value) { m_importTaskIdHasBeenSet = true; m_importTaskId = std::move(value); }
    inline void SetImportTaskId(const char* value) { m_importTaskIdHasBeenSet = true; m_importTaskId.assign(value); }
    inline ImportTask& WithImportTaskId(const Aws::String& value) { SetImportTaskId(value); return *this;}
    inline ImportTask& WithImportTaskId(Aws::String&& value) { SetImportTaskId(std::move(value)); return *this;}
    inline ImportTask& WithImportTaskId(const char* value) { SetImportTaskId(value); return *this;}
 
 
    inline const Aws::String& GetClientRequestToken() const{ return m_clientRequestToken; }
    inline bool ClientRequestTokenHasBeenSet() const { return m_clientRequestTokenHasBeenSet; }
    inline void SetClientRequestToken(const Aws::String& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = value; }
    inline void SetClientRequestToken(Aws::String&& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = std::move(value); }
    inline void SetClientRequestToken(const char* value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken.assign(value); }
    inline ImportTask& WithClientRequestToken(const Aws::String& value) { SetClientRequestToken(value); return *this;}
    inline ImportTask& WithClientRequestToken(Aws::String&& value) { SetClientRequestToken(std::move(value)); return *this;}
    inline ImportTask& WithClientRequestToken(const char* value) { SetClientRequestToken(value); return *this;}
 
 
    inline const Aws::String& GetName() const{ return m_name; }
    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
    inline ImportTask& WithName(const Aws::String& value) { SetName(value); return *this;}
    inline ImportTask& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
    inline ImportTask& WithName(const char* value) { SetName(value); return *this;}
 
 
    inline const Aws::String& GetImportUrl() const{ return m_importUrl; }
    inline bool ImportUrlHasBeenSet() const { return m_importUrlHasBeenSet; }
    inline void SetImportUrl(const Aws::String& value) { m_importUrlHasBeenSet = true; m_importUrl = value; }
    inline void SetImportUrl(Aws::String&& value) { m_importUrlHasBeenSet = true; m_importUrl = std::move(value); }
    inline void SetImportUrl(const char* value) { m_importUrlHasBeenSet = true; m_importUrl.assign(value); }
    inline ImportTask& WithImportUrl(const Aws::String& value) { SetImportUrl(value); return *this;}
    inline ImportTask& WithImportUrl(Aws::String&& value) { SetImportUrl(std::move(value)); return *this;}
    inline ImportTask& WithImportUrl(const char* value) { SetImportUrl(value); return *this;}
 
 
    inline const ImportStatus& GetStatus() const{ return m_status; }
    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
    inline void SetStatus(const ImportStatus& value) { m_statusHasBeenSet = true; m_status = value; }
    inline void SetStatus(ImportStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
    inline ImportTask& WithStatus(const ImportStatus& value) { SetStatus(value); return *this;}
    inline ImportTask& WithStatus(ImportStatus&& value) { SetStatus(std::move(value)); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetImportRequestTime() const{ return m_importRequestTime; }
    inline bool ImportRequestTimeHasBeenSet() const { return m_importRequestTimeHasBeenSet; }
    inline void SetImportRequestTime(const Aws::Utils::DateTime& value) { m_importRequestTimeHasBeenSet = true; m_importRequestTime = value; }
    inline void SetImportRequestTime(Aws::Utils::DateTime&& value) { m_importRequestTimeHasBeenSet = true; m_importRequestTime = std::move(value); }
    inline ImportTask& WithImportRequestTime(const Aws::Utils::DateTime& value) { SetImportRequestTime(value); return *this;}
    inline ImportTask& WithImportRequestTime(Aws::Utils::DateTime&& value) { SetImportRequestTime(std::move(value)); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetImportCompletionTime() const{ return m_importCompletionTime; }
    inline bool ImportCompletionTimeHasBeenSet() const { return m_importCompletionTimeHasBeenSet; }
    inline void SetImportCompletionTime(const Aws::Utils::DateTime& value) { m_importCompletionTimeHasBeenSet = true; m_importCompletionTime = value; }
    inline void SetImportCompletionTime(Aws::Utils::DateTime&& value) { m_importCompletionTimeHasBeenSet = true; m_importCompletionTime = std::move(value); }
    inline ImportTask& WithImportCompletionTime(const Aws::Utils::DateTime& value) { SetImportCompletionTime(value); return *this;}
    inline ImportTask& WithImportCompletionTime(Aws::Utils::DateTime&& value) { SetImportCompletionTime(std::move(value)); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetImportDeletedTime() const{ return m_importDeletedTime; }
    inline bool ImportDeletedTimeHasBeenSet() const { return m_importDeletedTimeHasBeenSet; }
    inline void SetImportDeletedTime(const Aws::Utils::DateTime& value) { m_importDeletedTimeHasBeenSet = true; m_importDeletedTime = value; }
    inline void SetImportDeletedTime(Aws::Utils::DateTime&& value) { m_importDeletedTimeHasBeenSet = true; m_importDeletedTime = std::move(value); }
    inline ImportTask& WithImportDeletedTime(const Aws::Utils::DateTime& value) { SetImportDeletedTime(value); return *this;}
    inline ImportTask& WithImportDeletedTime(Aws::Utils::DateTime&& value) { SetImportDeletedTime(std::move(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; }
    inline void SetErrorsAndFailedEntriesZip(const Aws::String& value) { m_errorsAndFailedEntriesZipHasBeenSet = true; m_errorsAndFailedEntriesZip = value; }
    inline void SetErrorsAndFailedEntriesZip(Aws::String&& value) { m_errorsAndFailedEntriesZipHasBeenSet = true; m_errorsAndFailedEntriesZip = std::move(value); }
    inline void SetErrorsAndFailedEntriesZip(const char* value) { m_errorsAndFailedEntriesZipHasBeenSet = true; m_errorsAndFailedEntriesZip.assign(value); }
    inline ImportTask& WithErrorsAndFailedEntriesZip(const Aws::String& value) { SetErrorsAndFailedEntriesZip(value); return *this;}
    inline ImportTask& WithErrorsAndFailedEntriesZip(Aws::String&& value) { SetErrorsAndFailedEntriesZip(std::move(value)); return *this;}
    inline ImportTask& WithErrorsAndFailedEntriesZip(const char* value) { SetErrorsAndFailedEntriesZip(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;
    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;
 
    int m_serverImportSuccess;
    bool m_serverImportSuccessHasBeenSet = false;
 
    int m_serverImportFailure;
    bool m_serverImportFailureHasBeenSet = false;
 
    int m_applicationImportSuccess;
    bool m_applicationImportSuccessHasBeenSet = false;
 
    int m_applicationImportFailure;
    bool m_applicationImportFailureHasBeenSet = false;
 
    Aws::String m_errorsAndFailedEntriesZip;
    bool m_errorsAndFailedEntriesZipHasBeenSet = false;
  };
 
} // namespace Model
} // namespace ApplicationDiscoveryService
} // namespace Aws