EventLogEntry.h

 
#pragma once
#include <aws/codecatalyst/CodeCatalyst_EXPORTS.h>
#include <aws/codecatalyst/model/EventPayload.h>
#include <aws/codecatalyst/model/OperationType.h>
#include <aws/codecatalyst/model/ProjectInformation.h>
#include <aws/codecatalyst/model/UserIdentity.h>
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace CodeCatalyst {
namespace Model {
 
class EventLogEntry {
 public:
  AWS_CODECATALYST_API EventLogEntry() = default;
  AWS_CODECATALYST_API EventLogEntry(Aws::Utils::Json::JsonView jsonValue);
  AWS_CODECATALYST_API EventLogEntry& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_CODECATALYST_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetId() const { return m_id; }
  inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
  template <typename IdT = Aws::String>
  void SetId(IdT&& value) {
    m_idHasBeenSet = true;
    m_id = std::forward<IdT>(value);
  }
  template <typename IdT = Aws::String>
  EventLogEntry& WithId(IdT&& value) {
    SetId(std::forward<IdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEventName() const { return m_eventName; }
  inline bool EventNameHasBeenSet() const { return m_eventNameHasBeenSet; }
  template <typename EventNameT = Aws::String>
  void SetEventName(EventNameT&& value) {
    m_eventNameHasBeenSet = true;
    m_eventName = std::forward<EventNameT>(value);
  }
  template <typename EventNameT = Aws::String>
  EventLogEntry& WithEventName(EventNameT&& value) {
    SetEventName(std::forward<EventNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEventType() const { return m_eventType; }
  inline bool EventTypeHasBeenSet() const { return m_eventTypeHasBeenSet; }
  template <typename EventTypeT = Aws::String>
  void SetEventType(EventTypeT&& value) {
    m_eventTypeHasBeenSet = true;
    m_eventType = std::forward<EventTypeT>(value);
  }
  template <typename EventTypeT = Aws::String>
  EventLogEntry& WithEventType(EventTypeT&& value) {
    SetEventType(std::forward<EventTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEventCategory() const { return m_eventCategory; }
  inline bool EventCategoryHasBeenSet() const { return m_eventCategoryHasBeenSet; }
  template <typename EventCategoryT = Aws::String>
  void SetEventCategory(EventCategoryT&& value) {
    m_eventCategoryHasBeenSet = true;
    m_eventCategory = std::forward<EventCategoryT>(value);
  }
  template <typename EventCategoryT = Aws::String>
  EventLogEntry& WithEventCategory(EventCategoryT&& value) {
    SetEventCategory(std::forward<EventCategoryT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEventSource() const { return m_eventSource; }
  inline bool EventSourceHasBeenSet() const { return m_eventSourceHasBeenSet; }
  template <typename EventSourceT = Aws::String>
  void SetEventSource(EventSourceT&& value) {
    m_eventSourceHasBeenSet = true;
    m_eventSource = std::forward<EventSourceT>(value);
  }
  template <typename EventSourceT = Aws::String>
  EventLogEntry& WithEventSource(EventSourceT&& value) {
    SetEventSource(std::forward<EventSourceT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetEventTime() const { return m_eventTime; }
  inline bool EventTimeHasBeenSet() const { return m_eventTimeHasBeenSet; }
  template <typename EventTimeT = Aws::Utils::DateTime>
  void SetEventTime(EventTimeT&& value) {
    m_eventTimeHasBeenSet = true;
    m_eventTime = std::forward<EventTimeT>(value);
  }
  template <typename EventTimeT = Aws::Utils::DateTime>
  EventLogEntry& WithEventTime(EventTimeT&& value) {
    SetEventTime(std::forward<EventTimeT>(value));
    return *this;
  }
 
 
  inline OperationType GetOperationType() const { return m_operationType; }
  inline bool OperationTypeHasBeenSet() const { return m_operationTypeHasBeenSet; }
  inline void SetOperationType(OperationType value) {
    m_operationTypeHasBeenSet = true;
    m_operationType = value;
  }
  inline EventLogEntry& WithOperationType(OperationType value) {
    SetOperationType(value);
    return *this;
  }
 
 
  inline const UserIdentity& GetUserIdentity() const { return m_userIdentity; }
  inline bool UserIdentityHasBeenSet() const { return m_userIdentityHasBeenSet; }
  template <typename UserIdentityT = UserIdentity>
  void SetUserIdentity(UserIdentityT&& value) {
    m_userIdentityHasBeenSet = true;
    m_userIdentity = std::forward<UserIdentityT>(value);
  }
  template <typename UserIdentityT = UserIdentity>
  EventLogEntry& WithUserIdentity(UserIdentityT&& value) {
    SetUserIdentity(std::forward<UserIdentityT>(value));
    return *this;
  }
 
 
  inline const ProjectInformation& GetProjectInformation() const { return m_projectInformation; }
  inline bool ProjectInformationHasBeenSet() const { return m_projectInformationHasBeenSet; }
  template <typename ProjectInformationT = ProjectInformation>
  void SetProjectInformation(ProjectInformationT&& value) {
    m_projectInformationHasBeenSet = true;
    m_projectInformation = std::forward<ProjectInformationT>(value);
  }
  template <typename ProjectInformationT = ProjectInformation>
  EventLogEntry& WithProjectInformation(ProjectInformationT&& value) {
    SetProjectInformation(std::forward<ProjectInformationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRequestId() const { return m_requestId; }
  inline bool RequestIdHasBeenSet() const { return m_requestIdHasBeenSet; }
  template <typename RequestIdT = Aws::String>
  void SetRequestId(RequestIdT&& value) {
    m_requestIdHasBeenSet = true;
    m_requestId = std::forward<RequestIdT>(value);
  }
  template <typename RequestIdT = Aws::String>
  EventLogEntry& WithRequestId(RequestIdT&& value) {
    SetRequestId(std::forward<RequestIdT>(value));
    return *this;
  }
 
 
  inline const EventPayload& GetRequestPayload() const { return m_requestPayload; }
  inline bool RequestPayloadHasBeenSet() const { return m_requestPayloadHasBeenSet; }
  template <typename RequestPayloadT = EventPayload>
  void SetRequestPayload(RequestPayloadT&& value) {
    m_requestPayloadHasBeenSet = true;
    m_requestPayload = std::forward<RequestPayloadT>(value);
  }
  template <typename RequestPayloadT = EventPayload>
  EventLogEntry& WithRequestPayload(RequestPayloadT&& value) {
    SetRequestPayload(std::forward<RequestPayloadT>(value));
    return *this;
  }
 
 
  inline const EventPayload& GetResponsePayload() const { return m_responsePayload; }
  inline bool ResponsePayloadHasBeenSet() const { return m_responsePayloadHasBeenSet; }
  template <typename ResponsePayloadT = EventPayload>
  void SetResponsePayload(ResponsePayloadT&& value) {
    m_responsePayloadHasBeenSet = true;
    m_responsePayload = std::forward<ResponsePayloadT>(value);
  }
  template <typename ResponsePayloadT = EventPayload>
  EventLogEntry& WithResponsePayload(ResponsePayloadT&& value) {
    SetResponsePayload(std::forward<ResponsePayloadT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetErrorCode() const { return m_errorCode; }
  inline bool ErrorCodeHasBeenSet() const { return m_errorCodeHasBeenSet; }
  template <typename ErrorCodeT = Aws::String>
  void SetErrorCode(ErrorCodeT&& value) {
    m_errorCodeHasBeenSet = true;
    m_errorCode = std::forward<ErrorCodeT>(value);
  }
  template <typename ErrorCodeT = Aws::String>
  EventLogEntry& WithErrorCode(ErrorCodeT&& value) {
    SetErrorCode(std::forward<ErrorCodeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSourceIpAddress() const { return m_sourceIpAddress; }
  inline bool SourceIpAddressHasBeenSet() const { return m_sourceIpAddressHasBeenSet; }
  template <typename SourceIpAddressT = Aws::String>
  void SetSourceIpAddress(SourceIpAddressT&& value) {
    m_sourceIpAddressHasBeenSet = true;
    m_sourceIpAddress = std::forward<SourceIpAddressT>(value);
  }
  template <typename SourceIpAddressT = Aws::String>
  EventLogEntry& WithSourceIpAddress(SourceIpAddressT&& value) {
    SetSourceIpAddress(std::forward<SourceIpAddressT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetUserAgent() const { return m_userAgent; }
  inline bool UserAgentHasBeenSet() const { return m_userAgentHasBeenSet; }
  template <typename UserAgentT = Aws::String>
  void SetUserAgent(UserAgentT&& value) {
    m_userAgentHasBeenSet = true;
    m_userAgent = std::forward<UserAgentT>(value);
  }
  template <typename UserAgentT = Aws::String>
  EventLogEntry& WithUserAgent(UserAgentT&& value) {
    SetUserAgent(std::forward<UserAgentT>(value));
    return *this;
  }
 private:
  Aws::String m_id;
 
  Aws::String m_eventName;
 
  Aws::String m_eventType;
 
  Aws::String m_eventCategory;
 
  Aws::String m_eventSource;
 
  Aws::Utils::DateTime m_eventTime{};
 
  OperationType m_operationType{OperationType::NOT_SET};
 
  UserIdentity m_userIdentity;
 
  ProjectInformation m_projectInformation;
 
  Aws::String m_requestId;
 
  EventPayload m_requestPayload;
 
  EventPayload m_responsePayload;
 
  Aws::String m_errorCode;
 
  Aws::String m_sourceIpAddress;
 
  Aws::String m_userAgent;
  bool m_idHasBeenSet = false;
  bool m_eventNameHasBeenSet = false;
  bool m_eventTypeHasBeenSet = false;
  bool m_eventCategoryHasBeenSet = false;
  bool m_eventSourceHasBeenSet = false;
  bool m_eventTimeHasBeenSet = false;
  bool m_operationTypeHasBeenSet = false;
  bool m_userIdentityHasBeenSet = false;
  bool m_projectInformationHasBeenSet = false;
  bool m_requestIdHasBeenSet = false;
  bool m_requestPayloadHasBeenSet = false;
  bool m_responsePayloadHasBeenSet = false;
  bool m_errorCodeHasBeenSet = false;
  bool m_sourceIpAddressHasBeenSet = false;
  bool m_userAgentHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CodeCatalyst
}  // namespace Aws