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 - 1,bismulti,phttpip);
    pszUserToken = QString::fromUtf8(buffer);

    m_strtoken = pszUserToken;
    delete [] buffer;

    m_Localip = pLocalip;

    m_Serid = pSerid;

    m_appType = appType;

    if(bismulti)
    {
        m_phttpip = phttpip;
    }

    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;
//     }
// }

int lhhttpapi::DBDoInterface(int nOperatorType, const QString &strParamXml, QString &strRetXml, bool bismulti)
{
    if(fnDBDoInterface == nullptr) return -1;
    if(m_phttpip == nullptr) return -1;
    int ret = 0;
    if(bismulti)
    {
        QString strToken="";
        DoGetToken(strToken, bismulti, m_phttpip);
        QString serid = m_Serid;
        QString appType = m_appType;
        char *buffer = new char[LHHTTPAPI_BUFFER_SIZE]{0};
        ret = fnDBDoInterface(serid.toUtf8().data(), appType.toUtf8().data(), strToken.toUtf8().data(), nOperatorType, strParamXml.toUtf8().data(), buffer, LHHTTPAPI_BUFFER_SIZE - 1, bismulti, m_phttpip);
        strRetXml = QString::fromUtf8(buffer);
        delete [] buffer;
    }
    else
    {
        QString strToken="";
        DoGetToken(strToken, bismulti, nullptr);
        QString serid = m_Serid;
        QString appType = m_appType;
        char *buffer = new char[LHHTTPAPI_BUFFER_SIZE]{0};
        ret = fnDBDoInterface(serid.toUtf8().data(), appType.toUtf8().data(), strToken.toUtf8().data(), nOperatorType, strParamXml.toUtf8().data(), buffer, LHHTTPAPI_BUFFER_SIZE - 1, bismulti, nullptr);
        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();
}