error.h

Go to the documentation of this file.

/*
 *
 * Copyright (c) Microsoft Corporation.
 * All rights reserved.
 *
 * This code is licensed under the MIT License.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files(the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions :
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 */
#ifndef API_MIP_ERROR_H_
#define API_MIP_ERROR_H_
 
#include <algorithm>
#include <exception>
#include <map>
#include <memory>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "mip/common_types.h"
#include "mip/mip_namespace.h"
 
namespace {
 
constexpr const char* GetStackTraceString() {
  return "StackTrace";
}
 
constexpr const char* GetHResultString() {
  return "HResult";
}
 
constexpr const char* GetBadInputErrorString() {
  return "BadInputError";
}
 
constexpr const char* GetNoPermissionsExtendedErrorName() { return "NoPermissionsExtendedError"; }
 
constexpr const char* GetErrorInfoCodesKey() { return "ExtendedErrorInfo_Codes"; }
 
constexpr const char* GetErrorInfoMessagesKey() { return "ExtendedErrorInfo_Messages"; }
 
constexpr const char* GetErrorInfoDetailsKey() { return "ExtendedErrorInfo_Details"; }
 
} // namespace
 
MIP_NAMESPACE_BEGIN
 
enum class ErrorType : unsigned int {
  BAD_INPUT_ERROR, 
  INSUFFICIENT_BUFFER_ERROR, 
  FILE_IO_ERROR, 
  NETWORK_ERROR, 
  INTERNAL_ERROR, 
  JUSTIFICATION_REQUIRED, 
  NOT_SUPPORTED_OPERATION, 
  PRIVILEGED_REQUIRED, 
  ACCESS_DENIED, 
  CONSENT_DENIED, 
  NO_PERMISSIONS, 
  NO_AUTH_TOKEN, 
  DISABLED_SERVICE, 
  PROXY_AUTH_ERROR, 
  NO_POLICY, 
  OPERATION_CANCELLED, 
  ADHOC_PROTECTION_REQUIRED, 
  DEPRECATED_API, 
  TEMPLATE_NOT_FOUND, 
  LABEL_NOT_FOUND, 
  LABEL_DISABLED, 
  DOUBLE_KEY_DISABLED, 
  LICENSE_NOT_REGISTERED,  
  CONTENT_FORMAT_NOT_SUPPORTED, 
  TEMPLATE_ARCHIVED, 
  CUSTOMER_KEY_UNAVAILABLE, 
  DELEGATE_RESPONSE, 
  MAX_DEPTH_REACHED, 
  COUNT, 
};
 
struct ExtendedErrorInfo {
  std::string code;
  std::string message;
  std::map<std::string, std::string> details;
};
 
class Error : public std::exception {
public:
  char const* what() const noexcept override {
    return mFormattedMessage.c_str();
  }
 
  virtual std::shared_ptr<Error> Clone() const = 0;
 
  virtual ErrorType GetErrorType() const { return mType; }
 
  const std::string& GetErrorName() const { return mName; }
 
  const std::string& GetMessage(bool maskPII = false) const {
    return maskPII ? mMaskedMessage : mFormattedMessage;
  }
 
  void SetMessage(const std::string& msg) {
    std::string* targetStrings[] = { &mFormattedMessage, &mMaskedMessage };
    for (auto* targetString : targetStrings) {
      size_t pos = targetString->find(mMessage);
      if (pos != std::string::npos) {
        targetString->replace(pos, mMessage.length(), msg);
      } else {
        targetString->replace(0, 0, msg);
      }
    }
    mMessage = msg;
  }
 
  void AddDebugInfo(const std::string& key, const std::string& value, bool sensitive = false) {
    if (!key.empty() && !value.empty()) {
      mDebugInfo[key] = value;
      mFormattedMessage = mFormattedMessage + ", " + key + "=" + value;
      mMaskedMessage = mMaskedMessage + ", " + key + "=" + (sensitive ? "***" : value);
    }
  }
 
  const std::map<std::string, std::string>& GetDebugInfo() const { return mDebugInfo; }
 
  virtual ~Error() {}
 
protected:
  explicit Error(
      const std::string& message,
      const std::string& name,
      ErrorType type)
      : mMessage(message), mName(name), mType(type) {
    mFormattedMessage = CreateFormattedMessage(message);
    mMaskedMessage = mFormattedMessage;
  }
  explicit Error(
      const std::string& message,
      const std::map<std::string, std::string> debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name,
      ErrorType type)
      : mMessage(message), mName(name), mType(type) {
    mFormattedMessage = CreateFormattedMessage(message);
    mMaskedMessage = mFormattedMessage;
    for (const auto& entry: sensitiveDebugInfo) {
      AddDebugInfo(entry.first, entry.second, true);
    }
    for (const auto& entry: debugInfo) {
      AddDebugInfo(entry.first, entry.second);
    }
  }
  std::string mMessage;
  std::map<std::string, std::string> mDebugInfo;
  std::string mName;
  ErrorType mType;
 
private:
  std::string CreateFormattedMessage(const std::string& message) const {
    auto formattedMessage = message;
 
    // Remove stray newlines
    auto isNewlineFn = [](char c) { return c == '\n' || c == '\r'; };
    formattedMessage.erase(std::remove_if(formattedMessage.begin(), formattedMessage.end(), isNewlineFn), formattedMessage.end());
 
    return formattedMessage;
  }
 
  std::string mFormattedMessage;
  std::string mMaskedMessage;
};
 
class BadInputError : public Error {
public:
 
  enum class ErrorCode {
    General = 0, 
    FileIsTooLargeForProtection = 1, 
    ParameterParsing = 2, 
    LicenseNotTrusted = 3, 
    DoubleKey = 4, 
    FileFormatNotSupported = 5, 
  };
 
  explicit BadInputError(
      const std::string& message,
      const std::string& name = GetBadInputErrorString(),
      ErrorCode errorCode = ErrorCode::General)
      : BadInputError(message, {{}}, {{}}, name, errorCode) {}
 
  explicit BadInputError(
      const std::string& message,
      ErrorCode errorCode,
      const std::string& name = GetBadInputErrorString())
      : BadInputError(message, {{}}, {{}}, name, errorCode) {}
 
  explicit BadInputError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = GetBadInputErrorString(),
      ErrorCode errorCode = ErrorCode::General)
      : Error(message, debugInfo, sensitiveDebugInfo, name, ErrorType::BAD_INPUT_ERROR),
        mErrorCode(errorCode) {
    AddDebugInfo("BadInputError.Code", GetErrorCodeString(errorCode));
  }
  std::shared_ptr<Error> Clone() const override { return std::make_shared<BadInputError>(*this); }
  ErrorCode GetErrorCode() const { return mErrorCode; }
 
private:
  ErrorCode mErrorCode;
 
  const std::string& GetErrorCodeString(ErrorCode code) const {
    static const std::string kUnrecognized = "UNRECOGNIZED";
    static const std::map<ErrorCode, std::string> kCodes = {
        { ErrorCode::General,                       "General" },
        { ErrorCode::FileIsTooLargeForProtection,   "FileIsTooLargeForProtection" },
        { ErrorCode::ParameterParsing,              "ParameterParsing" },
        { ErrorCode::LicenseNotTrusted,             "LicenseNotTrusted" },
        { ErrorCode::DoubleKey,                     "DoubleKey" },
        { ErrorCode::FileFormatNotSupported,        "FileFormatNotSupported"},
    };
    return kCodes.count(code) ? kCodes.at(code) : kUnrecognized;
  }
};
 
class DelegateResponseError : public Error {
public:
  explicit DelegateResponseError(const std::exception_ptr& except) :
      Error(std::string(), std::string("DelegateResponseError"), ErrorType::DELEGATE_RESPONSE),
      mCurrentException(except) {
    if (except) {
      try {
        std::rethrow_exception(except);
      } catch(const Error& error) {
        *static_cast<Error*>(this) = error;
      } catch (const std::exception& thisException) {
        this->mMessage = std::string(thisException.what());
      }
    }
  }
 
  DelegateResponseError(
    const std::string& message,
    const std::string& stackTrace,
    const std::string& name = "DelegateResponseError")
      : Error(message, name, ErrorType::DELEGATE_RESPONSE) {
    AddDebugInfo(GetStackTraceString(), stackTrace);
  }
 
  DelegateResponseError(
    const std::string& message,
    long HResult,
    const std::string& stackTrace,
    const std::string& name = "DelegateResponseError")
      : Error(message, name, ErrorType::DELEGATE_RESPONSE) {
    std::stringstream hrStream;
    hrStream << std::hex << HResult;
    AddDebugInfo(GetHResultString(), hrStream.str());
    AddDebugInfo(GetStackTraceString(), stackTrace);
  }
 
  DelegateResponseError(const std::string& message, long HResult)
      : Error(message, std::string("DelegateResponseError"), ErrorType::DELEGATE_RESPONSE) {
    std::stringstream hrStream;
    hrStream << std::hex << HResult;
    AddDebugInfo(GetHResultString(), hrStream.str());
  }
 
  DelegateResponseError(const std::string& message)
      : Error(message, std::string("DelegateResponseError"), ErrorType::DELEGATE_RESPONSE) {
  }
 
  explicit DelegateResponseError(const Error& error) : Error(error) {
    mType = ErrorType::DELEGATE_RESPONSE;
  }
 
  std::shared_ptr<Error> Clone() const override {
    // There's nothing special about this class - a clone can simply call the copy constructor.
    auto result = std::make_shared<mip::DelegateResponseError>(*this);
    return std::static_pointer_cast<Error>(result);
  }
  
  ErrorType GetErrorType() const override { return ErrorType::DELEGATE_RESPONSE; }
 
  const std::exception_ptr& GetExceptionPtr() const { return mCurrentException; }
 
private:
  std::exception_ptr mCurrentException;
};
 
class InsufficientBufferError : public BadInputError {
public:
  explicit InsufficientBufferError(
      const std::string& message,
      const std::string& name = "InsufficientBufferError")
      : InsufficientBufferError(message, {{}}, {{}}, name) {}
  explicit InsufficientBufferError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "InsufficientBufferError")
      : BadInputError(message, debugInfo, sensitiveDebugInfo, name) {}
  std::shared_ptr<Error> Clone() const override { return std::make_shared<InsufficientBufferError>(*this); }
  ErrorType GetErrorType() const override { return ErrorType::INSUFFICIENT_BUFFER_ERROR; }
};
 
class FileIOError : public Error {
public:
  explicit FileIOError(
      const std::string& message,
      const std::string& name = "FileIOError")
      : FileIOError(message, {{}}, {{}}, name) {}
  explicit FileIOError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "FileIOError")
      : Error(message, debugInfo, sensitiveDebugInfo, name, ErrorType::FILE_IO_ERROR) {}
  std::shared_ptr<Error> Clone() const override { return std::make_shared<FileIOError>(*this); }
};
 
class NetworkError : public Error {
public:
  enum class Category {
    Unknown = 0, 
    FailureResponseCode = 1, 
    BadResponse = 2, 
    UnexpectedResponse = 3, 
    NoConnection = 4, 
    Proxy = 5, 
    SSL = 6, 
    Timeout = 7, 
    Offline = 8, 
    Throttled = 9, 
    Cancelled = 10, 
    FunctionNotImplemented = 11, 
    ServiceUnavailable = 12, 
  };
 
  explicit NetworkError(
      Category category,
      const std::string& sanitizedUrl,
      const std::string& requestId,
      int32_t statusCode,
      const std::string& message,
      const std::string& name = "NetworkError")
      : NetworkError(category, sanitizedUrl, requestId, statusCode, message, {{}}, {{}}, name) {}
 
  explicit NetworkError(
      Category category,
      const std::string& sanitizedUrl,
      const std::string& requestId,
      int32_t statusCode,
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "NetworkError")
      : NetworkError(category, statusCode, message, debugInfo, sensitiveDebugInfo, name) {
    if (!sanitizedUrl.empty())
      AddDebugInfo("HttpRequest.SanitizedUrl", sanitizedUrl);
    if (!requestId.empty())
      AddDebugInfo("HttpRequest.Id", requestId);
  }
 
  explicit NetworkError(
      Category category,
      int32_t statusCode,
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "NetworkError")
      : Error(message, debugInfo, sensitiveDebugInfo, name, ErrorType::NETWORK_ERROR),
        mCategory(category),
        mResponseStatusCode(statusCode) {
    AddDebugInfo("NetworkError.Category", GetCategoryString(category));
    if (statusCode != 0)
      AddDebugInfo("HttpResponse.StatusCode", std::to_string(static_cast<int>(statusCode)));
  }
 
  std::shared_ptr<Error> Clone() const override {
    return std::make_shared<NetworkError>(*this);
  }
  Category GetCategory() const { return mCategory; }
 
  int32_t GetResponseStatusCode() const { return mResponseStatusCode; }
 
private:
  Category mCategory;
  int32_t mResponseStatusCode;
 
  const std::string& GetCategoryString(Category category) const {
    static const std::string kUnrecognized = "UNRECOGNIZED";
    static const std::map<Category, std::string> kCategories = {
        { Category::Unknown,             "Unknown" },
        { Category::FailureResponseCode, "FailureResponseCode" },
        { Category::BadResponse,         "BadResponse" },
        { Category::UnexpectedResponse,  "UnexpectedResponse" },
        { Category::NoConnection,        "NoConnection" },
        { Category::Proxy,               "Proxy" },
        { Category::SSL,                 "SSL" },
        { Category::Timeout,             "Timeout" },
        { Category::Offline,             "Offline" },
        { Category::Throttled,           "Throttled" },
        { Category::ServiceUnavailable,  "ServiceUnavailable" },
        { Category::Cancelled,           "Cancelled" },
    };
    return kCategories.count(category) ? kCategories.at(category) : kUnrecognized;
  }
};
 
class ProxyAuthenticationError : public NetworkError {
public:
  explicit ProxyAuthenticationError(
      const std::string& sanitizedUrl,
      const std::string& requestId,
      int32_t statusCode,
      const std::string& message,
      const std::string& name = "ProxyAuthenticationError")
      : NetworkError(Category::Proxy, sanitizedUrl, requestId, statusCode, message, name) {}
  explicit ProxyAuthenticationError(
      int32_t statusCode,
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "ProxyAuthenticationError")
      : NetworkError(Category::Proxy, statusCode, message, debugInfo, sensitiveDebugInfo, name) {}
  std::shared_ptr<Error> Clone() const override {
    return std::make_shared<ProxyAuthenticationError>(*this);
  }
  ErrorType GetErrorType() const override { return ErrorType::PROXY_AUTH_ERROR; }
};
 
class InternalError : public Error {
public:
  explicit InternalError(
      const std::string& message,
      const std::string& name = "InternalError")
      : InternalError(message, {{}}, {{}}, name) {}
  explicit InternalError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "InternalError")
      : Error(message, debugInfo, sensitiveDebugInfo, name, ErrorType::INTERNAL_ERROR) {}
  std::shared_ptr<Error> Clone() const override { return std::make_shared<InternalError>(*this); }
};
 
class NotSupportedError : public Error {
public:
  explicit NotSupportedError(
      const std::string& message,
      const std::string& name = "NotSupportedError")
      : NotSupportedError(message, {{}}, {{}}, name) {}
  explicit NotSupportedError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "NotSupportedError")
      : Error(message, debugInfo, sensitiveDebugInfo, name, ErrorType::NOT_SUPPORTED_OPERATION) {}
  explicit NotSupportedError(
      const std::string& message,
      ErrorType errorType,
      const std::string& name = "NotSupportedError")
      : Error(message, name, errorType) {}
  std::shared_ptr<Error> Clone() const override { return std::make_shared<NotSupportedError>(*this); }
};
 
class PrivilegedRequiredError : public Error {
public:
  explicit PrivilegedRequiredError(
      const std::string& message,
      const std::string& name = "PrivilegedRequiredError")
      : PrivilegedRequiredError(message, {{}}, {{}}, name) {}
  explicit PrivilegedRequiredError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "PrivilegedRequiredError")
      : Error(message, debugInfo, sensitiveDebugInfo, name, ErrorType::PRIVILEGED_REQUIRED) {}
  std::shared_ptr<Error> Clone() const override { return std::make_shared<PrivilegedRequiredError>(*this); }
};
 
class AccessDeniedError : public Error {
public:
  explicit AccessDeniedError(
      const std::string& message,
      const std::string& name = "AccessDeniedError")
      : AccessDeniedError(message, {{}}, {{}}, name) {}
  explicit AccessDeniedError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "AccessDeniedError")
      : Error(message, debugInfo, sensitiveDebugInfo, name, ErrorType::ACCESS_DENIED) {}
  virtual std::shared_ptr<Error> Clone() const override { return std::make_shared<AccessDeniedError>(*this); }
};
 
class NoPermissionsError : public AccessDeniedError {
public:
  enum class Category {
    Unknown = 0, 
    UserNotFound = 1,           
    AccessDenied = 2,           
    AccessExpired = 3,          
    InvalidEmail = 4,
    UnknownTenant = 5,
    NotOwner = 6,               
    NotPremiumLicenseUser = 7,  
    ClientVersionNotSupported = 8, 
    /* The following 3 error categories are related to dynamic protection. In dynamic protection, the rights for content are stored in an online location
     where owners can have stronger ability to control access after a document has been shared */
    FileNotFound = 9,           
    ClientUnauthorized = 10,    
    InvalidToken = 11,          
  };
 
  explicit NoPermissionsError(
      Category category,
      const std::string& message,
      const std::string& referrer = "",
      const std::string& owner = "",
      const std::string& name = "NoPermissionsError")
      : NoPermissionsError(category, message, referrer, owner, {{}}, {{}}, name) {}
  explicit NoPermissionsError(
      Category category,
      const std::string& message,
      const std::string& referrer,
      const std::string& owner,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "NoPermissionsError")
      : AccessDeniedError(message, debugInfo, sensitiveDebugInfo, name), mCategory(category), mReferrer(referrer), mOwner(owner) {
        AddDebugInfo("NoPermissionsError.Category", GetCategoryString(mCategory));
        if (!referrer.empty())
          AddDebugInfo("NoPermissionsError.Referrer", referrer, true);
        if (!owner.empty())
          AddDebugInfo("NoPermissionsError.Owner", owner, true);
      }
#if !defined(SWIG) && !defined(SWIG_DIRECTORS)
    [[deprecated]]
#endif
  explicit NoPermissionsError(
      const std::string& message,
      const std::string& referrer,
      const std::string& owner,
      const std::string& name = "NoPermissionsError")
      : NoPermissionsError(Category::Unknown, message, referrer, owner, {{}}, {{}}, name) {}
#if !defined(SWIG) && !defined(SWIG_DIRECTORS)
    [[deprecated]]
#endif
  explicit NoPermissionsError(
      const std::string& message,
      const std::string& referrer,
      const std::string& owner,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "NoPermissionsError")
      : NoPermissionsError(Category::Unknown, message, referrer, owner, debugInfo, sensitiveDebugInfo, name) {}
  std::shared_ptr<Error> Clone() const override { return std::make_shared<NoPermissionsError>(*this); }
  ErrorType GetErrorType() const override { return ErrorType::NO_PERMISSIONS; }
  std::string GetReferrer() const { return mReferrer; }
 
  std::string GetOwner() const { return mOwner; }
 
  Category GetCategory() const { return mCategory; }
 
private:
  Category mCategory;
  std::string mReferrer;
  std::string mOwner;
 
  const std::string& GetCategoryString(Category category) const {
    static const std::string kUnrecognized = "UNRECOGNIZED";
    static const std::map<Category, std::string> kCategories = {
        { Category::Unknown,                    "Unknown" },
        { Category::UserNotFound,               "UserNotFound" },
        { Category::AccessDenied,               "AccessDenied" },
        { Category::AccessExpired,              "AccessExpired" },
        { Category::InvalidEmail,               "InvalidEmail" },
        { Category::UnknownTenant,              "UnknownTenant" },
        { Category::NotOwner,                   "NotOwner" },
        { Category::NotPremiumLicenseUser,      "NotPremiumLicenseUser" },
        { Category::ClientVersionNotSupported,  "ClientVersionNotSupported" },
        { Category::FileNotFound,               "FileNotFound" },
        { Category::ClientUnauthorized,         "ClientUnauthorized" },
        { Category::InvalidToken,               "InvalidToken" }
    };
    return kCategories.count(category) ? kCategories.at(category) : kUnrecognized;
  }
};
 
class NoPermissionsExtendedError : public NoPermissionsError {
public:
  explicit NoPermissionsExtendedError(Category category,
      const std::string& message,
      const std::string& referrer,
      const std::string& owner,
      const std::vector<ExtendedErrorInfo>& extendedErrorInfo,
      const std::string& name = GetNoPermissionsExtendedErrorName())
      : NoPermissionsError(category, message, referrer, owner, name),
        mExtendedErrorInfo(extendedErrorInfo) { AddExtendedErrorInfoToDebugInfo(extendedErrorInfo); }
 
  explicit NoPermissionsExtendedError(Category category,
      const std::string& message,
      const std::string& referrer,
      const std::string& owner,
      const std::map<std::string, std::string> debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::vector<ExtendedErrorInfo>& extendedErrorInfo,
      const std::string& name = GetNoPermissionsExtendedErrorName())
      : NoPermissionsError(category, message, referrer, owner, debugInfo, sensitiveDebugInfo, name),
        mExtendedErrorInfo(extendedErrorInfo) { AddExtendedErrorInfoToDebugInfo(extendedErrorInfo); }
  
  std::shared_ptr<Error> Clone() const override { return std::make_shared<NoPermissionsExtendedError>(*this); }
 
  std::vector<ExtendedErrorInfo> GetExtendedErrorInfo() const { 
    return mExtendedErrorInfo;
  }
private:
  void AddExtendedErrorInfoToDebugInfo(const std::vector<ExtendedErrorInfo>& extendedErrorInfo) {
    std::stringstream codesStream;
    std::stringstream messagesStream;
    std::stringstream detailsStream;
 
    static const std::string seperator = ",";
    static const std::string objSeperator = ";";
    static const std::string mapElementSeperator = "|";
    for (size_t i = 0; i < extendedErrorInfo.size(); i++) {
      codesStream << extendedErrorInfo[i].code;
      messagesStream << extendedErrorInfo[i].message;
      std::map<std::string, std::string>::const_iterator detailsIter = extendedErrorInfo[i].details.begin();
      while (detailsIter != extendedErrorInfo[i].details.end()) {
        detailsStream << detailsIter->first << seperator << detailsIter->second;
        detailsIter++;
        if (detailsIter != extendedErrorInfo[i].details.end()) {
          detailsStream << mapElementSeperator;
        }
      }
 
      if (i + 1 < extendedErrorInfo.size()) {
        codesStream << objSeperator;
        messagesStream << objSeperator;
        detailsStream << objSeperator;
      }
    }
 
    if (!extendedErrorInfo.empty()) {
      AddDebugInfo(GetErrorInfoCodesKey(), codesStream.str());
      AddDebugInfo(GetErrorInfoMessagesKey(), messagesStream.str());
      AddDebugInfo(GetErrorInfoDetailsKey(), detailsStream.str());
    }
  }
 
  std::vector<ExtendedErrorInfo> mExtendedErrorInfo;
};
 
class NoAuthTokenError : public AccessDeniedError {
public:
  explicit NoAuthTokenError(
      const std::string& message,
      const std::string& name = "NoAuthTokenError")
      : NoAuthTokenError(message, {{}}, {{}}, name) {}
  explicit NoAuthTokenError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "NoAuthTokenError")
      : AccessDeniedError(message, debugInfo, sensitiveDebugInfo, name) {}
  std::shared_ptr<Error> Clone() const override { return std::make_shared<NoAuthTokenError>(*this); }
  ErrorType GetErrorType() const override { return ErrorType::NO_AUTH_TOKEN; }
};
 
class ServiceDisabledError : public AccessDeniedError {
public:
  enum class Extent {
    User, 
    Device, 
    Platform, 
    Tenant, 
  };
 
  explicit ServiceDisabledError(
      Extent extent,
      const std::string& requestId,
      const std::string& message,
      const std::string& name = "ServiceDisabledError")
      : ServiceDisabledError(extent, message, {{}}, {{}}, name) {
    if (!requestId.empty())
      AddDebugInfo("HttpRequest.Id", requestId);
  }
  explicit ServiceDisabledError(
      Extent extent,
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "ServiceDisabledError")
      : AccessDeniedError(message, debugInfo, sensitiveDebugInfo, name),
        mExtent(extent) {
    AddDebugInfo("ServiceDisabledError.Extent", GetExtentString(extent));
  }
 
  std::shared_ptr<Error> Clone() const override { return std::make_shared<ServiceDisabledError>(*this); }
  ErrorType GetErrorType() const override { return ErrorType::DISABLED_SERVICE; }
  Extent GetExtent() const { return mExtent; }
 
private:
  const std::string& GetExtentString(Extent extent) const {
    static const std::string kUnrecognized = "UNRECOGNIZED";
    static const std::map<Extent, std::string> kExtents = {
        { Extent::User,     "User" },
        { Extent::Device,   "Device" },
        { Extent::Platform, "Platform" },
        { Extent::Tenant,   "Tenant" },
    };
    return kExtents.count(extent) ? kExtents.at(extent) : kUnrecognized;
  }
 
  Extent mExtent;
};
 
class ConsentDeniedError : public Error {
public:
  explicit ConsentDeniedError(
      const std::string& message,
      const std::string& name = "ConsentDeniedError")
      : ConsentDeniedError(message, {{}}, {{}}, name) {}
  explicit ConsentDeniedError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "ConsentDeniedError")
      : Error(message, debugInfo, sensitiveDebugInfo, name, ErrorType::CONSENT_DENIED) {}
  std::shared_ptr<Error> Clone() const override { return std::make_shared<ConsentDeniedError>(*this); }
};
 
class NoPolicyError : public Error {
public:
  enum class Category {
    SyncFile, 
    Labels,   
    Rules     
  };
  
  explicit NoPolicyError(
      const std::string& message,
      const Category category,
      const std::string& name = "NoPolicyError")
    : NoPolicyError(message, category, {{}}, {{}}, name) {}
  explicit NoPolicyError(
      const std::string& message,
      const Category category,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "NoPolicyError")
    : Error(message, debugInfo, sensitiveDebugInfo, name, ErrorType::NO_POLICY),
      mCategory(category) {
    AddDebugInfo("NoPolicyError.Category", GetCategoryString(category));
  }
  
  std::shared_ptr<Error> Clone() const override { return std::make_shared<NoPolicyError>(*this); }
  Category GetCategory() const { return mCategory; }
private:
  const std::string& GetCategoryString(Category category) const {
    static const std::string kUnrecognized = "UNRECOGNIZED";
    static const std::map<Category, std::string> kCategories = {
        { Category::SyncFile,             "SyncFile" },
        { Category::Labels,               "Labels" },
        { Category::Rules,                "Rules" },
    };
    return kCategories.count(category) ? kCategories.at(category) : kUnrecognized;
  }
 
  Category mCategory;
};
 
class OperationCancelledError : public Error {
public:
  explicit OperationCancelledError(
      const std::string& message,
      const std::string& name = "OperationCancelledError")
      : OperationCancelledError(message, {{}}, {{}}, name) {}
  explicit OperationCancelledError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "OperationCancelledError")
      : Error(message, debugInfo, sensitiveDebugInfo, name, ErrorType::OPERATION_CANCELLED) {}
  std::shared_ptr<Error> Clone() const override { return std::make_shared<OperationCancelledError>(*this); }
};
 
class AdhocProtectionRequiredError : public Error {
public:
  explicit AdhocProtectionRequiredError(
      const std::string& message,
      const std::string& name = "AdhocProtectionRequiredError")
      : AdhocProtectionRequiredError(message, {{}}, {{}}, name) {}
  explicit AdhocProtectionRequiredError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "AdhocProtectionRequiredError")
      : Error(message, debugInfo, sensitiveDebugInfo, name, ErrorType::ADHOC_PROTECTION_REQUIRED) {}
  std::shared_ptr<Error> Clone() const override { return std::make_shared<AdhocProtectionRequiredError>(*this); }
};
 
class DeprecatedApiError : public Error {
public:
  explicit DeprecatedApiError(
      const std::string& message,
      const std::string& name = "DeprecatedApiError")
      : DeprecatedApiError(message, {{}}, {{}}, name) {}
  explicit DeprecatedApiError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "DeprecatedApiError")
      : Error(message, debugInfo, sensitiveDebugInfo, name, ErrorType::DEPRECATED_API) {}
  std::shared_ptr<Error> Clone() const override { return std::make_shared<DeprecatedApiError>(*this); }
};
 
class TemplateNotFoundError : public BadInputError {
public:
  explicit TemplateNotFoundError(
      const std::string& message,
      const std::string& name = "TemplateNotFoundError")
      : TemplateNotFoundError(message, {{}}, {{}}, name) {}
  explicit TemplateNotFoundError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "TemplateNotFoundError")
      : BadInputError(message, debugInfo, sensitiveDebugInfo, name) {}
 
  std::shared_ptr<Error> Clone() const override { return std::make_shared<TemplateNotFoundError>(*this); }
  ErrorType GetErrorType() const override { return ErrorType::TEMPLATE_NOT_FOUND; }
};
 
class TemplateArchivedError : public BadInputError {
public:
  explicit TemplateArchivedError(
      const std::string& message,
      const std::string& name = "TemplateArchivedError")
      : TemplateArchivedError(message, {{}}, {{}}, name) {}
  explicit TemplateArchivedError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "TemplateArchivedError")
      : BadInputError(message, debugInfo, sensitiveDebugInfo, name) {}
 
  std::shared_ptr<Error> Clone() const override { return std::make_shared<TemplateArchivedError>(*this); }
  ErrorType GetErrorType() const override { return ErrorType::TEMPLATE_ARCHIVED; }
};
 
class ContentFormatNotSupportedError : public BadInputError {
public:
  explicit ContentFormatNotSupportedError(
      const std::string& message,
      const std::string& name = "ContentFormatNotSupportedError")
      : ContentFormatNotSupportedError(message, {{}}, {{}}, name) {}
  explicit ContentFormatNotSupportedError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "ContentFormatNotSupportedError")
      : BadInputError(message, debugInfo, sensitiveDebugInfo, name) {}
 
  std::shared_ptr<Error> Clone() const override { return std::make_shared<ContentFormatNotSupportedError>(*this); }
  ErrorType GetErrorType() const override { return ErrorType::CONTENT_FORMAT_NOT_SUPPORTED; }
};
 
class LabelNotFoundError : public BadInputError {
public:
  explicit LabelNotFoundError(
      const std::string& message,
      const std::string& name = "LabelNotFoundError")
      : LabelNotFoundError(message, {{}}, {{}}, name) {}
  explicit LabelNotFoundError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "LabelNotFoundError")
      : BadInputError(message, debugInfo, sensitiveDebugInfo, name) {}
 
  std::shared_ptr<Error> Clone() const override { return std::make_shared<LabelNotFoundError>(*this); }
  ErrorType GetErrorType() const override { return ErrorType::LABEL_NOT_FOUND; }
};
 
class LicenseNotRegisteredError : public BadInputError {
public:
  explicit LicenseNotRegisteredError(
      const std::string& message,
      const std::string& name = "LicenseNotRegisteredError")
      : LicenseNotRegisteredError(message, {{}}, {{}}, name) {}
  explicit LicenseNotRegisteredError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "LicenseNotRegisteredError")
      : BadInputError(message, debugInfo, sensitiveDebugInfo, name) {}
 
  std::shared_ptr<Error> Clone() const override { return std::make_shared<LicenseNotRegisteredError>(*this); }
  ErrorType GetErrorType() const override { return ErrorType::LICENSE_NOT_REGISTERED; }
};
 
class LabelDisabledError : public BadInputError {
public:
  explicit LabelDisabledError(
      const std::string& message,
      const std::string& name = "LabelDisabledError")
      : LabelDisabledError(message, {{}}, {{}}, name) {}
  explicit LabelDisabledError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "LabelDisabledError")
      : BadInputError(message, debugInfo, sensitiveDebugInfo, name) {}
  std::shared_ptr<Error> Clone() const override { return std::make_shared<LabelDisabledError>(*this); }
  ErrorType GetErrorType() const override { return ErrorType::LABEL_DISABLED; }
};
 
class CustomerKeyUnavailableError : public AccessDeniedError {
public:
  explicit CustomerKeyUnavailableError(
      const std::string& message,
      const std::string& name = "CustomerKeyUnavailableError")
      : CustomerKeyUnavailableError(message, {{}}, {{}}, name) {}
  explicit CustomerKeyUnavailableError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string>& sensitiveDebugInfo,
      const std::string& name = "CustomerKeyUnavailableError")
      : AccessDeniedError(message, debugInfo, sensitiveDebugInfo, name) {}
  std::shared_ptr<Error> Clone() const override { return std::make_shared<CustomerKeyUnavailableError>(*this); }
  ErrorType GetErrorType() const override { return ErrorType::CUSTOMER_KEY_UNAVAILABLE; }
};
 
class MaxDepthReachedError : public Error {
public:
  explicit MaxDepthReachedError(
      const std::string& message,
      const std::string& name = "MaxDepthReachedError")
      : MaxDepthReachedError(message, {{}}, {{}}, name) {}
  explicit MaxDepthReachedError(
      const std::string& message,
      const std::map<std::string, std::string>& debugInfo,
      const std::map<std::string, std::string> sensitiveDebugInfo,
      const std::string& name = "MaxDepthReachedError")
      : Error(message, debugInfo, sensitiveDebugInfo, name, ErrorType::MAX_DEPTH_REACHED) {}
  std::shared_ptr<Error> Clone() const override { return std::make_shared<MaxDepthReachedError>(*this); }
};
 
MIP_NAMESPACE_END
 
#endif  // API_MIP_ERROR_H_