account_sas_builder.hpp

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#pragma once
 
#include "azure/storage/common/internal/constants.hpp"
#include "azure/storage/common/storage_credential.hpp"
 
#include <azure/core/datetime.hpp>
#include <azure/core/nullable.hpp>
 
#include <string>
#include <type_traits>
 
namespace Azure { namespace Storage { namespace Sas {
 
  enum class SasProtocol
  {
    HttpsAndHttp,
 
    HttpsOnly,
  };
 
  namespace _detail {
    inline std::string SasProtocolToString(SasProtocol protocol)
    {
      return protocol == SasProtocol::HttpsAndHttp ? "https,http" : "https";
    }
  } // namespace _detail
 
  enum class AccountSasResource
  {
    Service = 1,
 
    Container = 2,
 
    Object = 4,
 
    All = ~0,
  };
 
  inline AccountSasResource operator|(AccountSasResource lhs, AccountSasResource rhs)
  {
    using type = std::underlying_type_t<AccountSasResource>;
    return static_cast<AccountSasResource>(static_cast<type>(lhs) | static_cast<type>(rhs));
  }
 
  inline AccountSasResource operator&(AccountSasResource lhs, AccountSasResource rhs)
  {
    using type = std::underlying_type_t<AccountSasResource>;
    return static_cast<AccountSasResource>(static_cast<type>(lhs) & static_cast<type>(rhs));
  }
 
  enum class AccountSasServices
  {
    Blobs = 1,
 
    Queue = 2,
 
    Files = 4,
 
    All = ~0,
  };
 
  inline AccountSasServices operator|(AccountSasServices lhs, AccountSasServices rhs)
  {
    using type = std::underlying_type_t<AccountSasServices>;
    return static_cast<AccountSasServices>(static_cast<type>(lhs) | static_cast<type>(rhs));
  }
 
  inline AccountSasServices operator&(AccountSasServices lhs, AccountSasServices rhs)
  {
    using type = std::underlying_type_t<AccountSasServices>;
    return static_cast<AccountSasServices>(static_cast<type>(lhs) & static_cast<type>(rhs));
  }
 
  enum class AccountSasPermissions
  {
    Read = 1,
 
    Write = 2,
 
    Delete = 4,
 
    DeleteVersion = 8,
 
    List = 16,
 
    Add = 32,
 
    Create = 64,
 
    Update = 128,
 
    Process = 256,
 
    Tags = 512,
 
    Filter = 1024,
 
    SetImmutabilityPolicy = 2048,
 
    PermanentDelete = 4096,
 
    All = ~0,
  };
 
  inline AccountSasPermissions operator|(AccountSasPermissions lhs, AccountSasPermissions rhs)
  {
    using type = std::underlying_type_t<AccountSasPermissions>;
    return static_cast<AccountSasPermissions>(static_cast<type>(lhs) | static_cast<type>(rhs));
  }
 
  inline AccountSasPermissions operator&(AccountSasPermissions lhs, AccountSasPermissions rhs)
  {
    using type = std::underlying_type_t<AccountSasPermissions>;
    return static_cast<AccountSasPermissions>(static_cast<type>(lhs) & static_cast<type>(rhs));
  }
 
  struct AccountSasBuilder final
  {
    SasProtocol Protocol = SasProtocol::HttpsOnly;
 
    Azure::Nullable<Azure::DateTime> StartsOn;
 
    Azure::DateTime ExpiresOn;
 
    Azure::Nullable<std::string> IPRange;
 
    AccountSasServices Services;
 
    AccountSasResource ResourceTypes;
 
    std::string EncryptionScope;
 
    void SetPermissions(AccountSasPermissions permissions);
 
    void SetPermissions(std::string rawPermissions) { Permissions = std::move(rawPermissions); }
 
    std::string GenerateSasToken(const StorageSharedKeyCredential& credential);
 
    std::string GenerateSasStringToSign(const StorageSharedKeyCredential& credential);
 
  private:
    std::string Permissions;
  };
 
}}} // namespace Azure::Storage::Sas