share_responses.hpp

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#pragma once
 
#include "azure/storage/files/shares/share_constants.hpp"
#include "azure/storage/files/shares/share_options.hpp"
 
#include <azure/core/azure_assert.hpp>
#include <azure/core/operation.hpp>
#include <azure/core/paged_response.hpp>
 
namespace Azure { namespace Storage { namespace Files { namespace Shares {
 
  class ShareServiceClient;
  class ShareFileClient;
  class ShareDirectoryClient;
 
  namespace Models {
 
    using LeaseDuration [[deprecated]] = LeaseDurationType;
 
    struct ForceCloseDirectoryHandleResult final
    {
    };
 
    struct ClearFileRangeResult final
    {
      Azure::ETag ETag;
 
      DateTime LastModified;
 
      bool IsServerEncrypted = bool();
    };
 
    struct DownloadFileDetails final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      Core::CaseInsensitiveMap Metadata;
      Nullable<std::string> CopyId;
      Nullable<std::string> CopySource;
      Nullable<Models::CopyStatus> CopyStatus;
      Nullable<std::string> CopyStatusDescription;
      Nullable<std::string> CopyProgress;
      Nullable<DateTime> CopyCompletedOn;
      bool IsServerEncrypted = bool();
      FileSmbProperties SmbProperties;
      Nullable<LeaseDurationType> LeaseDuration;
      Nullable<Models::LeaseState> LeaseState;
      Nullable<Models::LeaseStatus> LeaseStatus;
 
      FilePosixProperties PosixProperties;
    };
 
    struct DownloadFileResult final
    {
      std::unique_ptr<Core::IO::BodyStream> BodyStream;
      Core::Http::HttpRange ContentRange;
      std::int64_t FileSize = std::int64_t();
      Nullable<ContentHash> TransactionalContentHash;
      FileHttpHeaders HttpHeaders;
      DownloadFileDetails Details;
    };
 
    struct DownloadFileToResult final
    {
      int64_t FileSize = 0;
 
      Azure::Core::Http::HttpRange ContentRange;
 
      FileHttpHeaders HttpHeaders;
 
      DownloadFileDetails Details;
    };
 
    struct ForceCloseFileHandleResult final
    {
    };
 
    struct UploadFileFromResult final
    {
      bool IsServerEncrypted = false;
    };
 
    struct AcquireLeaseResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      std::string LeaseId;
    };
    struct ReleaseLeaseResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
    };
    struct ChangeLeaseResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      std::string LeaseId;
    };
    struct RenewLeaseResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      std::string LeaseId;
    };
    struct BreakLeaseResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
    };
 
    class ShareFileHandleAccessRights final {
    public:
      ShareFileHandleAccessRights() = default;
      explicit ShareFileHandleAccessRights(const std::string& value);
      bool operator==(const ShareFileHandleAccessRights& other) const
      {
        return m_value == other.m_value;
      }
      bool operator!=(const ShareFileHandleAccessRights& other) const { return !(*this == other); }
      const std::set<std::string>& GetValues() const { return m_value; }
      ShareFileHandleAccessRights operator|(const ShareFileHandleAccessRights& other) const;
      ShareFileHandleAccessRights operator&(const ShareFileHandleAccessRights& other) const;
      ShareFileHandleAccessRights operator^(const ShareFileHandleAccessRights& other) const;
      ShareFileHandleAccessRights& operator|=(const ShareFileHandleAccessRights& other)
      {
        *this = *this | other;
        return *this;
      }
      ShareFileHandleAccessRights& operator&=(const ShareFileHandleAccessRights& other)
      {
        *this = *this & other;
        return *this;
      }
      ShareFileHandleAccessRights& operator^=(const ShareFileHandleAccessRights& other)
      {
        *this = *this ^ other;
        return *this;
      }
      AZ_STORAGE_FILES_SHARES_DLLEXPORT const static ShareFileHandleAccessRights Read;
      AZ_STORAGE_FILES_SHARES_DLLEXPORT const static ShareFileHandleAccessRights Write;
      AZ_STORAGE_FILES_SHARES_DLLEXPORT const static ShareFileHandleAccessRights Delete;
 
    private:
      std::set<std::string> m_value;
    };
 
    struct DirectoryItem final
    {
      std::string Name;
      DirectoryItemDetails Details;
    };
 
    struct FileItem final
    {
      std::string Name;
      FileItemDetails Details;
    };
 
    struct HandleItem final
    {
      std::string HandleId;
      std::string Path;
      std::string FileId;
      std::string ParentId;
      std::string SessionId;
      std::string ClientIp;
      std::string ClientName;
      DateTime OpenedOn;
      DateTime LastReconnectedOn;
      Azure::Nullable<ShareFileHandleAccessRights> AccessRights;
    };
 
    struct FileProperties final
    {
      FileSmbProperties SmbProperties;
      FileHttpHeaders HttpHeaders;
      DateTime LastModified;
      Core::CaseInsensitiveMap Metadata;
      std::int64_t FileSize = std::int64_t();
      Azure::ETag ETag;
      Nullable<DateTime> CopyCompletedOn;
      Nullable<std::string> CopyStatusDescription;
      Nullable<std::string> CopyId;
      Nullable<std::string> CopyProgress;
      Nullable<std::string> CopySource;
      Nullable<Models::CopyStatus> CopyStatus;
      bool IsServerEncrypted = bool();
      Nullable<LeaseDurationType> LeaseDuration;
      Nullable<Models::LeaseState> LeaseState;
      Nullable<Models::LeaseStatus> LeaseStatus;
      FilePosixProperties PosixProperties;
    };
 
    struct CreateFileResult final
    {
      bool Created = true;
      FileSmbProperties SmbProperties;
      Azure::ETag ETag;
      DateTime LastModified;
      bool IsServerEncrypted = bool();
      FilePosixProperties PosixProperties;
    };
 
    struct SetFilePropertiesResult final
    {
      FileSmbProperties SmbProperties;
      Azure::ETag ETag;
      DateTime LastModified;
      bool IsServerEncrypted = bool();
      FilePosixProperties PosixProperties;
    };
 
    struct CreateFileHardLinkResult final
    {
      Azure::ETag ETag;
 
      DateTime LastModified;
 
      FileSmbProperties SmbProperties;
 
      FilePosixProperties PosixProperties;
    };
 
    struct CreateDirectoryResult final
    {
      bool Created = true;
      FileSmbProperties SmbProperties;
      Azure::ETag ETag;
      DateTime LastModified;
      bool IsServerEncrypted = bool();
      FilePosixProperties PosixProperties;
    };
    struct DirectoryProperties final
    {
      FileSmbProperties SmbProperties;
      Core::CaseInsensitiveMap Metadata;
      Azure::ETag ETag;
      DateTime LastModified;
      bool IsServerEncrypted = bool();
      FilePosixProperties PosixProperties;
    };
 
    struct SetDirectoryPropertiesResult final
    {
      FileSmbProperties SmbProperties;
      Azure::ETag ETag;
      DateTime LastModified;
      bool IsServerEncrypted = bool();
      FilePosixProperties PosixProperties;
    };
  } // namespace Models
 
  class StartFileCopyOperation final : public Azure::Core::Operation<Models::FileProperties> {
  public:
    Models::FileProperties Value() const override { return m_pollResult; }
 
    StartFileCopyOperation() = default;
 
    StartFileCopyOperation(StartFileCopyOperation&&) = default;
 
    StartFileCopyOperation& operator=(StartFileCopyOperation&&) = default;
 
    ~StartFileCopyOperation() override {}
 
  private:
    std::string GetResumeToken() const override { AZURE_NOT_IMPLEMENTED(); }
 
    std::unique_ptr<Azure::Core::Http::RawResponse> PollInternal(
        const Azure::Core::Context& context) override;
 
    Azure::Response<Models::FileProperties> PollUntilDoneInternal(
        std::chrono::milliseconds period,
        Azure::Core::Context& context) override;
 
    std::shared_ptr<ShareFileClient> m_fileClient;
    Models::FileProperties m_pollResult;
 
    friend class ShareFileClient;
  };
 
  class ListSharesPagedResponse final : public Azure::Core::PagedResponse<ListSharesPagedResponse> {
  public:
    std::string ServiceEndpoint;
    std::string Prefix;
    std::vector<Models::ShareItem> Shares;
 
  private:
    void OnNextPage(const Azure::Core::Context& context);
 
    std::shared_ptr<ShareServiceClient> m_shareServiceClient;
    ListSharesOptions m_operationOptions;
 
    friend class ShareServiceClient;
    friend class Azure::Core::PagedResponse<ListSharesPagedResponse>;
  };
 
  class ListFilesAndDirectoriesPagedResponse final
      : public Azure::Core::PagedResponse<ListFilesAndDirectoriesPagedResponse> {
  public:
    std::string ServiceEndpoint;
    std::string ShareName;
    std::string ShareSnapshot;
    std::string DirectoryPath;
    std::string Prefix;
    std::vector<Models::DirectoryItem> Directories;
    std::vector<Models::FileItem> Files;
    std::string DirectoryId;
 
  private:
    void OnNextPage(const Azure::Core::Context& context);
 
    std::shared_ptr<ShareDirectoryClient> m_shareDirectoryClient;
    ListFilesAndDirectoriesOptions m_operationOptions;
 
    friend class ShareDirectoryClient;
    friend class Azure::Core::PagedResponse<ListFilesAndDirectoriesPagedResponse>;
  };
 
  class ListFileHandlesPagedResponse final
      : public Azure::Core::PagedResponse<ListFileHandlesPagedResponse> {
  public:
    std::vector<Models::HandleItem> FileHandles;
 
  private:
    void OnNextPage(const Azure::Core::Context& context);
 
    std::shared_ptr<ShareFileClient> m_shareFileClient;
    ListFileHandlesOptions m_operationOptions;
 
    friend class ShareFileClient;
    friend class Azure::Core::PagedResponse<ListFileHandlesPagedResponse>;
  };
 
  class ForceCloseAllFileHandlesPagedResponse final
      : public Azure::Core::PagedResponse<ForceCloseAllFileHandlesPagedResponse> {
  public:
    int32_t NumberOfHandlesClosed = 0;
    int32_t NumberOfHandlesFailedToClose = 0;
 
  private:
    void OnNextPage(const Azure::Core::Context& context);
 
    std::shared_ptr<ShareFileClient> m_shareFileClient;
    ForceCloseAllFileHandlesOptions m_operationOptions;
 
    friend class ShareFileClient;
    friend class Azure::Core::PagedResponse<ForceCloseAllFileHandlesPagedResponse>;
  };
 
  class ListDirectoryHandlesPagedResponse final
      : public Azure::Core::PagedResponse<ListDirectoryHandlesPagedResponse> {
  public:
    std::vector<Models::HandleItem> DirectoryHandles;
 
  private:
    void OnNextPage(const Azure::Core::Context& context);
 
    std::shared_ptr<ShareDirectoryClient> m_shareDirectoryClient;
    ListDirectoryHandlesOptions m_operationOptions;
 
    friend class ShareDirectoryClient;
    friend class Azure::Core::PagedResponse<ListDirectoryHandlesPagedResponse>;
  };
 
  class ForceCloseAllDirectoryHandlesPagedResponse final
      : public Azure::Core::PagedResponse<ForceCloseAllDirectoryHandlesPagedResponse> {
  public:
    int32_t NumberOfHandlesClosed = 0;
    int32_t NumberOfHandlesFailedToClose = 0;
 
  private:
    void OnNextPage(const Azure::Core::Context& context);
 
    std::shared_ptr<ShareDirectoryClient> m_shareDirectoryClient;
    ForceCloseAllDirectoryHandlesOptions m_operationOptions;
 
    friend class ShareDirectoryClient;
    friend class Azure::Core::PagedResponse<ForceCloseAllDirectoryHandlesPagedResponse>;
  };
 
}}}} // namespace Azure::Storage::Files::Shares