From 416db4c79203f56d8a4c58014371c49309339018 Mon Sep 17 00:00:00 2001 From: llnulldisk <48621230+llnulldisk@users.noreply.github.com> Date: Wed, 31 Aug 2022 00:09:33 +0200 Subject: Fix #192 --- src/Api.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/Api.cpp b/src/Api.cpp index 9cb7f6e..77e8c0b 100644 --- a/src/Api.cpp +++ b/src/Api.cpp @@ -528,7 +528,7 @@ Message::Ptr Api::sendPoll(std::int64_t chatId, const std::string& question, con args.emplace_back("chat_id", chatId); args.emplace_back("question", question); args.emplace_back("options", _tgTypeParser.parseArray([] (const std::string& option) -> std::string { - return StringTools::urlEncode(option); + return "\"" + StringTools::urlEncode(option) + "\""; }, options)); if (!isAnonymous) { args.emplace_back("is_anonymous", isAnonymous); -- cgit v1.2.3 From edb32270990eb194459622701ebba1b64192303c Mon Sep 17 00:00:00 2001 From: llnulldisk <48621230+llnulldisk@users.noreply.github.com> Date: Wed, 31 Aug 2022 17:50:50 +0200 Subject: Add Telegram Passport --- src/Api.cpp | 29 ++- src/TgTypeParser.cpp | 359 ++++++++++++++++++++++++++++++++++++- src/types/PassportElementError.cpp | 23 +++ 3 files changed, 390 insertions(+), 21 deletions(-) create mode 100644 src/types/PassportElementError.cpp (limited to 'src') diff --git a/src/Api.cpp b/src/Api.cpp index 77e8c0b..070d72e 100644 --- a/src/Api.cpp +++ b/src/Api.cpp @@ -570,12 +570,6 @@ Message::Ptr Api::sendPoll(std::int64_t chatId, const std::string& question, con return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendPoll", args)); } -Message::Ptr Api::sendPoll(std::int64_t chatId, const std::string& question, const std::vector& options, - bool disableNotification, std::int32_t replyToMessageId, GenericReply::Ptr replyMarkup) const { - - return sendPoll(chatId, question, options, true, "", false, 0, "", "", 0, 0, false, false, 0); -} - Message::Ptr Api::sendDice(std::int64_t chatId, const std::string& emoji, bool disableNotification, std::int32_t replyToMessageId, GenericReply::Ptr replyMarkup) const { vector args; @@ -1053,13 +1047,6 @@ bool Api::createNewStickerSet(std::int64_t userId, const std::string& name, cons return sendRequest("createNewStickerSet", args).get("", false); } -bool Api::createNewStickerSet(std::int64_t userId, const std::string& name, const std::string& title, - boost::variant pngSticker, const std::string& emojis, bool containsMasks, - MaskPosition::Ptr maskPosition) const { - - return createNewStickerSet(userId, name, title, emojis, pngSticker, "", containsMasks, maskPosition); -} - bool Api::addStickerToSet(std::int64_t userId, const std::string& name, const std::string& emojis, boost::variant pngSticker, boost::variant tgsSticker, MaskPosition::Ptr maskPosition) const { vector args; @@ -1087,12 +1074,6 @@ bool Api::addStickerToSet(std::int64_t userId, const std::string& name, const st return sendRequest("addStickerToSet", args).get("", false); } -bool Api::addStickerToSet(std::int64_t userId, const std::string& name, boost::variant pngSticker, - const std::string& emojis, MaskPosition::Ptr maskPosition) const { - - return addStickerToSet(userId, name, emojis, pngSticker, "", maskPosition); -} - bool Api::setStickerPositionInSet(const string& sticker, std::uint32_t position) const { vector args; args.reserve(2); @@ -1239,6 +1220,16 @@ bool Api::answerPreCheckoutQuery(const std::string& preCheckoutQueryId, bool ok, return sendRequest("answerPreCheckoutQuery", args).get("", false); } +bool Api::setPassportDataErrors(std::int64_t userId, const std::vector& errors) const { + vector args; + args.reserve(2); + + args.emplace_back("user_id", userId); + args.emplace_back("errors", _tgTypeParser.parseArray(&TgTypeParser::parsePassportElementError, errors)); + + return sendRequest("setPassportDataErrors", args).get("", false); +} + Message::Ptr Api::sendGame(std::int64_t chatId, const std::string& gameShortName, std::int32_t replyToMessageId, const InlineKeyboardMarkup::Ptr replyMarkup, bool disableNotification) const { vector args; args.reserve(5); diff --git a/src/TgTypeParser.cpp b/src/TgTypeParser.cpp index daa6184..89cdd4c 100644 --- a/src/TgTypeParser.cpp +++ b/src/TgTypeParser.cpp @@ -180,7 +180,7 @@ Message::Ptr TgTypeParser::parseJsonAndGetMessage(const ptree& data) const { result->invoice = tryParseJson(&TgTypeParser::parseJsonAndGetInvoice, data, "invoice"); result->successfulPayment = tryParseJson(&TgTypeParser::parseJsonAndGetSuccessfulPayment, data, "successful_payment"); result->connectedWebsite = data.get("connected_website", ""); - // result->passportData = tryParseJson(&TgTypeParser::parseJsonAndGetPassportData, data, "passport_data"); + result->passportData = tryParseJson(&TgTypeParser::parseJsonAndGetPassportData, data, "passport_data"); result->replyMarkup = tryParseJson(&TgTypeParser::parseJsonAndGetInlineKeyboardMarkup, data, "reply_markup"); result->automaticForward = data.get("is_automatic_forward", false); return result; @@ -239,7 +239,7 @@ string TgTypeParser::parseMessage(const Message::Ptr& object) const { appendToJson(result, "invoice", parseInvoice(object->invoice)); appendToJson(result, "successful_payment", parseSuccessfulPayment(object->successfulPayment)); appendToJson(result, "connected_website", object->connectedWebsite); - // appendToJson(result, "passport_data", parsePassportData(object->passportData)); + appendToJson(result, "passport_data", parsePassportData(object->passportData)); appendToJson(result, "reply_markup", parseInlineKeyboardMarkup(object->replyMarkup)); appendToJson(result, "is_automatic_forward", object->automaticForward); removeLastComma(result); @@ -2403,6 +2403,361 @@ std::string TgTypeParser::parseSuccessfulPayment(const SuccessfulPayment::Ptr& o return result; } +PassportData::Ptr TgTypeParser::parseJsonAndGetPassportData(const ptree& data) const { + auto result(make_shared()); + result->data = parseJsonAndGetArray(&TgTypeParser::parseJsonAndGetEncryptedPassportElement, data, "data"); + result->credentials = tryParseJson(&TgTypeParser::parseJsonAndGetEncryptedCredentials, data, "credentials"); + return result; +} + +string TgTypeParser::parsePassportData(const PassportData::Ptr& object) const { + if (!object) { + return ""; + } + string result; + result += '{'; + appendToJson(result, "data", parseArray(&TgTypeParser::parseEncryptedPassportElement, object->data)); + appendToJson(result, "credentials", parseEncryptedCredentials(object->credentials)); + removeLastComma(result); + result += '}'; + return result; +} + +PassportFile::Ptr TgTypeParser::parseJsonAndGetPassportFile(const ptree& data) const { + auto result(make_shared()); + result->fileId = data.get("file_id", ""); + result->fileUniqueId = data.get("file_unique_id", ""); + result->fileSize = data.get("file_size", 0); + result->fileDate = data.get("file_date", 0); + return result; +} + +string TgTypeParser::parsePassportFile(const PassportFile::Ptr& object) const { + if (!object) { + return ""; + } + string result; + result += '{'; + appendToJson(result, "file_id", object->fileId); + appendToJson(result, "file_unique_id", object->fileUniqueId); + appendToJson(result, "file_size", object->fileSize); + appendToJson(result, "file_date", object->fileDate); + removeLastComma(result); + result += '}'; + return result; +} + +EncryptedPassportElement::Ptr TgTypeParser::parseJsonAndGetEncryptedPassportElement(const ptree& data) const { + auto result(make_shared()); + result->type = data.get("type", ""); + result->data = data.get("data", ""); + result->phoneNumber = data.get("phone_number", ""); + result->email = data.get("email", ""); + result->files = parseJsonAndGetArray(&TgTypeParser::parseJsonAndGetPassportFile, data, "files"); + result->frontSide = tryParseJson(&TgTypeParser::parseJsonAndGetPassportFile, data, "front_side"); + result->reverseSide = tryParseJson(&TgTypeParser::parseJsonAndGetPassportFile, data, "reverse_side"); + result->selfie = tryParseJson(&TgTypeParser::parseJsonAndGetPassportFile, data, "selfie"); + result->translation = parseJsonAndGetArray(&TgTypeParser::parseJsonAndGetPassportFile, data, "translation"); + result->hash = data.get("hash", ""); + return result; +} + +string TgTypeParser::parseEncryptedPassportElement(const EncryptedPassportElement::Ptr& object) const { + if (!object) { + return ""; + } + string result; + result += '{'; + appendToJson(result, "type", object->type); + appendToJson(result, "data", object->data); + appendToJson(result, "phone_number", object->phoneNumber); + appendToJson(result, "email", object->email); + appendToJson(result, "files", parseArray(&TgTypeParser::parsePassportFile, object->files)); + appendToJson(result, "front_side", parsePassportFile(object->frontSide)); + appendToJson(result, "reverse_side", parsePassportFile(object->reverseSide)); + appendToJson(result, "selfie", parsePassportFile(object->selfie)); + appendToJson(result, "translation", parseArray(&TgTypeParser::parsePassportFile, object->translation)); + appendToJson(result, "hash", object->hash); + removeLastComma(result); + result += '}'; + return result; +} + +EncryptedCredentials::Ptr TgTypeParser::parseJsonAndGetEncryptedCredentials(const ptree& data) const { + auto result(make_shared()); + result->data = data.get("data", ""); + result->hash = data.get("hash", ""); + result->secret = data.get("secret", ""); + return result; +} + +string TgTypeParser::parseEncryptedCredentials(const EncryptedCredentials::Ptr& object) const { + if (!object) { + return ""; + } + string result; + result += '{'; + appendToJson(result, "data", object->data); + appendToJson(result, "hash", object->hash); + appendToJson(result, "secret", object->secret); + removeLastComma(result); + result += '}'; + return result; +} + +PassportElementError::Ptr TgTypeParser::parseJsonAndGetPassportElementError(const ptree& data) const { + string source = data.get("source", ""); + PassportElementError::Ptr result; + + if (source == PassportElementErrorDataField::SOURCE) { + result = static_pointer_cast(parseJsonAndGetPassportElementErrorDataField(data)); + } else if (source == PassportElementErrorFrontSide::SOURCE) { + result = static_pointer_cast(parseJsonAndGetPassportElementErrorFrontSide(data)); + } else if (source == PassportElementErrorReverseSide::SOURCE) { + result = static_pointer_cast(parseJsonAndGetPassportElementErrorReverseSide(data)); + } else if (source == PassportElementErrorSelfie::SOURCE) { + result = static_pointer_cast(parseJsonAndGetPassportElementErrorSelfie(data)); + } else if (source == PassportElementErrorFile::SOURCE) { + result = static_pointer_cast(parseJsonAndGetPassportElementErrorFile(data)); + } else if (source == PassportElementErrorFiles::SOURCE) { + result = static_pointer_cast(parseJsonAndGetPassportElementErrorFiles(data)); + } else if (source == PassportElementErrorTranslationFile::SOURCE) { + result = static_pointer_cast(parseJsonAndGetPassportElementErrorTranslationFile(data)); + } else if (source == PassportElementErrorTranslationFiles::SOURCE) { + result = static_pointer_cast(parseJsonAndGetPassportElementErrorTranslationFiles(data)); + } else if (source == PassportElementErrorUnspecified::SOURCE) { + result = static_pointer_cast(parseJsonAndGetPassportElementErrorUnspecified(data)); + } else { + result = make_shared(); + } + + result->source = data.get("source", ""); + result->type = data.get("type", ""); + result->message = data.get("message", ""); + + return result; +} + +string TgTypeParser::parsePassportElementError(const PassportElementError::Ptr& object) const { + if (!object) { + return ""; + } + string result; + result += '{'; + appendToJson(result, "source", object->source); + appendToJson(result, "type", object->type); + appendToJson(result, "message", object->message); + + if (object->source == PassportElementErrorDataField::SOURCE) { + result += parsePassportElementErrorDataField(static_pointer_cast(object)); + } else if (object->source == PassportElementErrorFrontSide::SOURCE) { + result += parsePassportElementErrorFrontSide(static_pointer_cast(object)); + } else if (object->source == PassportElementErrorReverseSide::SOURCE) { + result += parsePassportElementErrorReverseSide(static_pointer_cast(object)); + } else if (object->source == PassportElementErrorSelfie::SOURCE) { + result += parsePassportElementErrorSelfie(static_pointer_cast(object)); + } else if (object->source == PassportElementErrorFile::SOURCE) { + result += parsePassportElementErrorFile(static_pointer_cast(object)); + } else if (object->source == PassportElementErrorFiles::SOURCE) { + result += parsePassportElementErrorFiles(static_pointer_cast(object)); + } else if (object->source == PassportElementErrorTranslationFile::SOURCE) { + result += parsePassportElementErrorTranslationFile(static_pointer_cast(object)); + } else if (object->source == PassportElementErrorTranslationFiles::SOURCE) { + result += parsePassportElementErrorTranslationFiles(static_pointer_cast(object)); + } else if (object->source == PassportElementErrorUnspecified::SOURCE) { + result += parsePassportElementErrorUnspecified(static_pointer_cast(object)); + } + + removeLastComma(result); + result += '}'; + return result; +} + +PassportElementErrorDataField::Ptr TgTypeParser::parseJsonAndGetPassportElementErrorDataField(const ptree& data) const { + // NOTE: This function will be called by parseJsonAndGetPassportElementError(). + auto result(make_shared()); + result->fieldName = data.get("field_name", ""); + result->dataHash = data.get("data_hash", ""); + return result; +} + +string TgTypeParser::parsePassportElementErrorDataField(const PassportElementErrorDataField::Ptr& object) const { + if (!object) { + return ""; + } + // This function will be called by parsePassportElementError(), so I don't add + // curly brackets to the result string. + string result; + appendToJson(result, "field_name", object->fieldName); + appendToJson(result, "data_hash", object->dataHash); + // The last comma will be erased by parsePassportElementError(). + return result; +} + +PassportElementErrorFrontSide::Ptr TgTypeParser::parseJsonAndGetPassportElementErrorFrontSide(const ptree& data) const { + // NOTE: This function will be called by parseJsonAndGetPassportElementError(). + auto result(make_shared()); + result->fileHash = data.get("file_hash", ""); + return result; +} + +string TgTypeParser::parsePassportElementErrorFrontSide(const PassportElementErrorFrontSide::Ptr& object) const { + if (!object) { + return ""; + } + // This function will be called by parsePassportElementError(), so I don't add + // curly brackets to the result string. + string result; + appendToJson(result, "file_hash", object->fileHash); + // The last comma will be erased by parsePassportElementError(). + return result; +} + +PassportElementErrorReverseSide::Ptr TgTypeParser::parseJsonAndGetPassportElementErrorReverseSide(const ptree& data) const { + // NOTE: This function will be called by parseJsonAndGetPassportElementError(). + auto result(make_shared()); + result->fileHash = data.get("file_hash", ""); + return result; +} + +string TgTypeParser::parsePassportElementErrorReverseSide(const PassportElementErrorReverseSide::Ptr& object) const { + if (!object) { + return ""; + } + // This function will be called by parsePassportElementError(), so I don't add + // curly brackets to the result string. + string result; + appendToJson(result, "file_hash", object->fileHash); + // The last comma will be erased by parsePassportElementError(). + return result; +} + +PassportElementErrorSelfie::Ptr TgTypeParser::parseJsonAndGetPassportElementErrorSelfie(const ptree& data) const { + // NOTE: This function will be called by parseJsonAndGetPassportElementError(). + auto result(make_shared()); + result->fileHash = data.get("file_hash", ""); + return result; +} + +string TgTypeParser::parsePassportElementErrorSelfie(const PassportElementErrorSelfie::Ptr& object) const { + if (!object) { + return ""; + } + // This function will be called by parsePassportElementError(), so I don't add + // curly brackets to the result string. + string result; + appendToJson(result, "file_hash", object->fileHash); + // The last comma will be erased by parsePassportElementError(). + return result; +} + +PassportElementErrorFile::Ptr TgTypeParser::parseJsonAndGetPassportElementErrorFile(const ptree& data) const { + // NOTE: This function will be called by parseJsonAndGetPassportElementError(). + auto result(make_shared()); + result->fileHash = data.get("file_hash", ""); + return result; +} + +string TgTypeParser::parsePassportElementErrorFile(const PassportElementErrorFile::Ptr& object) const { + if (!object) { + return ""; + } + // This function will be called by parsePassportElementError(), so I don't add + // curly brackets to the result string. + string result; + appendToJson(result, "file_hash", object->fileHash); + // The last comma will be erased by parsePassportElementError(). + return result; +} + +PassportElementErrorFiles::Ptr TgTypeParser::parseJsonAndGetPassportElementErrorFiles(const ptree& data) const { + // NOTE: This function will be called by parseJsonAndGetPassportElementError(). + auto result(make_shared()); + result->fileHashes = parseJsonAndGetArray( + [] (const ptree& innerData)->std::string { + return innerData.get(""); + }, data, "file_hashes"); + return result; +} + +string TgTypeParser::parsePassportElementErrorFiles(const PassportElementErrorFiles::Ptr& object) const { + if (!object) { + return ""; + } + // This function will be called by parsePassportElementError(), so I don't add + // curly brackets to the result string. + string result; + appendToJson(result, "file_hashes", + parseArray([] (const std::string& s)->std::string { + return s; + }, object->fileHashes)); + // The last comma will be erased by parsePassportElementError(). + return result; +} + +PassportElementErrorTranslationFile::Ptr TgTypeParser::parseJsonAndGetPassportElementErrorTranslationFile(const ptree& data) const { + // NOTE: This function will be called by parseJsonAndGetPassportElementError(). + auto result(make_shared()); + result->fileHash = data.get("file_hash", ""); + return result; +} + +string TgTypeParser::parsePassportElementErrorTranslationFile(const PassportElementErrorTranslationFile::Ptr& object) const { + if (!object) { + return ""; + } + // This function will be called by parsePassportElementError(), so I don't add + // curly brackets to the result string. + string result; + appendToJson(result, "file_hash", object->fileHash); + // The last comma will be erased by parsePassportElementError(). + return result; +} + +PassportElementErrorTranslationFiles::Ptr TgTypeParser::parseJsonAndGetPassportElementErrorTranslationFiles(const ptree& data) const { + // NOTE: This function will be called by parseJsonAndGetPassportElementError(). + auto result(make_shared()); + result->fileHashes = parseJsonAndGetArray( + [] (const ptree& innerData)->std::string { + return innerData.get(""); + }, data, "file_hashes"); + return result; +} + +string TgTypeParser::parsePassportElementErrorTranslationFiles(const PassportElementErrorTranslationFiles::Ptr& object) const { + if (!object) { + return ""; + } + // This function will be called by parsePassportElementError(), so I don't add + // curly brackets to the result string. + string result; + appendToJson(result, "file_hashes", + parseArray([] (const std::string& s)->std::string { + return s; + }, object->fileHashes)); + // The last comma will be erased by parsePassportElementError(). + return result; +} + +PassportElementErrorUnspecified::Ptr TgTypeParser::parseJsonAndGetPassportElementErrorUnspecified(const ptree& data) const { + // NOTE: This function will be called by parseJsonAndGetPassportElementError(). + auto result(make_shared()); + result->elementHash = data.get("element_hash", ""); + return result; +} + +string TgTypeParser::parsePassportElementErrorUnspecified(const PassportElementErrorUnspecified::Ptr& object) const { + if (!object) { + return ""; + } + // This function will be called by parsePassportElementError(), so I don't add + // curly brackets to the result string. + string result; + appendToJson(result, "element_hash", object->elementHash); + // The last comma will be erased by parsePassportElementError(). + return result; +} + void TgTypeParser::appendToJson(string& json, const string& varName, const string& value) const { if (value.empty()) { diff --git a/src/types/PassportElementError.cpp b/src/types/PassportElementError.cpp new file mode 100644 index 0000000..d0156a9 --- /dev/null +++ b/src/types/PassportElementError.cpp @@ -0,0 +1,23 @@ +#include "tgbot/types/PassportElementErrorDataField.h" +#include "tgbot/types/PassportElementErrorFrontSide.h" +#include "tgbot/types/PassportElementErrorReverseSide.h" +#include "tgbot/types/PassportElementErrorSelfie.h" +#include "tgbot/types/PassportElementErrorFile.h" +#include "tgbot/types/PassportElementErrorFiles.h" +#include "tgbot/types/PassportElementErrorTranslationFile.h" +#include "tgbot/types/PassportElementErrorTranslationFiles.h" +#include "tgbot/types/PassportElementErrorUnspecified.h" + +#include + +using namespace TgBot; + +const std::string PassportElementErrorDataField::SOURCE = "data"; +const std::string PassportElementErrorFrontSide::SOURCE = "front_side"; +const std::string PassportElementErrorReverseSide::SOURCE = "reverse_side"; +const std::string PassportElementErrorSelfie::SOURCE = "selfie"; +const std::string PassportElementErrorFile::SOURCE = "file"; +const std::string PassportElementErrorFiles::SOURCE = "files"; +const std::string PassportElementErrorTranslationFile::SOURCE = "translation_file"; +const std::string PassportElementErrorTranslationFiles::SOURCE = "translation_files"; +const std::string PassportElementErrorUnspecified::SOURCE = "unspecified"; -- cgit v1.2.3