ibot.h

Go to the documentation of this file.

//#
//# Copyright (C) 2021-2026 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