GpgKeyOpera.h

 
#pragma once
 
#include <functional>
 
#include "core/function/gpg/GpgContext.h"
#include "core/typedef/GpgTypedef.h"
 
namespace GpgFrontend {
class GenKeyInfo;
 
class GPGFRONTEND_CORE_EXPORT GpgKeyOpera
    : public SingletonFunctionObject<GpgKeyOpera> {
 public:
  explicit GpgKeyOpera(
      int channel = SingletonFunctionObject::GetDefaultChannel());
 
  void DeleteKeys(KeyIdArgsListPtr key_ids);
 
  void DeleteKey(const KeyId& key_id);
 
  auto SetExpire(const GpgKey& key, const SubkeyId& subkey_fpr,
                 std::unique_ptr<QDateTime>& expires) -> GpgError;
 
  void GenerateRevokeCert(const GpgKey& key, const QString& output_path);
 
  void ModifyPassword(const GpgKey& key, const GpgOperationCallback&);
 
  auto ModifyTOFUPolicy(const GpgKey& key, gpgme_tofu_policy_t tofu_policy)
      -> GpgFrontend::GpgError;
  void GenerateKey(const std::shared_ptr<GenKeyInfo>&,
                   const GpgOperationCallback&);
 
  auto GenerateKeySync(const std::shared_ptr<GenKeyInfo>& params)
      -> std::tuple<GpgError, DataObjectPtr>;
 
  void GenerateSubkey(const GpgKey& key,
                      const std::shared_ptr<GenKeyInfo>& params,
                      const GpgOperationCallback&);
 
  auto GenerateSubkeySync(const GpgKey& key,
                          const std::shared_ptr<GenKeyInfo>& params)
      -> std::tuple<GpgError, DataObjectPtr>;
 
  void GenerateKeyWithSubkey(const std::shared_ptr<GenKeyInfo>& params,
                             const std::shared_ptr<GenKeyInfo>& subkey_params,
                             const GpgOperationCallback& callback);
 
  auto GenerateKeyWithSubkeySync(
      const std::shared_ptr<GenKeyInfo>& params,
      const std::shared_ptr<GenKeyInfo>& subkey_params)
      -> std::tuple<GpgError, DataObjectPtr>;
 
 private:
  GpgContext& ctx_ =
      GpgContext::GetInstance(SingletonFunctionObject::GetChannel());  
};
}  // namespace GpgFrontend