models.hpp

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
 
#pragma once
 
#include "azure/data/tables/dll_import_export.hpp"
#include "azure/data/tables/enum_operators.hpp"
 
#include <azure/core/datetime.hpp>
#include <azure/core/internal/extendable_enumeration.hpp>
#include <azure/core/nullable.hpp>
#include <azure/core/paged_response.hpp>
 
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace Azure { namespace Data { namespace Tables {
  class TableServiceClient;
  class TableClient;
 
  namespace Models {
    struct Table final
    {
      std::string TableName;
      std::string Metadata;
      std::string EditLink;
      std::string Type;
      std::string Id;
    };
 
    enum class QueryTablesIncludeFlags
    {
      None = 0,
      Metadata = 1,
    };
 
    struct QueryTablesOptions final
    {
      Azure::Nullable<std::string> Prefix;
 
      Azure::Nullable<std::string> ContinuationToken;
 
      Azure::Nullable<std::int32_t> PageSizeHint;
 
      Models::QueryTablesIncludeFlags Include = Models::QueryTablesIncludeFlags::None;
    };
 
    class QueryTablesPagedResponse final
        : public Azure::Core::PagedResponse<QueryTablesPagedResponse> {
 
    public:
      std::string ServiceEndpoint;
 
      Azure::Nullable<std::string> Prefix;
 
      std::vector<Models::Table> Tables;
 
      QueryTablesOptions m_operationOptions;
 
    private:
      QueryTablesPagedResponse(std::shared_ptr<TableServiceClient> tableServiceClient)
          : m_tableServiceClient(tableServiceClient){};
 
      friend class Azure::Data::Tables::TableServiceClient;
      friend class Azure::Core::PagedResponse<QueryTablesPagedResponse>;
      std::shared_ptr<TableServiceClient> m_tableServiceClient;
      void OnNextPage(const Azure::Core::Context& context);
    };
 
    struct RetentionPolicy final
    {
      bool IsEnabled = bool();
      Nullable<std::int32_t> DataRetentionInDays;
    };
 
    struct Metrics final
    {
      std::string Version;
      bool IsEnabled = bool();
      Nullable<bool> IncludeApis;
      RetentionPolicy RetentionPolicyDefinition;
    };
 
    struct AnalyticsLogging final
    {
      std::string Version;
      bool Delete = bool();
      bool Read = bool();
      bool Write = bool();
      RetentionPolicy RetentionPolicyDefinition;
    };
 
    struct CorsRule final
    {
      std::string AllowedOrigins;
      std::string AllowedMethods;
      std::string AllowedHeaders;
      std::string ExposedHeaders;
      std::int32_t MaxAgeInSeconds = int32_t();
    };
 
    struct TableServiceProperties final
    {
      AnalyticsLogging Logging;
      Metrics HourMetrics;
      Metrics MinuteMetrics;
      std::vector<CorsRule> Cors;
    };
 
    struct SetServicePropertiesOptions final
    {
      TableServiceProperties ServiceProperties;
    };
 
    struct SetServicePropertiesResult final
    {
    };
 
    struct PreflightCheckResult final
    {
    };
 
    struct PreflightCheckOptions final
    {
      std::string Origin;
      std::string TableName;
    };
 
    class GeoReplicationStatus final {
    public:
      GeoReplicationStatus() = default;
      explicit GeoReplicationStatus(std::string value) : m_value(std::move(value)) {}
      bool operator==(const GeoReplicationStatus& other) const { return m_value == other.m_value; }
      bool operator!=(const GeoReplicationStatus& other) const { return !(*this == other); }
      const std::string& ToString() const { return m_value; }
      AZ_DATA_TABLES_DLLEXPORT const static GeoReplicationStatus Live;
      AZ_DATA_TABLES_DLLEXPORT const static GeoReplicationStatus Bootstrap;
      AZ_DATA_TABLES_DLLEXPORT const static GeoReplicationStatus Unavailable;
 
    private:
      std::string m_value;
    };
 
    class TableEntityDataType final
        : public Azure::Core::_internal::ExtendableEnumeration<TableEntityDataType> {
    public:
      TableEntityDataType() = default;
      explicit TableEntityDataType(std::string tableEntityDataType)
          : ExtendableEnumeration(std::move(tableEntityDataType))
      {
      }
      AZ_DATA_TABLES_DLLEXPORT const static TableEntityDataType EdmBinary;
      AZ_DATA_TABLES_DLLEXPORT const static TableEntityDataType EdmBoolean;
      AZ_DATA_TABLES_DLLEXPORT const static TableEntityDataType EdmDateTime;
      AZ_DATA_TABLES_DLLEXPORT const static TableEntityDataType EdmDouble;
      AZ_DATA_TABLES_DLLEXPORT const static TableEntityDataType EdmGuid;
      AZ_DATA_TABLES_DLLEXPORT const static TableEntityDataType EdmInt32;
      AZ_DATA_TABLES_DLLEXPORT const static TableEntityDataType EdmInt64;
      AZ_DATA_TABLES_DLLEXPORT const static TableEntityDataType EdmString;
    };
 
    struct GeoReplication final
    {
      GeoReplicationStatus Status;
      Nullable<DateTime> LastSyncedOn;
    };
 
    struct ServiceStatistics final
    {
      Models::GeoReplication GeoReplication;
    };
 
    struct DeleteTableResult final
    {
    };
 
    struct SignedIdentifier final
    {
      std::string Id;
      Nullable<DateTime> StartsOn;
      Nullable<DateTime> ExpiresOn;
      std::string Permissions;
    };
 
    struct TableAccessPolicy final
    {
      std::vector<SignedIdentifier> SignedIdentifiers;
    };
 
    struct SetTableAccessPolicyResult final
    {
    };
 
    class TableEntityProperty final {
    public:
      TableEntityProperty() = default;
 
      TableEntityProperty(std::string const& value) : Value(std::move(value)) {}
      TableEntityProperty(std::string const& value, TableEntityDataType type)
          : Value(std::move(value)), Type(type)
      {
      }
      std::string Value;
      Azure::Nullable<TableEntityDataType> Type;
    };
 
    class TableEntity final {
      constexpr static const char* PartitionKeyPropertyName = "PartitionKey";
      constexpr static const char* RowKeyPropertyName = "RowKey";
      constexpr static const char* ETagPropertyName = "odata.etag";
      constexpr static const char* TimestampPropertyName = "Timestamp";
 
    public:
      std::map<std::string, TableEntityProperty> Properties;
 
      TableEntityProperty GetPartitionKey() const { return GetProperty(PartitionKeyPropertyName); }
 
      void SetPartitionKey(const std::string& partitionKey)
      {
        Properties[PartitionKeyPropertyName] = TableEntityProperty(partitionKey);
      }
 
      TableEntityProperty GetRowKey() const { return GetProperty(RowKeyPropertyName); }
      void SetRowKey(const std::string& rowKey)
      {
        Properties[RowKeyPropertyName] = TableEntityProperty(rowKey);
      }
 
      TableEntityProperty GetETag() const { return GetProperty(ETagPropertyName); }
      void SetETag(const std::string& eTag)
      {
        Properties[ETagPropertyName] = TableEntityProperty(eTag);
      }
 
      TableEntityProperty GetTimestamp() const { return GetProperty(TimestampPropertyName); }
      void SetTimestamp(const std::string& timestamp)
      {
        Properties[TimestampPropertyName] = TableEntityProperty(timestamp);
      }
 
    private:
      TableEntityProperty GetProperty(std::string const& name) const
      {
        return Properties.find(name) == Properties.end() ? TableEntityProperty()
                                                         : Properties.at(name);
      }
    };
 
    enum class UpsertKind
    {
      Update,
      Merge,
    };
 
    struct UpsertEntityOptions
    {
      UpsertKind UpsertType = UpsertKind::Update;
    };
    struct AddEntityOptions : public UpsertEntityOptions
    {
      AddEntityOptions() = default;
      explicit AddEntityOptions(UpsertEntityOptions const& other) { (void)other; }
    };
 
    struct AddEntityResult
    {
      std::string ETag;
    };
 
    struct UpdateEntityOptions final
    {
      UpdateEntityOptions() = default;
      UpdateEntityOptions(UpsertEntityOptions const& other) { (void)other; }
    };
 
    struct UpdateEntityResult
    {
      std::string ETag;
    };
 
    struct MergeEntityOptions final
    {
      MergeEntityOptions() = default;
      MergeEntityOptions(UpsertEntityOptions const& other) { (void)other; }
    };
 
    struct MergeEntityResult
    {
      std::string ETag;
    };
 
    struct DeleteEntityResult final
    {
    };
 
    struct UpsertEntityResult final : public MergeEntityResult, UpdateEntityResult, AddEntityResult
    {
      std::string ETag;
      UpsertEntityResult() = default;
      UpsertEntityResult(MergeEntityResult const& other)
          : MergeEntityResult(other), ETag(std::move(other.ETag))
      {
      }
      UpsertEntityResult(UpdateEntityResult const& other)
          : UpdateEntityResult(other), ETag(std::move(other.ETag))
      {
      }
      UpsertEntityResult(AddEntityResult const& other)
          : AddEntityResult(other), ETag(std::move(other.ETag))
      {
      }
    };
 
    struct QueryEntitiesOptions final
    {
      std::string PartitionKey;
      std::string RowKey;
      std::string NextPartitionKey;
      std::string NextRowKey;
      std::string SelectColumns;
      Azure::Nullable<std::string> Filter;
    };
 
    class QueryEntitiesPagedResponse final
        : public Azure::Core::PagedResponse<QueryEntitiesPagedResponse> {
    public:
      std::string NextPartitionKey;
      std::string NextRowKey;
      std::vector<Models::TableEntity> TableEntities;
      QueryEntitiesOptions m_operationOptions;
 
    private:
      QueryEntitiesPagedResponse(std::shared_ptr<TableClient> tableClient)
          : m_tableClient(tableClient){};
 
      std::shared_ptr<TableClient> m_tableClient;
      friend class Azure::Data::Tables::TableClient;
      friend class Azure::Core::PagedResponse<QueryEntitiesPagedResponse>;
 
      void OnNextPage(const Azure::Core::Context& context);
    };
 
    enum class TransactionActionType
    {
      Add,
      UpdateMerge,
      UpdateReplace,
      Delete,
      InsertMerge,
      InsertReplace
    };
 
    struct TransactionStep final
    {
      TransactionActionType Action;
      Models::TableEntity Entity;
    };
 
    struct TransactionError final
    {
      std::string Message;
      std::string Code;
    };
 
    struct SubmitTransactionResult final
    {
      std::string StatusCode;
      Azure::Nullable<TransactionError> Error;
    };
  } // namespace Models
}}} // namespace Azure::Data::Tables