inattalker.h

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of digiKam project
 * https://www.digikam.org
 *
 * Date        : 2021-03-20
 * Description : a tool to export images to iNaturalist web service
 *
 * Copyright (C) 2021-2022 by Joerg Lohse <joergmlpts at gmail dot com>
 * Copyright (C) 2005-2009 by Vardhman Jain <vardhman at gmail dot com>
 * Copyright (C) 2009-2022 by Gilles Caulier <caulier dot gilles at gmail dot com>
 * Copyright (C) 2017-2019 by Maik Qualmann <metzpinguin at gmail dot com>
 *
 * This program is free software; you can redistribute it
 * and/or modify it under the terms of the GNU General
 * Public License as published by the Free Software Foundation;
 * either version 2, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * ============================================================ */
 
#ifndef DIGIKAM_INAT_TALKER_H
#define DIGIKAM_INAT_TALKER_H
 
// Qt includes
 
#include <QUrl>
#include <QList>
#include <QPair>
#include <QString>
#include <QObject>
#include <QNetworkReply>
#include <QNetworkCookie>
 
// Local includes
 
#include "dinfointerface.h"
#include "ditemslist.h"
#include "inattaxon.h"
#include "inatscore.h"
 
class QProgressDialog;
 
using namespace Digikam;
 
namespace DigikamGenericINatPlugin
{
 
class INatPhotoInfo;
class INatPhotoSet;
 
class AuthRequest;
class ApiTokenRequest;
 
typedef QPair<QString, QList<Taxon> > AutoCompletions;
 
class INatTalker : public QObject
{
    Q_OBJECT
 
public:
 
    struct PhotoUploadRequest
    {
        PhotoUploadRequest()
            : m_observationId(-1),
              m_totalImages  (0),
              m_updateIds    (false),
              m_rescale      (false),
              m_maxDim       (-1),
              m_quality      (-1)
        {
        }
 
        PhotoUploadRequest(const QList<QUrl>& imgs,
                           bool updId,
                           bool resize,
                           int mxDim,
                           int q, const QString& userName)
            : m_observationId(-1),
              m_totalImages  (imgs.count()),
              m_images       (imgs),
              m_user         (userName),
              m_updateIds    (updId),
              m_rescale      (resize),
              m_maxDim       (mxDim),
              m_quality      (q)
        {
        }
 
        int         m_observationId;
        int         m_totalImages;
        QList<QUrl> m_images;
        QString     m_apiKey;
        QString     m_user;
        bool        m_updateIds;
        bool        m_rescale;
        int         m_maxDim;
        int         m_quality;
    };
 
    struct PhotoUploadResult
    {
        PhotoUploadResult()
            : m_observationPhotoId(-1),
              m_photoId           (-1)
        {
        }
 
        PhotoUploadResult(const PhotoUploadRequest& req, int obsPhId, int phId)
            : m_request           (req),
              m_observationPhotoId(obsPhId),
              m_photoId           (phId)
        {
        }
 
        PhotoUploadRequest m_request;
        int                m_observationPhotoId;
        int                m_photoId;
    };
 
    struct NearbyObservation
    {
 
        NearbyObservation()
            : m_observationId     (-1),
              m_latitude          (0.0),
              m_longitude         (0.0),
              m_distanceMeters    (-1.0),
              m_obscured          (false),
              m_referenceTaxon    (0),
              m_referenceLatitude (0.0),
              m_referenceLongitude(0.0)
        {
        }
 
        NearbyObservation(int id,
                          double latitude,
                          double longitude,
                          double distanceMeters,
                          bool obscured,
                          uint taxon,
                          double referenceLatitude,
                          double referenceLongitude)
            : m_observationId       (id),
              m_latitude            (latitude),
              m_longitude           (longitude),
              m_distanceMeters      (distanceMeters),
              m_obscured            (obscured),
              m_referenceTaxon      (taxon),
              m_referenceLatitude   (referenceLatitude),
              m_referenceLongitude  (referenceLongitude)
        {
        }
 
        void updateObservation(int id,
                               double latitude,
                               double longitude,
                               double distanceMeters)
        {
            m_observationId  = id;
            m_latitude       = latitude;
            m_longitude      = longitude;
            m_distanceMeters = distanceMeters;
        }
 
        bool isValid() const
        {
            return (m_observationId != -1);
        }
 
        int    m_observationId;
        double m_latitude;
        double m_longitude;
        double m_distanceMeters;
        bool   m_obscured;
        uint   m_referenceTaxon;
        double m_referenceLatitude;
        double m_referenceLongitude;
    };
 
    INatTalker(QWidget* const parent,
               const QString& serviceName,
               DInfoInterface* const iface);
    ~INatTalker() override;
 
    void    unLink();
    void    cancel();
    void    removeUserName(const QString& userName);
 
    bool    stillUploading() const;
 
    int     apiTokenExpiresIn() const;
 
    bool    restoreApiToken(const QString& username,
                            QList<QNetworkCookie>&,
                            bool emitSignal);
 
    void    loadUrl(const QUrl& url, int retries = 0);
 
    void    taxonAutoCompletions(const QString& partialName);
 
    void    userInfo(const QList<QNetworkCookie>&);
 
    void    nearbyPlaces(double latitude, double longitude);
 
    void    closestObservation(uint taxon, double latitude, double longitude,
                               double radius_km = 10.0,
                               const QString& origQuery = QString());
 
    void    computerVision(const QUrl& localImage);
 
    void    createObservation(const QByteArray&, const PhotoUploadRequest&);
 
    void    verifyCreateObservation(const QByteArray&,
                                    const PhotoUploadRequest&,
                                    int page, int retries);
 
    void    deleteObservation(int id, const QString& apiKey, int retries = 0);
 
    void    uploadNextPhoto(const PhotoUploadRequest&);
 
    void    verifyUploadNextPhoto(const PhotoUploadRequest&, int retries);
 
public:
 
    QProgressDialog* m_authProgressDlg;
 
Q_SIGNALS:
 
    void signalBusy(bool val);
 
    void signalLoadUrlSucceeded(const QUrl&, const QByteArray&);
    void signalTaxonAutoCompletions(const AutoCompletions&);
    void signalNearbyObservation(const INatTalker::NearbyObservation&);
    void signalComputerVisionResults(const ImageScores&);
    void signalNearbyPlaces(const QStringList&);
    void signalObservationCreated(const INatTalker::PhotoUploadRequest&);
    void signalObservationDeleted(int id);
    void signalPhotoUploaded(const INatTalker::PhotoUploadResult&);
 
    void signalLinkingSucceeded(const QString& login,
                                const QString& name, const QUrl& iconUrl);
    void signalLinkingFailed(const QString& error);
 
private:
 
    QString tmpFileName(const QString& path);
 
private Q_SLOTS:
 
    void slotApiToken(const QString&, const QList<QNetworkCookie>&);
    void slotFinished(QNetworkReply* reply);
    void slotTimeout();
 
private:
 
    class Private;
    Private* const d;
 
    friend class UserRequest;
    friend class LoadUrlRequest;
    friend class AutoCompletionRequest;
    friend class NearbyPlacesRequest;
    friend class NearbyObservationRequest;
    friend class ComputerVisionRequest;
};
 
} // namespace DigikamGenericINatPlugin
 
#endif // DIGIKAM_INAT_TALKER_H