cos-cpp-sdk-v5/include/request/bucket_req.h

// Copyright (c) 2017, Tencent Inc.
// All rights reserved.
//
// Author: sevenyou <sevenyou@tencent.com>
// Created: 07/21/17
// Description:

#ifndef BUCKET_REQ_H
#define BUCKET_REQ_H
#pragma once

#include "cos_defines.h"
#include "request/base_req.h"
#include "util/string_util.h"
#include "util/illegal_intercept.h"

namespace qcloud_cos {

class BucketReq : public BaseReq {
 public:
  BucketReq() : m_bucket_name("") {}
  explicit BucketReq(const std::string& bucket_name) : m_bucket_name(bucket_name) {
    if (!IllegalIntercept::CheckBucket(bucket_name)) {
      throw std::invalid_argument("Invalid bucket_name argument :" + bucket_name);
    }
  }
  virtual ~BucketReq() {}

  // getter and setter
  std::string GetBucketName() const { return m_bucket_name; }
  void SetBucketName(const std::string& bucket_name) {
    if (!IllegalIntercept::CheckBucket(bucket_name)) {
      throw std::invalid_argument("Invalid bucket_name argument :" + bucket_name);
    }
    m_bucket_name = bucket_name;
  }
  virtual bool GenerateRequestBody(std::string* body) const { UNUSED_PARAM(body); return true; }

 private:
  std::string m_bucket_name;
};

class HeadBucketReq : public BucketReq {
 public:
  explicit HeadBucketReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    m_method = "HEAD";
  }

  virtual ~HeadBucketReq() {}
};

class PutBucketReq : public BucketReq {
 public:
  explicit PutBucketReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("PUT");
    SetPath("/");
  }

  virtual ~PutBucketReq() {}

  /// 定义Bucket的ACL属性,有效值：private,public-read-write,public-read
  /// 默认值：private
  void SetXCosAcl(const std::string& str) { AddHeader("x-cos-acl", str); }

  /// 赋予被授权者读的权限.格式：x-cos-grant-read: id=" ",id=" ".
  /// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>"
  /// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
  void SetXCosGrantRead(const std::string& str) {
    AddHeader("x-cos-grant-read", str);
  }

  /// 赋予被授权者写的权限,格式：x-cos-grant-write: id=" ",id=" "./
  /// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>",
  /// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
  void SetXCosGrantWrite(const std::string& str) {
    AddHeader("x-cos-grant-write", str);
  }

  /// 赋予被授权者读写权限.格式：x-cos-grant-full-control: id=" ",id=" ".
  /// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>",
  /// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
  void SetXCosGrantFullControl(const std::string& str) {
    AddHeader("x-cos-grant-full-control", str);
  }

  //设置桶为多az存储桶
  void SetMAZBucket() {
    std::string maz = "<CreateBucketConfiguration>";
    maz += "    <BucketAZConfig>MAZ</BucketAZConfig>";
    maz += "</CreateBucketConfiguration>";
    SetBody(maz);
  }
};

class GetBucketReq : public BucketReq {
 public:
  explicit GetBucketReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("GET");
    SetPath("/");
  }

  virtual ~GetBucketReq() {}

  /// \@brief 设置前缀，用来规定返回的文件前缀地址
  void SetPrefix(const std::string& prefix) { AddParam("prefix", prefix); }

  /// \brief 设置定界符，如果有 Prefix，则将 Prefix 到 delimiter
  /// 之间的相同路径归为一类，
  ///        定义为 Common Prefix，然后列出所有 Common Prefix。如果没有
  ///        Prefix，则从路径起点开始
  void SetDelimiter(const std::string& delimiter) {
    AddParam("delimiter", delimiter);
  }

  /// \brief 规定返回值的编码方式，可选值：url
  void SetEncodingType(const std::string& encoding_type) {
    AddParam("encoding-type", encoding_type);
  }

  /// \brief 默认以 UTF-8 二进制顺序列出条目，所有列出条目从marker开始
  void SetMarker(const std::string& marker) { AddParam("marker", marker); }

  /// \brief 单次返回最大的条目数量，默认1000
  void SetMaxKeys(uint64_t max_keys) {
    AddParam("max-keys", StringUtil::Uint64ToString(max_keys));
  }
};

class ListMultipartUploadReq : public BucketReq {
 public:
  explicit ListMultipartUploadReq(const std::string& bucket_name)
      : BucketReq(bucket_name) {
    SetMethod("GET");
    SetPath("/");
    AddParam("uploads", "");
  }

  virtual ~ListMultipartUploadReq() {}

  void SetPrefix(const std::string& prefix) { AddParam("prefix", prefix); }

  void SetDelimiter(const std::string& delimiter) {
    AddParam("delimiter", delimiter);
  }

  void SetEncodingType(const std::string& encoding_type) {
    AddParam("encoding-type", encoding_type);
  }

  void SetKeyMarker(const std::string& marker) {
    AddParam("key-marker", marker);
  }

  void SetMaxUploads(const std::string& max_uploads) {
    AddParam("max-uploads", max_uploads);
  }

  void SetUploadIdMarker(const std::string& upload_id_marker) {
    AddParam("upload-id-marker", upload_id_marker);
  }
};

class DeleteBucketReq : public BucketReq {
 public:
  explicit DeleteBucketReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("DELETE");
  }

  ~DeleteBucketReq() {}
};

class GetBucketVersioningReq : public BucketReq {
 public:
  explicit GetBucketVersioningReq(const std::string& bucket_name)
      : BucketReq(bucket_name) {
    SetMethod("GET");
    SetPath("/");
    AddParam("versioning", "");
  }

  virtual ~GetBucketVersioningReq() {}
};

class PutBucketVersioningReq : public BucketReq {
 public:
  explicit PutBucketVersioningReq(const std::string& bucket_name)
      : BucketReq(bucket_name), m_status(true) {
    SetMethod("PUT");
    SetPath("/");
    AddParam("versioning", "");
  }

  virtual ~PutBucketVersioningReq() {}

  /// \brief 版本是否开启
  void SetStatus(bool is_enable) { m_status = is_enable; }

  bool GetStatus() const { return m_status; }

  bool GenerateRequestBody(std::string* body) const;

 private:
  bool m_status;
};

class GetBucketReplicationReq : public BucketReq {
 public:
  explicit GetBucketReplicationReq(const std::string& bucket_name)
      : BucketReq(bucket_name) {
    SetMethod("GET");
    SetPath("/");
    AddParam("replication", "");
  }

  virtual ~GetBucketReplicationReq() {}
};

class PutBucketReplicationReq : public BucketReq {
 public:
  explicit PutBucketReplicationReq(const std::string& bucket_name)
      : BucketReq(bucket_name) {
    SetMethod("PUT");
    SetPath("/");
    AddParam("replication", "");
  }

  virtual ~PutBucketReplicationReq() {}

  void SetRole(const std::string& role) { m_role = role; }

  void AddReplicationRule(const ReplicationRule& rule) {
    m_rules.push_back(rule);
  }

  void SetReplicationRule(const std::vector<ReplicationRule>& rules) {
    m_rules = rules;
  }

  bool GenerateRequestBody(std::string* body) const;

 private:
  std::string m_role;
  std::vector<ReplicationRule> m_rules;
};

class DeleteBucketReplicationReq : public BucketReq {
 public:
  explicit DeleteBucketReplicationReq(const std::string& bucket_name)
      : BucketReq(bucket_name) {
    SetMethod("Delete");
    SetPath("/");
    AddParam("replication", "");
  }

  virtual ~DeleteBucketReplicationReq() {}
};

class GetBucketLifecycleReq : public BucketReq {
 public:
  explicit GetBucketLifecycleReq(const std::string& bucket_name)
      : BucketReq(bucket_name) {
    SetMethod("GET");
    SetPath("/");
    AddParam("lifecycle", "");
  }

  virtual ~GetBucketLifecycleReq() {}
};

class PutBucketLifecycleReq : public BucketReq {
 public:
  explicit PutBucketLifecycleReq(const std::string& bucket_name)
      : BucketReq(bucket_name) {
    SetMethod("PUT");
    SetPath("/");
    AddParam("lifecycle", "");
  }

  virtual ~PutBucketLifecycleReq() {}

  void AddRule(const LifecycleRule& rule) { m_rules.push_back(rule); }

  void SetRule(const std::vector<LifecycleRule>& rules) { m_rules = rules; }

  bool GenerateRequestBody(std::string* body) const;

 private:
  std::vector<LifecycleRule> m_rules;
};

class DeleteBucketLifecycleReq : public BucketReq {
 public:
  explicit DeleteBucketLifecycleReq(const std::string& bucket_name)
      : BucketReq(bucket_name) {
    SetMethod("DELETE");
    SetPath("/");
    AddParam("lifecycle", "");
  }

  virtual ~DeleteBucketLifecycleReq() {}
};

class GetBucketACLReq : public BucketReq {
 public:
  explicit GetBucketACLReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("GET");
    SetPath("/");
    AddParam("acl", "");
  }

  virtual ~GetBucketACLReq() {}
};

class PutBucketACLReq : public BucketReq {
 public:
  explicit PutBucketACLReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("PUT");
    SetPath("/");
    AddParam("acl", "");
  }

  virtual ~PutBucketACLReq() {}

  /// 定义Bucket的ACL属性,有效值：private,public-read-write,public-read
  /// 默认值：private
  void SetXCosAcl(const std::string& str) { AddHeader("x-cos-acl", str); }

  /// 赋予被授权者读的权限.格式：x-cos-grant-read: id=" ",id=" ".
  /// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>"
  /// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
  void SetXCosGrantRead(const std::string& str) {
    AddHeader("x-cos-grant-read", str);
  }

  /// 赋予被授权者写的权限,格式：x-cos-grant-write: id=" ",id=" "./
  /// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>",
  /// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
  void SetXCosGrantWrite(const std::string& str) {
    AddHeader("x-cos-grant-write", str);
  }

  /// 赋予被授权者读写权限.格式：x-cos-grant-full-control: id=" ",id=" ".
  /// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>",
  /// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
  void SetXCosGrantFullControl(const std::string& str) {
    AddHeader("x-cos-grant-full-control", str);
  }

  /// Bucket 持有者 ID
  void SetOwner(const Owner& owner) { m_owner = owner; }

  /// 设置被授权者信息与权限信息
  void SetAccessControlList(const std::vector<Grant>& grants) {
    m_acl = grants;
  }

  /// 添加单个 Bucket 的授权信息
  void AddAccessControlList(const Grant& grant) { m_acl.push_back(grant); }

  /// 清空权限信息
  void ClearAccessControlList() {
    std::vector<Grant> tmp;
    m_acl.swap(tmp);
  }

  bool GenerateRequestBody(std::string* body) const;

 private:
  Owner m_owner;
  std::vector<Grant> m_acl;
};

class GetBucketPolicyReq : public BucketReq {
 public:
  explicit GetBucketPolicyReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("GET");
    SetPath("/");
    AddParam("policy", "");
  }

  virtual ~GetBucketPolicyReq() {}
};

class PutBucketPolicyReq : public BucketReq {
 public:
  explicit PutBucketPolicyReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("PUT");
    SetPath("/");
    AddParam("policy", "");
  }

  virtual ~PutBucketPolicyReq() {}
};

class DeleteBucketPolicyReq : public BucketReq {
 public:
  explicit DeleteBucketPolicyReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("DELETE");
    SetPath("/");
    AddParam("policy", "");
  }

  virtual ~DeleteBucketPolicyReq() {}
};

class DeleteBucketACLReq : public BucketReq {
 public:
  explicit DeleteBucketACLReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("DELETE");
  }

  virtual ~DeleteBucketACLReq() {}
};

class GetBucketCORSReq : public BucketReq {
 public:
  explicit GetBucketCORSReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("GET");
    SetPath("/");
    AddParam("cors", "");
  }

  virtual ~GetBucketCORSReq() {}
};

class PutBucketCORSReq : public BucketReq {
 public:
  explicit PutBucketCORSReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("PUT");
    SetPath("/");
    AddParam("cors", "");
    AddHeader("Content-Type", "application/xml");
  }

  virtual ~PutBucketCORSReq() {}

  bool GenerateRequestBody(std::string* body) const;

  void AddRule(const CORSRule& rule) { m_rules.push_back(rule); }

  void SetRules(const std::vector<CORSRule>& rules) { m_rules = rules; }

 private:
  std::vector<CORSRule> m_rules;
};

class DeleteBucketCORSReq : public BucketReq {
 public:
  explicit DeleteBucketCORSReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("DELETE");
    SetPath("/");
    AddParam("cors", "");
  }

  virtual ~DeleteBucketCORSReq() {}
};

class GetBucketLocationReq : public BucketReq {
 public:
  explicit GetBucketLocationReq(const std::string& bucket_name)
      : BucketReq(bucket_name) {
    SetMethod("GET");
    SetPath("/");
    AddParam("location", "");
  }

  virtual ~GetBucketLocationReq() {}
};

class GetBucketObjectVersionsReq : public BucketReq {
 public:
  explicit GetBucketObjectVersionsReq(const std::string& bucket_name)
      : BucketReq(bucket_name) {
    SetMethod("GET");
    SetPath("/");
    AddParam("versions", "");
  }

  virtual ~GetBucketObjectVersionsReq() {}

  /// \@brief 设置前缀，用来规定返回的文件前缀地址
  void SetPrefix(const std::string& prefix) { AddParam("prefix", prefix); }

  /// \brief 设置定界符，如果有 Prefix，则将 Prefix 到 delimiter
  /// 之间的相同路径归为一类，
  ///        定义为 Common Prefix，然后列出所有 Common Prefix。如果没有
  ///        Prefix，则从路径起点开始
  void SetDelimiter(const std::string& delimiter) {
    AddParam("delimiter", delimiter);
  }

  /// \brief 规定返回值的编码方式，可选值：url
  void SetEncodingType(const std::string& encoding_type) {
    AddParam("encoding-type", encoding_type);
  }

  /// \brief 默认以 UTF-8 二进制顺序列出条目，所有列出条目从marker开始
  void SetKeyMarker(const std::string& marker) {
    AddParam("key-marker", marker);
  }

  /// \brief 单次返回最大的条目数量，默认1000
  void SetMaxKeys(uint64_t max_keys) {
    AddParam("max-keys", StringUtil::Uint64ToString(max_keys));
  }

  void SetVersionIdMarker(const std::string& version_id_marker) {
    AddParam("version-id-marker", version_id_marker);
  }
};

class PutBucketLoggingReq : public BucketReq {
 public:
  explicit PutBucketLoggingReq(const std::string& bucket_name)
      : BucketReq(bucket_name), m_mask(0x00000000u) {
    SetMethod("PUT");
    SetPath("/");
    AddParam("logging", "");
  }
  virtual ~PutBucketLoggingReq() {}

  void SetLoggingEnabled(const LoggingEnabled& rules) {
    m_mask = m_mask | 0x00000001u;
    m_rules = rules;
  }
  bool HasLoggingEnabled() const { return (m_mask & 0x00000001u) != 0; }

  bool GenerateRequestBody(std::string* body) const;

 private:
  uint64_t m_mask;
  LoggingEnabled m_rules;
};

class GetBucketLoggingReq : public BucketReq {
 public:
  explicit GetBucketLoggingReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("GET");
    SetPath("/");
    AddParam("logging", "");
  }
  virtual ~GetBucketLoggingReq() {}
};

class PutBucketDomainReq : public BucketReq {
 public:
  explicit PutBucketDomainReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("PUT");
    SetPath("/");
    AddParam("domain", "");
  }
  virtual ~PutBucketDomainReq() {}

  void SetDomainRule(const DomainRule& rules) { m_rules = rules; }
  bool GenerateRequestBody(std::string* body) const;

 private:
  DomainRule m_rules;
};

class GetBucketDomainReq : public BucketReq {
 public:
  explicit GetBucketDomainReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("GET");
    SetPath("/");
    AddParam("domain", "");
  }
  virtual ~GetBucketDomainReq() {}
};

class PutBucketWebsiteReq : public BucketReq {
 public:
  explicit PutBucketWebsiteReq(const std::string& bucket_name)
      : BucketReq(bucket_name),
        m_mask(0x00000000u),
        m_suffix(""),
        m_protocol(""),
        m_key("") {
    SetMethod("PUT");
    SetPath("/");
    AddParam("website", "");
  }

  virtual ~PutBucketWebsiteReq() {}

  void SetSuffix(const std::string& suffix) {
    m_mask = m_mask | 0x00000001u;
    m_suffix = suffix;
  }

  void SetProtocol(const std::string& protocol) {
    m_mask = m_mask | 0x00000002u;
    m_protocol = protocol;
  }

  void SetKey(const std::string& key) {
    m_mask = m_mask | 0x00000004u;
    m_key = key;
  }

  std::string GetSuffix() const { return m_suffix; }

  std::string GetProtocol() const { return m_protocol; }

  std::string GetKey() const { return m_key; }

  bool HasSuffix() const { return (m_mask & 0x00000001u) != 0; }

  bool HasProtocol() const { return (m_mask & 0x00000002u) != 0; }

  bool HasKey() const { return (m_mask & 0x00000004u) != 0; }

  bool HasRoutingRules() const { return !m_routingrules.empty(); }

  /// 设置重定向规则
  void SetRoutingRules(const std::vector<RoutingRule>& routingrules) {
    m_routingrules = routingrules;
  }

  /// 添加单个rule
  void AddRoutingRule(const RoutingRule& routingrule) {
    m_routingrules.push_back(routingrule);
  }

  /// 清空重定向规则
  void ClearRoutingRules() {
    std::vector<RoutingRule> tmp;
    m_routingrules.swap(tmp);
  }

  bool GenerateRequestBody(std::string* body) const;

 private:
  uint64_t m_mask;
  std::string m_suffix;
  std::string m_protocol;
  std::string m_key;
  std::vector<RoutingRule> m_routingrules;
};

class GetBucketWebsiteReq : public BucketReq {
 public:
  explicit GetBucketWebsiteReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("Get");
    SetPath("/");
    AddParam("website", "");
  }

  virtual ~GetBucketWebsiteReq() {}
};

class DeleteBucketWebsiteReq : public BucketReq {
 public:
  explicit DeleteBucketWebsiteReq(const std::string& bucket_name)
      : BucketReq(bucket_name) {
    SetMethod("DELETE");
    SetPath("/");
    AddParam("website", "");
  }

  virtual ~DeleteBucketWebsiteReq() {}
};

class PutBucketTaggingReq : public BucketReq {
 public:
  explicit PutBucketTaggingReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("PUT");
    SetPath("/");
    AddParam("tagging", "");
  }

  void SetTagSet(std::vector<Tag>& tagset) { m_tagset = tagset; }

  std::vector<Tag> GetTagSet() { return m_tagset; }

  //清除tag规则.
  void ClearTagSet() {
    std::vector<Tag> temp;
    m_tagset.swap(temp);
  }

  /// 添加单个tag.
  void AddTag(const Tag& tag) { m_tagset.push_back(tag); }

  bool GenerateRequestBody(std::string* body) const;
  virtual ~PutBucketTaggingReq() {}

 private:
  std::vector<Tag> m_tagset;
};

class GetBucketTaggingReq : public BucketReq {
 public:
  explicit GetBucketTaggingReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("GET");
    SetPath("/");
    AddParam("tagging", "");
  }
  virtual ~GetBucketTaggingReq() {}
};

class DeleteBucketTaggingReq : public BucketReq {
 public:
  explicit DeleteBucketTaggingReq(const std::string& bucket_name)
      : BucketReq(bucket_name) {
    SetMethod("DELETE");
    SetPath("/");
    AddParam("tagging", "");
  }

  virtual ~DeleteBucketTaggingReq() {}
};

class PutBucketInventoryReq : public BucketReq {
 public:
  explicit PutBucketInventoryReq(const std::string& bucket_name)
      : BucketReq(bucket_name), m_mask(0x00000000u) {
    SetMethod("PUT");
    SetPath("/");
    AddParam("inventory", "");
  }

  void SetInventory(Inventory& inventory) {
    m_mask = m_mask | 0x00000001u;
    m_inventory = inventory;
  }

  bool HasInventory() const { return (m_mask & 0x00000001u) != 0; }

  const Inventory& GetInventory() const { return m_inventory; }

  void SetId(const std::string id) {
    m_mask = m_mask | 0x00000001u;
    m_id = id;
    AddParam("id", m_id);
  }

  std::string GetId() const { return m_id; }

  bool HasId() const { return (m_mask & 0x00000001u) != 0; }

  bool GenerateRequestBody(std::string* body) const;
  virtual ~PutBucketInventoryReq() {}

 private:
  uint64_t m_mask;
  std::string m_id;
  Inventory m_inventory;
};

class GetBucketInventoryReq : public BucketReq {
 public:
  explicit GetBucketInventoryReq(const std::string& bucket_name)
      : BucketReq(bucket_name), m_mask(0x00000000u) {
    SetMethod("GET");
    SetPath("/");
    AddParam("inventory", "");
  }

  void SetId(const std::string id) {
    m_mask = m_mask | 0x00000001u;
    m_id = id;
    AddParam("id", m_id);
  }

  std::string GetId() const { return m_id; }

  bool HasId() const { return (m_mask & 0x00000001u) != 0; }

  virtual ~GetBucketInventoryReq() {}

 private:
  uint64_t m_mask;
  std::string m_id;
};

class ListBucketInventoryConfigurationsReq : public BucketReq {
 public:
  explicit ListBucketInventoryConfigurationsReq(const std::string& bucket_name)
      : BucketReq(bucket_name), m_mask(0x00000000u) {
    SetMethod("GET");
    SetPath("/");
    AddParam("inventory", "");
  }

  void SetContinuationToken(const std::string continuation_token) {
    m_mask = m_mask | 0x00000001u;
    m_continuation_token = continuation_token;
    AddParam("continuation-token", m_continuation_token);
  }

  std::string GetContinuationToken() const { return m_continuation_token; }

  bool HasContinuationToken() const { return (m_mask & 0x00000001u) != 0; }

  virtual ~ListBucketInventoryConfigurationsReq() {}

 private:
  uint64_t m_mask;
  std::string m_continuation_token;
};

class DeleteBucketInventoryReq : public BucketReq {
 public:
  explicit DeleteBucketInventoryReq(const std::string& bucket_name)
      : BucketReq(bucket_name), m_mask(0x00000000u), m_id("") {
    SetMethod("DELETE");
    SetPath("/");
    AddParam("inventory", "");
  }

  void SetId(const std::string id) {
    m_mask = m_mask | 0x00000001u;
    m_id = id;
    AddParam("id", m_id);
  }

  std::string GetId() const { return m_id; }

  bool HasId() const { return (m_mask & 0x00000001u) != 0; }

  virtual ~DeleteBucketInventoryReq() {}

 private:
  uint64_t m_mask;
  std::string m_id;
};

/// \brief: 列举直播通道请求
class ListLiveChannelReq : public BucketReq {
 public:
  explicit ListLiveChannelReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("GET");
    SetPath("/");
    AddParam("live", "");
  }
  void SetMaxKeys(uint32_t max_keys) {
    AddParam("max-keys", StringUtil::IntToString(max_keys));
  }
  void SetMarker(const std::string& marker) { AddParam("marker", marker); }
  void SetPrefix(const std::string& prefix) { AddParam("prefix", prefix); }
  virtual ~ListLiveChannelReq() {}
};

/// \brief: 配置存储桶智能分层特性
class PutBucketIntelligentTieringReq : public BucketReq {
 public:
  explicit PutBucketIntelligentTieringReq(const std::string& bucket_name)
      : BucketReq(bucket_name), m_status(false), m_days(30) {
    SetMethod("PUT");
    SetPath("/");
    AddParam("intelligenttiering", "");
  }
  virtual ~PutBucketIntelligentTieringReq() {}

  /// \brief 设置智能分层的状态，true表示Enabled，false表示Suspended
  void SetStatus(bool is_enable) { m_status = is_enable; }

  /// \brief
  /// 指定智能分层存储配置中标准层数据转换为低频层数据的天数限制，默认值为30天
  void SetDays(uint32_t days) { m_days = days; }

  bool GenerateRequestBody(std::string* body) const;

 private:
  bool m_status;
  uint32_t m_days;
};

/// \brief: 获取存储桶智能分层配置
class GetBucketIntelligentTieringReq : public BucketReq {
 public:
  explicit GetBucketIntelligentTieringReq(const std::string& bucket_name)
      : BucketReq(bucket_name) {
    SetMethod("GET");
    SetPath("/");
    AddParam("intelligenttiering", "");
  }
  virtual ~GetBucketIntelligentTieringReq() {}
};

class PutBucketRefererReq : public BucketReq {
 public:
  explicit PutBucketRefererReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("PUT");
    SetPath("/");
    AddParam("referer", "");
  }

  /// \brief 是否开启防盗链，枚举值：Enabled、Disabled
  void SetStatus(const std::string& status) { m_status = status; }

  /// \brief 防盗链类型，枚举值：Black-List、White-List
  void SetRefererType(const std::string& referer_type) {
    m_referer_type = referer_type;
  }

  /// \brief 生效域名列表， 支持多个域名且为前缀匹配， 支持带端口的域名和 IP，
  /// 支持通配符*，做二级域名或多级域名的通配
  void AddDomain(const std::string& domain) { m_domain_list.push_back(domain); }

  /// \brief 是否允许空 Referer 访问，枚举值：Allow、Deny，默认值为 Deny
  void SetEmptyReferConfig(const std::string& empty_refer_conf) {
    m_empty_refer_conf = empty_refer_conf;
  }

  bool GenerateRequestBody(std::string* body) const;
  virtual ~PutBucketRefererReq() {}

 private:
  std::string m_status;
  std::string m_referer_type;
  std::vector<std::string> m_domain_list;
  std::string m_empty_refer_conf;
};

class GetBucketRefererReq : public BucketReq {
 public:
  explicit GetBucketRefererReq(const std::string& bucket_name) : BucketReq(bucket_name) {
    SetMethod("GET");
    SetPath("/");
    AddParam("referer", "");
  }
  virtual ~GetBucketRefererReq() {}
};

}  // namespace qcloud_cos

#endif  // BUCKET_REQ_H