smartbotic/lib/credentials/credential_client.cpp

#include "credential_client.hpp"
#include "logging/logger.hpp"

namespace smartbotic::credentials {

using namespace common;

CredentialClient::CredentialClient(const CredentialClientConfig& config)
    : config_(config) {

    channel_ = grpc::CreateChannel(config_.address, grpc::InsecureChannelCredentials());
    stub_ = proto::CredentialService::NewStub(channel_);

    LOG_INFO("CredentialClient initialized with address: {}", config_.address);
}

Result<HttpAuth> CredentialClient::getHttpAuth(const std::string& credential_id,
                                               const std::string& workflow_id) {
    proto::GetCredentialAuthRequest request;
    request.set_credential_id(credential_id);
    request.set_workflow_id(workflow_id);

    proto::GetCredentialAuthResponse response;
    grpc::ClientContext context;

    // Set timeout
    auto deadline = std::chrono::system_clock::now() +
                   std::chrono::milliseconds(config_.timeout_ms);
    context.set_deadline(deadline);

    grpc::Status status = stub_->GetCredentialAuth(&context, request, &response);

    if (!status.ok()) {
        return Error(ErrorCode::Unavailable,
                    "Credential service error: " + status.error_message());
    }

    if (!response.success()) {
        return Error(ErrorCode::NotFound, response.error());
    }

    HttpAuth auth;
    auth.header_name = response.header_name();
    auth.header_value = response.header_value();

    return auth;
}

Result<ImapData> CredentialClient::getImapCredentials(const std::string& credential_id,
                                                       const std::string& workflow_id) {
    proto::GetImapCredentialsRequest request;
    request.set_credential_id(credential_id);
    request.set_workflow_id(workflow_id);

    proto::GetImapCredentialsResponse response;
    grpc::ClientContext context;

    // Set timeout
    auto deadline = std::chrono::system_clock::now() +
                   std::chrono::milliseconds(config_.timeout_ms);
    context.set_deadline(deadline);

    grpc::Status status = stub_->GetImapCredentials(&context, request, &response);

    if (!status.ok()) {
        return Error(ErrorCode::Unavailable,
                    "Credential service error: " + status.error_message());
    }

    if (!response.success()) {
        return Error(ErrorCode::NotFound, response.error());
    }

    ImapData data;
    data.host = response.host();
    data.port = response.port();
    data.username = response.username();
    data.password = response.password();
    data.use_ssl = response.use_ssl();

    return data;
}

Result<ClientCertificateData> CredentialClient::getClientCertificate(
    const std::string& credential_id, const std::string& workflow_id) {
    proto::GetClientCertificateRequest request;
    request.set_credential_id(credential_id);
    request.set_workflow_id(workflow_id);

    proto::GetClientCertificateResponse response;
    grpc::ClientContext context;

    auto deadline = std::chrono::system_clock::now() +
                   std::chrono::milliseconds(config_.timeout_ms);
    context.set_deadline(deadline);

    grpc::Status status = stub_->GetClientCertificate(&context, request, &response);

    if (!status.ok()) {
        return Error(ErrorCode::Unavailable,
                    "Credential service error: " + status.error_message());
    }

    if (!response.success()) {
        return Error(ErrorCode::NotFound, response.error());
    }

    ClientCertificateData data;
    data.certificate_pem = response.certificate_pem();
    data.private_key_pem = response.private_key_pem();
    data.passphrase = response.passphrase();

    return data;
}

Result<SmtpData> CredentialClient::getSmtpCredentials(const std::string& credential_id,
                                                       const std::string& workflow_id) {
    proto::GetSmtpCredentialsRequest request;
    request.set_credential_id(credential_id);
    request.set_workflow_id(workflow_id);

    proto::GetSmtpCredentialsResponse response;
    grpc::ClientContext context;

    auto deadline = std::chrono::system_clock::now() +
                   std::chrono::milliseconds(config_.timeout_ms);
    context.set_deadline(deadline);

    grpc::Status status = stub_->GetSmtpCredentials(&context, request, &response);

    if (!status.ok()) {
        return Error(ErrorCode::Unavailable,
                    "Credential service error: " + status.error_message());
    }

    if (!response.success()) {
        return Error(ErrorCode::NotFound, response.error());
    }

    SmtpData data;
    data.host = response.host();
    data.port = response.port();
    data.username = response.username();
    data.password = response.password();
    data.security = response.security();
    data.from_address = response.from_address();
    data.from_name = response.from_name();

    return data;
}

Result<MysqlData> CredentialClient::getMysqlCredentials(const std::string& credential_id,
                                                         const std::string& workflow_id) {
    proto::GetMysqlCredentialsRequest request;
    request.set_credential_id(credential_id);
    request.set_workflow_id(workflow_id);

    proto::GetMysqlCredentialsResponse response;
    grpc::ClientContext context;

    // Set timeout
    auto deadline = std::chrono::system_clock::now() +
                   std::chrono::milliseconds(config_.timeout_ms);
    context.set_deadline(deadline);

    grpc::Status status = stub_->GetMysqlCredentials(&context, request, &response);

    if (!status.ok()) {
        return Error(ErrorCode::Unavailable,
                    "Credential service error: " + status.error_message());
    }

    if (!response.success()) {
        return Error(ErrorCode::NotFound, response.error());
    }

    MysqlData data;
    data.host = response.host();
    data.port = response.port();
    data.username = response.username();
    data.password = response.password();
    data.database = response.database();
    data.use_ssl = response.use_ssl();

    return data;
}

Result<PostgresqlData> CredentialClient::getPostgresqlCredentials(const std::string& credential_id,
                                                                   const std::string& workflow_id) {
    proto::GetPostgresqlCredentialsRequest request;
    request.set_credential_id(credential_id);
    request.set_workflow_id(workflow_id);

    proto::GetPostgresqlCredentialsResponse response;
    grpc::ClientContext context;

    // Set timeout
    auto deadline = std::chrono::system_clock::now() +
                   std::chrono::milliseconds(config_.timeout_ms);
    context.set_deadline(deadline);

    grpc::Status status = stub_->GetPostgresqlCredentials(&context, request, &response);

    if (!status.ok()) {
        return Error(ErrorCode::Unavailable,
                    "Credential service error: " + status.error_message());
    }

    if (!response.success()) {
        return Error(ErrorCode::NotFound, response.error());
    }

    PostgresqlData data;
    data.host = response.host();
    data.port = response.port();
    data.username = response.username();
    data.password = response.password();
    data.database = response.database();
    data.use_ssl = response.use_ssl();

    return data;
}

Result<std::vector<CredentialInfo>> CredentialClient::listCredentials(const std::string& workflow_id) {
    proto::ListCredentialsRequest request;
    request.set_workflow_id(workflow_id);

    proto::ListCredentialsResponse response;
    grpc::ClientContext context;

    auto deadline = std::chrono::system_clock::now() +
                   std::chrono::milliseconds(config_.timeout_ms);
    context.set_deadline(deadline);

    grpc::Status status = stub_->ListCredentials(&context, request, &response);

    if (!status.ok()) {
        return Error(ErrorCode::Unavailable,
                    "Credential service error: " + status.error_message());
    }

    std::vector<CredentialInfo> credentials;
    for (const auto& cred : response.credentials()) {
        CredentialInfo info;
        info.id = cred.id();
        info.name = cred.name();
        info.type = credentialTypeFromString(cred.type());
        info.description = cred.description();
        credentials.push_back(info);
    }

    return credentials;
}

bool CredentialClient::isConnected() const {
    if (!channel_) return false;
    auto state = channel_->GetState(false);
    return state == GRPC_CHANNEL_READY || state == GRPC_CHANNEL_IDLE;
}

} // namespace smartbotic::credentials