ts/TransmitterSwitch/common/LHHTTPAPI/src/lhhttpapi.cpp

#include "lhhttpapi.h"
#include <QDebug>
#include "LHQLogAPI.h"

#include <QCoreApplication>
// #include "singletonset.h"
//#include <QMessageBox>


lhhttpapi::lhhttpapi(QObject *parent)
    : QObject(parent)
    , m_pQLib(nullptr)
    , fnDBInit(nullptr)
    , fnDBLogin(nullptr)
    , fnDBGettServerList(nullptr)
    , fnDBGetChannelList(nullptr)
    , fnDBDoInterface(nullptr)
    , fnDoGetHttpFileSize(nullptr)
    , fnDoGetHttpFileContent(nullptr)
    , fnDoUploadFtpFile(nullptr)
    , fnDoUploadFtpFileContent(nullptr)
    , fnDoCurlDeleteFtpFile(nullptr)
    , fnDoCurlUploadFtpFile(nullptr)
    , fnDoCurlUploadFtpFileContent(nullptr)
    , fnDoRelease(nullptr)
    , fnGetLastError(nullptr)
    , m_strtoken("")


{
    m_lasttimer = QDateTime::currentDateTime();

}


lhhttpapi::~lhhttpapi()
{
    //qDebug()<<"destroy LHMPJmdInfoModuleApi";
    //DoUnInit();
    UnLoad();
}

bool lhhttpapi::UnLoad()
{
    if(m_pQLib == nullptr) return false;
    int ret = m_pQLib->unload();
    m_pQLib = nullptr;
    return ret;
}

bool lhhttpapi::Load(QString file)
{
    m_pQLib = new QLibrary(file);
    if (!m_pQLib->load())
    {
     //   QMessageBox::critical(nullptr, "警告", QString("模块%1加载失败-1").arg(file));
        qDebug() << QString("模块%1加载失败-1").arg(file);

        return false;
    }
    fnDBInit = reinterpret_cast<FunDBInit>(m_pQLib->resolve("DBInitex"));
    fnDBLogin = reinterpret_cast<FunDBLogin>(m_pQLib->resolve("DBLogin"));
    fnDBGettServerList = reinterpret_cast<FunDBGetServerList>(m_pQLib->resolve("DBGetServerList"));
    fnDBGetChannelList = reinterpret_cast<FunDBGetChannelList>(m_pQLib->resolve("DBGetChannelList"));
    fnDBDoInterface = reinterpret_cast<FunDBDoInterface>(m_pQLib->resolve("DBDoInterface"));
    fnDoGetHttpFileSize = reinterpret_cast<FunDoGetHttpFileSize>(m_pQLib->resolve("DoGetHttpFileSize"));
    fnDoGetHttpFileContent = reinterpret_cast<FunDoGetHttpFileContent>(m_pQLib->resolve("DoGetHttpFileContent"));
    fnDoUploadFtpFile = reinterpret_cast<FunDoUploadFtpFile>(m_pQLib->resolve("DoUploadFtpFile"));
    fnDoUploadFtpFileContent = reinterpret_cast<FunDoUploadFtpFileContent>(m_pQLib->resolve("DoUploadFtpFileContent"));
    fnDoCurlDeleteFtpFile = reinterpret_cast<FunDoCurlDeleteFtpFile>(m_pQLib->resolve("DoCurlDeleteFtpFile"));
    fnDoCurlUploadFtpFile = reinterpret_cast<FunDoCurlUploadFtpFile>(m_pQLib->resolve("DoCurlUploadFtpFile"));
    fnDoCurlUploadFtpFileContent = reinterpret_cast<FunDoCurlUploadFtpFileContent>(m_pQLib->resolve("DoCurlUploadFtpFileContent"));
    fnGetLastError = reinterpret_cast<FunDoGetLastError>(m_pQLib->resolve("DBGetLastError"));
    fnDoRelease= reinterpret_cast<FunDoRelease>(m_pQLib->resolve("DoRelease"));

    if(fnDBInit == nullptr||fnDBLogin == nullptr||fnDBGetChannelList == nullptr||
            fnDBDoInterface == nullptr|| fnDBGettServerList == nullptr || fnGetLastError == nullptr
            || fnDoGetHttpFileSize == nullptr || fnDoGetHttpFileContent == nullptr
            || fnDoUploadFtpFile == nullptr || fnDoUploadFtpFileContent == nullptr
            || fnDoCurlDeleteFtpFile == nullptr || fnDoCurlUploadFtpFile == nullptr || fnDoCurlUploadFtpFileContent == nullptr
            || fnDoRelease == nullptr)
    {
       // QMessageBox::critical(nullptr, "警告", QString("模块%1加载失败-2").arg(file));
        return false;
    }
    return true;
}


bool lhhttpapi::Load()
{
#if defined(Q_OS_WIN)
    QString libFile = QString("%1/LHSqlWebInterface.dll").arg(QCoreApplication::applicationDirPath());
#elif defined(Q_OS_LINUX)
    QString libFile = QString("%1/libLHSqlWebInterface.so").arg(QCoreApplication::applicationDirPath());
#elif defined(Q_OS_MAC)
    QString libFile = QString("%1/libLHSqlWebInterface.dylib").arg(QCoreApplication::applicationDirPath());
#endif
    return Load(libFile);

}

void* lhhttpapi::DBInit(const char* lpUrl,bool bismulti )
{
    if(fnDBInit == nullptr) return nullptr;
    return fnDBInit(lpUrl,bismulti);
}

int lhhttpapi::DoRelease(bool bismulti, void *phttpip)
{
    if(fnDoRelease == nullptr) return -1;
    return fnDoRelease(bismulti,phttpip);
}

int lhhttpapi::DoGetToken(QString &szToken,bool bismulti,void* phttpip)
{

    int nret = 0;
    if(m_strtoken=="")
    {
        qDebug() << "in1-DoGetToken";
         nret = DBLogin(m_Localip, m_appType, m_appType, szToken,bismulti, phttpip);
          qDebug() << "in1-DoGetToken";
         m_strtoken = szToken ;

    }
    else
    {
        //判断时间
        QDateTime tspan = QDateTime::currentDateTime();

        qint64 intervalTime = m_lasttimer.secsTo(tspan); //求时间差
        if(intervalTime>TOKENTIME)
        {
            qDebug() << "in2-DoGetToken";
           nret = DBLogin(m_Localip,m_Serid,m_appType,szToken);
        //    nret = DBLogin(m_Localip, SingletonSet::GetServerID(),APPTYPE,szToken);
            qDebug() << "out2-DoGetToken";
           m_strtoken = szToken ;
           m_lasttimer =  QDateTime::currentDateTime();
        }
    }

    szToken = m_strtoken;
    return nret;
}

int lhhttpapi::DBLogin(const QString& pLocalip,const QString &pSerid, const QString &appType,  QString &pszUserToken,bool bismulti, void* phttpip)
{
    if(fnDBLogin == nullptr) return -1;
    //char buffer[LHHTTPAPI_BUFFER_SIZE] = {0};
    char *buffer = new char[LHHTTPAPI_BUFFER_SIZE];
    int ret =  fnDBLogin(pLocalip.toUtf8().data(),pSerid.toUtf8().data(),appType.toUtf8().data(), buffer, LHHTTPAPI_BUFFER_SIZE,bismulti,phttpip);
    pszUserToken = QString::fromUtf8(buffer);

    m_strtoken = pszUserToken;
    delete [] buffer;

    m_Localip = pLocalip;

    m_Serid = pSerid;

    m_appType = appType;

    return ret;
}

int lhhttpapi::DBGetServerList(char *pszList, int nSize,bool bismulti, void* phttpip)
{
    if(fnDBGettServerList == nullptr) return -1;
    return fnDBGettServerList(pszList, nSize,bismulti,phttpip);
}

int lhhttpapi::DBGetChannelList(const char* pSerid,char *pszList, int nSize,bool bismulti, void* phttpip)
{
    if(fnDBGetChannelList == nullptr) return -1;
    return fnDBGetChannelList(pSerid,pszList, nSize,bismulti,phttpip);
}

void lhhttpapi::OnWorkerFinished()
{
    //LH_WRITE_COMMON("DoInterfaceObject::DoWork End1");

    m_Condition.wakeAll();

   // LH_WRITE_COMMON("DoInterfaceObject::DoWork End2");
}


int lhhttpapi::DBDoInterface( int nOperatorType, const QString &strParamXml, QString &strRetXml, bool wait,bool bismulti, void* phttpip)
{
    QString strToken="";
    DoGetToken(strToken,bismulti,phttpip);
    if(wait)
    {
        DoInterfaceObject *pWorker = new DoInterfaceObject(this, strToken, nOperatorType, strParamXml,bismulti,phttpip);
        connect(pWorker, &DoInterfaceObject::sig_WorkFinished, this, &lhhttpapi::OnWorkerFinished, Qt::DirectConnection);
        pWorker->Start(100000);
        QMutexLocker locker(&m_mutexWorkerDestroy);
        m_Condition.wait(&m_mutexWorkerDestroy);
        strRetXml = pWorker->GetRetXML();
        int ret = pWorker->GetResult();
        pWorker->BlockStop();
        if(ret != 0)
        {
            int nerror = 0;
            QString strerror = QString("访问DBDoInterface 接口失败: token:%1,optype:%2,param:%3,ret:%4,error:%5")
                    .arg(strToken).
                    arg(nOperatorType).
                    arg(strParamXml).
                    arg(strRetXml).
                    arg(DoGetLastError(&nerror));

            //if(strerr)
            LH_WRITE_ERROR(strerror);
            if(strerror.contains("票据"))
            {
                LH_WRITE_ERROR("重新获取票据，并再次执行命令");
                QString szToken;
                int nret1 = DBLogin(m_Localip,m_Serid,m_appType,szToken,bismulti,phttpip);

                m_strtoken = szToken;

                DoInterfaceObject *pWorker = new DoInterfaceObject(this, szToken, nOperatorType, strParamXml,bismulti,phttpip);
                connect(pWorker, &DoInterfaceObject::sig_WorkFinished, this, &lhhttpapi::OnWorkerFinished, Qt::DirectConnection);
                pWorker->Start(20000);
                QMutexLocker locker(&m_mutexWorkerDestroy);
                m_Condition.wait(&m_mutexWorkerDestroy);
                strRetXml = pWorker->GetRetXML();
                int ret = pWorker->GetResult();
                pWorker->BlockStop();

                if(ret != 0)
                {
                    int nerror = 0;
                    QString strerror = QString("再次访问DBDoInterface 接口失败: token:%1,optype:%2,param:%3,ret:%4,error:%5")
                            .arg(strToken).
                            arg(nOperatorType).
                            arg(strParamXml).
                            arg(strRetXml).
                            arg(DoGetLastError(&nerror));
                      LH_WRITE_ERROR(strerror);
                }
            }
        }
        return ret;
    }
    else
    {
        if(fnDBDoInterface == nullptr) return -1;
        QString serid = m_Serid;
        QString appType = m_appType;
        //char buffer[LHHTTPAPI_BUFFER_SIZE] = {0};
        char *buffer = new char[LHHTTPAPI_BUFFER_SIZE]{0};
        // memset(buffer, 0, LHHTTPAPI_BUFFER_SIZE);
        int ret = fnDBDoInterface(serid.toUtf8().data(), appType.toUtf8().data(), strToken.toUtf8().data(), nOperatorType, strParamXml.toUtf8().data(), buffer, LHHTTPAPI_BUFFER_SIZE - 1,bismulti,phttpip);
        strRetXml = QString::fromUtf8(buffer);
        delete [] buffer;
        return ret;
    }
}


int64_t lhhttpapi::DoGetHttpFileContent(const QString &url, char *pszContent, int nSize)
{
    if(fnDoGetHttpFileContent == nullptr) return 0;
    return fnDoGetHttpFileContent(url.toUtf8().data(), pszContent, nSize);
}

bool lhhttpapi::DoUploadFtpFile(const QString &localFilePath, const QString &ftpFilePath)
{
    if(fnDoUploadFtpFile == nullptr) return -1;
    return (fnDoUploadFtpFile(localFilePath.toUtf8(), ftpFilePath.toUtf8()) == 0);
}

bool lhhttpapi::DoUploadFtpFileContent(const char * szFileContent, int nSize, const QString &ftpFilePath)
{
    if(fnDoUploadFtpFileContent == nullptr) return -1;
    return (fnDoUploadFtpFileContent(szFileContent, nSize, ftpFilePath.toUtf8()) == 0);
}
bool lhhttpapi::DoCurlDeleteFtpFile(const QString &targetFilePath)
{
    return DoCurlDeleteFtpFile("","",targetFilePath);
}
bool lhhttpapi::DoCurlDeleteFtpFile(const QString &user, const QString &pwd, const QString &targetFilePath)
{
    if(fnDoCurlDeleteFtpFile == nullptr) return -1;
    return (fnDoCurlDeleteFtpFile(user.toUtf8(), pwd.toUtf8(), targetFilePath.toUtf8()) == 0);
}
bool lhhttpapi::DoCurlUploadFtpFile(const QString &localFilePath, const QString &destFilePath)
{
    return DoCurlUploadFtpFile("", "", localFilePath, destFilePath);
}
bool lhhttpapi::DoCurlUploadFtpFile(const QString &user, const QString &pwd, const QString &localFilePath, const QString &destFilePath)
{
    if(fnDoCurlUploadFtpFile == nullptr) return -1;
    return (fnDoCurlUploadFtpFile(user.toUtf8(), pwd.toUtf8(), localFilePath.toUtf8(), destFilePath.toUtf8()) == 0);
}

bool lhhttpapi::DoCurlUploadFtpFileContent(const char *szFileContent, int nSize, const QString &destFilePath)
{
    return DoCurlUploadFtpFileContent("", "", szFileContent, nSize, destFilePath);
}

bool lhhttpapi::DoCurlUploadFtpFileContent(const QString &user, const QString &pwd, const char *szFileContent, int nSize, const QString &destFilePath)
{
    if(fnDoCurlUploadFtpFileContent == nullptr) return -1;
    return (fnDoCurlUploadFtpFileContent(user.toUtf8(), pwd.toUtf8(), szFileContent, nSize, destFilePath.toUtf8()) == 0);
}

int64_t lhhttpapi::DoGetHttpFileSize(const QString &url)
{
    if(fnDoGetHttpFileSize == nullptr) return 0;
    return fnDoGetHttpFileSize(url.toUtf8().data());
}

int lhhttpapi::DoGetLastError(char *pError, int nLen, int *nErrorCode)
{
    if(fnGetLastError == nullptr) return -1;
    return fnGetLastError(pError, nLen, nErrorCode);
}

QString lhhttpapi::DoGetLastError(int *nErrorCode)
{
    if(fnGetLastError == nullptr) return QString();
    int nLen = 1024;
    char pError[1024] = {0};
    if(fnGetLastError(pError, nLen, nErrorCode) != 0) return QString();
    return QString::fromLocal8Bit(pError).toLocal8Bit();
}


DoInterfaceObject::DoInterfaceObject(lhhttpapi *pApi, const QString &strToken, int nOperatorType, const QString &strParamXml,bool bismulti,void* phttpip)
    : ThreadWorker()
    , m_pApi(pApi)
    , m_strToken(strToken)
    , m_nOperatorType(nOperatorType)
    , m_strParamXml(strParamXml)
    , m_nResult(-1)
    ,m_bismulti(bismulti)
    ,m_phttpip(phttpip)
{

}

void DoInterfaceObject::DoWork()
{
    //LH_WRITE_COMMON("DoInterfaceObject::DoWork Start");
    if(m_pApi != nullptr)
    {
        //QString serid = singletonWork::GetServerDBID();

        // QString serid =  SingletonSet::GetServerID();
        // QString appType = APPTYPE;
        // char *buffer = new char[LHHTTPAPI_BUFFER_SIZE];
        // m_nResult = m_pApi->fnDBDoInterface(serid.toUtf8().data(), appType.toUtf8().data(), m_strToken.toUtf8().data(), m_nOperatorType, m_strParamXml.toUtf8().data(), buffer, LHHTTPAPI_BUFFER_SIZE,m_bismulti,m_phttpip);
        // m_strRetXml = QString::fromUtf8(buffer);
        // delete [] buffer;
    }
    emit sig_WorkFinished();
}