ibot.h

Go to the documentation of this file.

//#
//# Copyright (C) 2021-2025 QuasarApp.
//# Distributed under the GPLv3 software license, see the accompanying
//# Everyone is permitted to copy and distribute verbatim copies
//# of this license document, but changing it is not allowed.
//#
 
 
#ifndef IBOT_H
#define IBOT_H
 
#include "qTbot/global.h"
#include "qTbot/iupdate.h"
#include "qTbot/irequest.h"
 
#include <QMap>
#include <QHash>
#include <QSet>
#include <QFileInfo>
#include <QTimer>
 
#include <QNetworkReply>
#include <QObject>
#include <QSharedPointer>
#include <qfuture.h>
 
namespace qTbot {
 
class ReplayData;
 
class QTBOT_EXPORT IBot: public QObject
{
    Q_OBJECT
public:
    IBot();
    ~IBot();
 
    enum FileType {
        Ram,
 
        Local
    };
 
    struct RequestData {
        QSharedPointer<iRequest> request;
 
        QString responceFilePath = "";
 
        QSharedPointer<QPromise<QByteArray>> responce;
    };
 
    virtual bool login(const QByteArray& token) = 0;
 
    virtual void logout();
 
    virtual bool sendMessage(const QVariant& chatId, const QString& text, iRequest::RequestPriority priority = iRequest::NormalPriority) = 0;
 
    virtual bool deleteMessage(const QVariant& chatId, const QVariant& messageId) = 0;
 
    virtual QFuture<QByteArray> getFile(const QString& fileId, FileType fileType = Ram) = 0;
 
    virtual bool sendFile( const QFileInfo& file, const QVariant& chatId) = 0;
 
    virtual bool sendFile( const QByteArray& file, const QString& fileName, const QVariant& chatId) = 0;
 
    const QByteArray &token() const;
 
    const QString& name() const;
 
    void setName(const QString &newName);
 
    QSharedPointer<iUpdate> takeNextUnreadUpdate();
 
    QSet<unsigned long long> processed() const;
 
    virtual void setProcessed(const QSet<unsigned long long> &newProcessed);
 
    int reqestLimitPerSecond() const;
 
    void setReqestLimitPerSecond(int newReqestLimitPerSecond);
 
    int parallelActiveNetworkThreads() const;
 
    void setParallelActiveNetworkThreads(int newParallelActiveNetworkThreads);
 
    unsigned long long totalSentRequests() const;
 
    QDateTime startTime() const;
 
protected:
 
    template<class MessageType, class ... Args>
    static QSharedPointer<MessageType> makeMesasge(const QByteArray& data, Args&& ...args) {
        auto&& ptr = QSharedPointer<MessageType>(new MessageType(std::forward<Args>(args)...));
        ptr->setRawData(data);
 
        return ptr;
    }
 
    template<class MessageType, class ... Args>
    static QSharedPointer<MessageType> makeMesasge(const QJsonObject& data, Args&& ...args) {
        auto&& ptr = QSharedPointer<MessageType>(new MessageType(std::forward<Args>(args)...));
        ptr->setRawJson(data);
 
        return ptr;
    }
 
    virtual QString makeUrl(const QSharedPointer<iRequest>& request) const = 0;
 
    QFuture<QByteArray>
    sendRequest(const QSharedPointer<iRequest>& rquest);
 
    QFuture<QByteArray>
    sendRequest(const QSharedPointer<iRequest>& rquest, const QString& pathToResult);
 
    void setToken(const QByteArray &newToken);
 
    void incomeNewUpdate(const QSharedPointer<iUpdate>& message);
 
    void markUpdateAsProcessed(const QSharedPointer<iUpdate>& message);
 
    void markUpdateAsUnprocessed(const QSharedPointer<iUpdate>& message);
 
    void markUpdateAsUnprocessed(unsigned long long messageID);
 
    virtual QString defaultFileStorageLocation() const;
 
    virtual void handleIncomeNewUpdate(const QSharedPointer<iUpdate>& );
signals:
    void sigReceiveUpdate(const QSharedPointer<qTbot::iUpdate>& );
 
    void sigStopRequire();
 
private slots:
    void handleEcxecuteRequest();
private:
    unsigned long long makeKey(iRequest::RequestPriority priority);
    void setCurrentParallelActiveNetworkThreads(int newParallelActiveNetworkThreads);
 
    void sendRequestPrivate(const QSharedPointer<iRequest>& rquest,
                            const QSharedPointer<QPromise<QByteArray>> & promiseResult);
 
    void sendRequestPrivate(const QSharedPointer<iRequest>& rquest,
                            const QString& pathToResult,
                            const QSharedPointer<QPromise<QByteArray> > &promiseResult);
 
    QNetworkReply *sendRquestImpl(const QSharedPointer<iRequest> &rquest);
 
    QByteArray _token;
    QString _name;
    QMap<unsigned long long, QSharedPointer<iUpdate>> _notProcessedUpdates;
    QSet<unsigned long long> _processed;
    QNetworkAccessManager *_manager = nullptr;
    QTimer* _requestExecutor = nullptr;
    unsigned long long _totalRequest = 0;
    QDateTime _startTime;
    QMap<unsigned long long, RequestData> _requestQueue;
    int _currentParallelActiveNetworkThreads = 0;
    int _parallelActiveNetworkThreads = 5;
 
    QRecursiveMutex _mutex;
 
 
 
};
 
}
#endif // IBOT_H