270 lines
8.8 KiB
C++
270 lines
8.8 KiB
C++
#include "typeconverter.h"
|
|
#include "message.h"
|
|
|
|
//converts between tdlib types and own types
|
|
|
|
ChatType convertChatType(const td_api::ChatType& in) {
|
|
switch(in.get_id()) {
|
|
case td_api::chatTypeBasicGroup::ID:
|
|
return ChatType::GROUP;
|
|
case td_api::chatTypePrivate::ID:
|
|
return ChatType::PRIVATE;
|
|
case td_api::chatTypeSecret::ID:
|
|
return ChatType::SECRET;
|
|
case td_api::chatTypeSupergroup::ID: {
|
|
if(((const td_api::chatTypeSupergroup&) in).is_channel_)
|
|
return ChatType::CHANNEL;
|
|
return ChatType::SUPERGROUP;
|
|
}
|
|
}
|
|
return ChatType::UNKNOWN; //unknown
|
|
}
|
|
|
|
void convertUser(const td_api::user& in, User& out) {
|
|
if(in.usernames_ && in.usernames_->active_usernames_.empty()) {
|
|
out.username = in.usernames_->active_usernames_.at(0);
|
|
} else {
|
|
out.username = {};
|
|
}
|
|
|
|
out.tgid = in.id_;
|
|
out.firstname = in.first_name_;
|
|
out.lastname = in.last_name_;
|
|
out.phonenumber = in.phone_number_;
|
|
out.isContact = in.is_contact_;
|
|
out.isMutalContact = in.is_mutual_contact_;
|
|
out.isVerified = in.is_verified_;
|
|
out.isSupport = in.is_support_;
|
|
out.restriction = in.restriction_reason_;
|
|
out.isScam = in.is_scam_;
|
|
out.haveAccess = in.have_access_;
|
|
out.type = convertUserType(*in.type_);
|
|
}
|
|
|
|
UserType convertUserType(const td_api::UserType& in) {
|
|
switch(in.get_id()) {
|
|
case td_api::userTypeBot::ID:
|
|
return UserType::BOT;
|
|
case td_api::userTypeDeleted::ID:
|
|
return UserType::DELETED;
|
|
case td_api::userTypeRegular::ID:
|
|
return UserType::REGULAR;
|
|
}
|
|
return UserType::UNKNOWN; //unknown
|
|
}
|
|
|
|
const std::string& convertUserType(UserType type) {
|
|
switch(type) {
|
|
case UserType::BOT:
|
|
return UserTypeTypes[0];
|
|
case UserType::DELETED:
|
|
return UserTypeTypes[1];
|
|
case UserType::REGULAR:
|
|
return UserTypeTypes[2];
|
|
default: break;
|
|
}
|
|
return UserTypeTypes[3];
|
|
}
|
|
|
|
UserType convertUserType(const std::string& in) {
|
|
if(in == UserTypeTypes[0])
|
|
return UserType::BOT;
|
|
if(in == UserTypeTypes[1])
|
|
return UserType::DELETED;
|
|
if(in == UserTypeTypes[2])
|
|
return UserType::REGULAR;
|
|
return UserType::UNKNOWN;
|
|
}
|
|
|
|
const std::string& convertMessageType(MessageType type) {
|
|
uint32_t i = (uint32_t) type;
|
|
if(i > 14) return MessageTypeTypes[0]; //unknown
|
|
return MessageTypeTypes[i];
|
|
}
|
|
|
|
MessageType convertMessageType(const std::string& in) {
|
|
for(int32_t i = 0; i < 14; ++i) {
|
|
if(MessageTypeTypes[i] == in) {
|
|
return (MessageType) i;
|
|
}
|
|
}
|
|
return MessageType::UNKNOWN;
|
|
}
|
|
|
|
static int64_t getSender(const td_api::MessageSender& s) {
|
|
if(s.get_id() == td_api::messageSenderUser::ID) {
|
|
return static_cast<const td_api::messageSenderUser&>(s).user_id_;
|
|
}
|
|
if(s.get_id() == td_api::messageSenderChat::ID) {
|
|
return static_cast<const td_api::messageSenderChat&>(s).chat_id_;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void convertMessage(const td_api::message& in, Message& out) {
|
|
out.id = in.id_;
|
|
out.chat = in.chat_id_;
|
|
out.sender = getSender(*in.sender_id_);
|
|
out.text = "";
|
|
out.type = convertMessageTypeandText(*in.content_, out.text);
|
|
out.isDeleted = false;
|
|
out.isOutgoing = in.is_outgoing_;
|
|
out.isPinned = in.is_pinned_;
|
|
out.isEditable = in.can_be_edited_;
|
|
out.isForwardable = in.can_be_forwarded_;
|
|
out.sendDate = in.date_;
|
|
out.editDate = in.edit_date_;
|
|
out.messageThreadId = in.message_thread_id_;
|
|
out.viaBotid = in.via_bot_user_id_;
|
|
out.mediaAlbumId = in.media_album_id_;
|
|
|
|
ReplyMarkup* markup = convertReplyMarkup(in.reply_markup_.get());
|
|
if(markup) {
|
|
out.replyMarkup = std::shared_ptr<ReplyMarkup>(markup);
|
|
}
|
|
}
|
|
|
|
|
|
#define CHECKCAST(TYPE, MTYPE, ACCESS) case td_api::TYPE::ID: \
|
|
textout = static_cast<const td_api::TYPE&>(cont).ACCESS; \
|
|
return MessageType::MTYPE
|
|
#define ECHECKCAST(TYPE, MTYPE) case td_api::TYPE::ID: \
|
|
return MessageType::MTYPE
|
|
|
|
MessageType convertMessageTypeandText(const td_api::MessageContent& cont, std::string& textout) {
|
|
switch(cont.get_id()) {
|
|
CHECKCAST(messageText, TEXT, text_->text_);
|
|
|
|
CHECKCAST(messageAnimation, ANIMATION, caption_->text_);
|
|
CHECKCAST(messageAudio, AUDIO, caption_->text_);
|
|
CHECKCAST(messageContact, CONTACT, contact_->first_name_);
|
|
CHECKCAST(messageDocument, DOCUMENT, caption_->text_);
|
|
ECHECKCAST(messageLocation, LOCATION);
|
|
CHECKCAST(messagePhoto, PHOTO, caption_->text_);
|
|
ECHECKCAST(messageExpiredPhoto, PHOTO);
|
|
CHECKCAST(messagePoll, POLL, poll_->question_);
|
|
ECHECKCAST(messageSticker, STICKER);
|
|
ECHECKCAST(messageDice, STICKER);
|
|
CHECKCAST(messageVideo, VIDEO, caption_->text_);
|
|
ECHECKCAST(messageExpiredVideo, VIDEO);
|
|
ECHECKCAST(messageVideoNote, VIDEO);
|
|
CHECKCAST(messageVenue, VENUE, venue_->title_);
|
|
CHECKCAST(messageVoiceNote, VOICE, caption_->text_);
|
|
ECHECKCAST(messageUnsupported, UNSUPPORTED);
|
|
|
|
default:
|
|
return MessageType::SERVICE;
|
|
|
|
}
|
|
// unreachable
|
|
return MessageType::UNKNOWN;
|
|
}
|
|
|
|
#undef CHECKCAST
|
|
#undef ECHECKCAST
|
|
|
|
ReplyMarkup* convertReplyMarkup(const td_api::ReplyMarkup* in) {
|
|
if(!in)
|
|
return nullptr;
|
|
if(in->get_id() == td_api::replyMarkupInlineKeyboard::ID) {
|
|
const td_api::replyMarkupInlineKeyboard* kyb = (const td_api::replyMarkupInlineKeyboard*) in;
|
|
InlineReplyMarkup* out = new InlineReplyMarkup();
|
|
|
|
// convertbuttons
|
|
for(uint32_t i = 0; i < kyb->rows_.size(); ++i) {
|
|
const std::vector<td_api::object_ptr<td_api::inlineKeyboardButton>>& row = kyb->rows_.at(i);
|
|
for(uint32_t j = 0; j < row.size(); ++j) {
|
|
InlineButton* btn = convertInlineButton(row.at(j).get());
|
|
if(btn)
|
|
out->buttons.push_back(btn);
|
|
}
|
|
}
|
|
|
|
return out;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
InlineButton* convertInlineButton(const td_api::inlineKeyboardButton* in) {
|
|
//construct button
|
|
InlineButton* btn = nullptr;
|
|
const td_api::InlineKeyboardButtonType* type = in->type_.get();
|
|
if(type->get_id() == td_api::inlineKeyboardButtonTypeCallback::ID) {
|
|
btn = new InlineCallbackButton();
|
|
((InlineCallbackButton*) btn)->data = ((const td_api::inlineKeyboardButtonTypeCallback*) type)->data_;
|
|
} else if(type->get_id() == td_api::inlineKeyboardButtonTypeCallbackWithPassword::ID) {
|
|
btn = new InlineCallbackPasswordButton();
|
|
((InlineCallbackPasswordButton*) btn)->data = ((const td_api::inlineKeyboardButtonTypeCallbackWithPassword*) type)->data_;
|
|
} else if(type->get_id() == td_api::inlineKeyboardButtonTypeLoginUrl::ID) {
|
|
InlineLoginURLButton* lurlbtn = new InlineLoginURLButton();
|
|
const td_api::inlineKeyboardButtonTypeLoginUrl* casted = (const td_api::inlineKeyboardButtonTypeLoginUrl*) type;
|
|
lurlbtn->url = casted->url_;
|
|
lurlbtn->id = casted->id_;
|
|
lurlbtn->forwardText = casted->forward_text_;
|
|
btn = lurlbtn;
|
|
} else if(type->get_id() == td_api::inlineKeyboardButtonTypeSwitchInline::ID) {
|
|
InlineSwitchInlineButton* lsbtn = new InlineSwitchInlineButton();
|
|
const td_api::inlineKeyboardButtonTypeSwitchInline* casted = (const td_api::inlineKeyboardButtonTypeSwitchInline*) type;
|
|
lsbtn->query = casted->query_;
|
|
lsbtn->inCurrentChat = (casted->target_chat_->get_id() == td_api::targetChatCurrent::ID);
|
|
btn = lsbtn;
|
|
} else if(type->get_id() == td_api::inlineKeyboardButtonTypeUrl::ID) {
|
|
btn = new InlineURLButton();
|
|
((InlineURLButton*) btn)->url = ((const td_api::inlineKeyboardButtonTypeUrl*) type)->url_;
|
|
}
|
|
|
|
if(btn) {
|
|
btn->text = in->text_;
|
|
}
|
|
return btn;
|
|
}
|
|
|
|
bool User::operator==(const User& u) const {
|
|
return (tgid == u.tgid && firstname == u.firstname && lastname == u.lastname && username == u.username && phonenumber == u.phonenumber && isContact == u.isContact && isMutalContact == u.isMutalContact && isVerified == u.isVerified && isSupport == u.isSupport && restriction == u.restriction && isScam == u.isScam && haveAccess == u.haveAccess && type == u.type);
|
|
}
|
|
|
|
bool User::operator!=(const User& u) const {
|
|
return !operator==(u);
|
|
}
|
|
|
|
bool Message::operator==(const Message& m) const {
|
|
return (id == m.id && chat == m.chat && sender == m.sender && type == m.type && text == m.text && isDeleted == m.isDeleted && isOutgoing == m.isOutgoing && isPinned == m.isPinned && isForwardable == m.isForwardable && sendDate == m.sendDate && editDate == m.sendDate && viaBotid == m.viaBotid && mediaAlbumId == m.mediaAlbumId);
|
|
}
|
|
|
|
bool Message::operator!=(const Message& m) const {
|
|
return !operator==(m);
|
|
}
|
|
|
|
const std::string& getMessageText(const td_api::object_ptr<td_api::message>& msg) {
|
|
if(msg->content_->get_id() == td_api::messageText::ID) {
|
|
const std::string& text = ((const td_api::messageText&) *msg->content_).text_->text_;
|
|
return text;
|
|
}
|
|
static const std::string EMPTY = "";
|
|
return EMPTY;
|
|
}
|
|
|
|
|
|
#define CHECKCAST(TYPE) case td_api::TYPE::ID: \
|
|
return &*static_cast<td_api::TYPE&>(cont).caption_;
|
|
td_api::formattedText* getMessageFormattedText(td_api::message& msg, bool& isText) {
|
|
if(!msg.content_) return nullptr;
|
|
|
|
td_api::MessageContent& cont = *msg.content_;
|
|
isText = false;
|
|
switch(cont.get_id()) {
|
|
CHECKCAST(messageAnimation);
|
|
CHECKCAST(messageAudio);
|
|
CHECKCAST(messageDocument);
|
|
CHECKCAST(messagePhoto);
|
|
CHECKCAST(messageVideo);
|
|
CHECKCAST(messageVoiceNote);
|
|
case td_api::messageText::ID:
|
|
isText = true;
|
|
return &*static_cast<td_api::messageText&>(cont).text_;
|
|
}
|
|
|
|
//default
|
|
return nullptr;
|
|
}
|
|
#undef CHECKCAST |