ITS_OP/CctvCamViewer - ffmpeg - ini/CDS/RestObjectF.cpp

//---------------------------------------------------------------------------

#include <vcl.h>
//#include <iostream>
#include <DBXJSON.hpp>
#include "IdBaseComponent.hpp"
#include "IdComponent.hpp"
#include "IdHTTP.hpp"
#include "IdTCPClient.hpp"
#include "IdTCPConnection.hpp"
#pragma hdrstop
//#include "McJSON.hpp"
//https://github.com/hydrobyte/McJSON

#include "RestObjectF.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

TRestData::TRestData()
{
}
//---------------------------------------------------------------------------
TRestData::~TRestData()
{
}
//---------------------------------------------------------------------------

TRestObject::TRestObject()
{
}
//---------------------------------------------------------------------------
TRestObject::~TRestObject()
{
}
//---------------------------------------------------------------------------

TRestObjectList::TRestObjectList()
{
}
//---------------------------------------------------------------------------
TRestObjectList::~TRestObjectList()
{
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//TRestObjectManager *ObjCtlrManager = NULL;
//---------------------------------------------------------------------------

TRestObjectManager::TRestObjectManager()
{
}
//---------------------------------------------------------------------------
TRestObjectManager::~TRestObjectManager()
{
}
//---------------------------------------------------------------------------

String TRestObjectManager::Get(String AApiUrl, TForm *AParent)
{
//S := TIdURI.URLEncode(str);
    String         result  = "";
    TIdHTTP       *IdHTTP1 = new TIdHTTP(NULL);
    TMemoryStream *stream  = new TMemoryStream();
    TMemo         *memo    = new TMemo(AParent);
    try {
        try {
            memo->Visible = false;
            memo->Parent = AParent;

            IdHTTP1->Request->Clear();
            IdHTTP1->Request->BasicAuthentication = false;
            IdHTTP1->Request->ContentType = "application/json; charset=utf8";
            IdHTTP1->Request->Accept      = "application/json; charset=utf8";
            IdHTTP1->Request->CharSet     = "utf-8";
            //IdHTTP1->Request->ContentEncoding = "utf-8";
            IdHTTP1->ReadTimeout = 5000;
            IdHTTP1->AllowCookies = false;

            IdHTTP1->HTTPOptions = IdHTTP1->HTTPOptions >> hoInProcessAuth;

            //IdHTTP1->IOHandler->DefStringEncoding = TEncoding::GetEncoding(949);
            //result = IdHTTP1->Get(AApiUrl);
            //return result;
            IdHTTP1->Get(AApiUrl, stream);
            stream->Position = 0;
            memo->Lines->BeginUpdate();
            memo->Lines->LoadFromStream(stream, TEncoding::UTF8);
            memo->Lines->EndUpdate();
            result = memo->Text.Trim();

            IdHTTP1->Disconnect();
            IdHTTP1->IOHandler->InputBuffer->Clear();
        } catch(Exception &e) {
        }
    } __finally {
        if (IdHTTP1) delete IdHTTP1;
        if (stream) delete stream;
        if (memo) delete memo;
    }
    return result;

//RawByteString rbstr = (char*)(urlStream->Memory);
//if (Pos("utf-8", IdHTTP1->Response->ContentType)==0 && (Pos("charset=utf-8", rbstr)==0))
//    SetCodePage(rbstr, 949, false);
//else
//SetCodePage(rbstr, 65001, false);
//String sResult = rbstr;
}
//---------------------------------------------------------------------------

TStream* TRestObjectManager::GetStream(String AApiUrl)
{
    String         result  = "";
    TIdHTTP       *IdHTTP1 = new TIdHTTP(NULL);
    TMemoryStream *stream  = new TMemoryStream();
    try {
        try {
            IdHTTP1->Request->Clear();
            IdHTTP1->Request->BasicAuthentication = false;
            IdHTTP1->Request->ContentType = "application/json; charset=utf8";
            IdHTTP1->Request->Accept      = "application/json; charset=utf8";
            IdHTTP1->Request->CharSet     = "utf-8";
            //IdHTTP1->Request->ContentEncoding = "utf-8";
            IdHTTP1->ReadTimeout = 5000;
            IdHTTP1->AllowCookies = false;

            IdHTTP1->HTTPOptions = IdHTTP1->HTTPOptions >> hoInProcessAuth;

            //IdHTTP1->IOHandler->DefStringEncoding = TEncoding::GetEncoding(949);
            //result = IdHTTP1->Get(AApiUrl);
            //return result;
            IdHTTP1->Get(AApiUrl, stream);
            stream->Position = 0;

            IdHTTP1->Disconnect();
            IdHTTP1->IOHandler->InputBuffer->Clear();
        } catch(Exception &e) {
        }
    } __finally {
        if (IdHTTP1) delete IdHTTP1;
    }
    return stream;

//RawByteString rbstr = (char*)(urlStream->Memory);
//if (Pos("utf-8", IdHTTP1->Response->ContentType)==0 && (Pos("charset=utf-8", rbstr)==0))
//    SetCodePage(rbstr, 949, false);
//else
//SetCodePage(rbstr, 65001, false);
//String sResult = rbstr;
}
//---------------------------------------------------------------------------

TMcJsonItem* TRestObjectManager::ParseJsonString(String AJsonData)
{
    String AData = AJsonData.Trim();

    TMcJsonItem *Json = new TMcJsonItem();
    try {
        Json->AsJSON = AData;
    } catch(Exception &e) {
    }
    return Json;
}
//---------------------------------------------------------------------------

TMcJsonItem* TRestObjectManager::ParseJsonStream(TStream *AStream)
{
    TMcJsonItem *Json = new TMcJsonItem();
    try {
        Json->LoadFromStream(AStream, true);
    } catch(Exception &e) {
    }
    return Json;
}
//---------------------------------------------------------------------------

String TRestObjectManager::GetValue(TMcJsonItem *AItem, String AKey)
{
    String result = "";
    if (AItem) {
        TMcJsonItem *value = AItem->Values[AKey];
        if (value) {
            result = value->AsString;
        }
    }
    return result;
}
//---------------------------------------------------------------------------

#if 0
    TJSONArray *jsonArr = NULL;
    try {
        reMsg->Lines->BeginUpdate();
        try {
            /*TBytes data;
            data.Length = AData.Length();
            ZeroMemory(&data[0], data.Length);
            CopyMemory(&data[0], AData.c_str(), data.Length);*/

            TStringStream *stream = new TStringStream(AData, TEncoding::UTF8);

            jsonArr = (TJSONArray*)TJSONObject::ParseJSONValue(TEncoding::UTF8->GetBytes(AData), 0);
            jsonArr = (TJSONArray*)TJSONObject::ParseJSONValue(TEncoding::UTF8->GetBytes(AData), 0);
            if (!jsonArr) {
                reMsg->Lines->Add("*******************************************: ");
                reMsg->Lines->Add("JSON Data Reading Failed: ");
                reMsg->Lines->Add("*******************************************: ");
                return;
            }

            reMsg->Lines->Add("Objects: " + String(jsonArr->Size()));
            reMsg->Lines->Add("*******************************************: ");

            cameraNmbr   = "";
            cameraId     = "";
            cameraNm     = "";
            cameraIp     = "";
            cameraStream = "";

            for (int ii = 0; ii < jsonArr->Size(); ii++) {
                TJSONObject *jo = (TJSONObject*)jsonArr->Get(ii);
                for (int jj = 0; jj < jo->Size(); jj++) {
                    TJSONPair *obj = jo->Get(jj);
                    if (obj->JsonString->Value() == CAMERA_NMBR) {
                        cameraNmbr = obj->JsonValue->Value();
                    }
                    else if (obj->JsonString->Value() == CAMERA_ID) {
                        cameraId = obj->JsonValue->Value();
                    }
                    else if (obj->JsonString->Value() == CAMERA_NM) {
                        cameraNm = obj->JsonValue->Value();
                        /*
                        String sStrVal = obj->JsonValue->Value();
                        reMsg->Lines->Add(TEncoding::Default->GetString(TEncoding::Default->GetBytes(sStrVal)));
                        reMsg->Lines->Add(TEncoding::UTF8->GetString(TEncoding::UTF8->GetBytes(sStrVal)));
                        reMsg->Lines->Add(TEncoding::UTF7->GetString(TEncoding::UTF7->GetBytes(sStrVal)));
                        reMsg->Lines->Add(TEncoding::Unicode->GetString(TEncoding::Unicode->GetBytes(sStrVal)));
                        reMsg->Lines->Add((TEncoding::UTF8->GetBytes(sStrVal)));
                        reMsg->Lines->Add((TEncoding::UTF7->GetBytes(sStrVal)));
                        reMsg->Lines->Add((TEncoding::Unicode->GetBytes(sStrVal)));
                        */
                    }
                    else if (obj->JsonString->Value() == CAMERA_IP) {
                        cameraIp = obj->JsonValue->Value();
                    }
                    else if (obj->JsonString->Value() == CAMERA_STREAM) {
                        cameraStream = obj->JsonValue->Value();
                    }
                }
                reMsg->Lines->Add(cameraNmbr + "," + cameraId + "," + cameraNm + "," + cameraIp + "," + cameraStream);

                ObjCtlrManager->SaveCameraInfo(ii+1, cameraNmbr, cameraId, cameraNm, cameraIp, cameraStream, "");
            }
        } catch(Exception &e) {
        }
    } __finally {
        if (jsonArr) jsonArr->Free();
        reMsg->Lines->EndUpdate();
    }
#endif

#if 0
reMsg->Lines->BeginUpdate();

    AData = StringReplace(AData, "[",  "",  TReplaceFlags() << rfReplaceAll);
    AData = StringReplace(AData, "]",  "",  TReplaceFlags() << rfReplaceAll);
    AData = StringReplace(AData, "},", "}", TReplaceFlags() << rfReplaceAll);
    //AData = StringReplace(AData, "{",  "",  TReplaceFlags() << rfReplaceAll);

    TStringList *pStringList = new TStringList;
    try {
        pStringList->Delimiter = '}';
        pStringList->StrictDelimiter = true;
        pStringList->DelimitedText = AData;
        for (int ii = 0; ii < pStringList->Count; ii++) {
            //reMsg->Lines->Add("*******************************************: " + String(ii+1));
            //reMsg->Lines->Add(pStringList->Strings[ii]);
        }

    } __finally {
        if (pStringList) delete pStringList;
    }


reMsg->Lines->EndUpdate();
//return;
#endif
    //String sFileName = "C:\\UTF8FileName.xml";
	//Memo1->Lines->LoadFromFile(sFileName,  TEncoding::UTF8);

    //reMsg->Lines->Clear();
    //reMsg->Lines->Add(AData);
    //String((char *)pMemoryStream->Memory, pMemoryStream->Size);
#include <OleAuto.h>
char* UTF8ToANSI(const char *pszCode)
{
    BSTR    bstrWide;
    char*   pszAnsi;
    int     nLength;

    // Get nLength of the Wide Char buffer
    nLength = MultiByteToWideChar(CP_UTF8, 0, pszCode, strlen(pszCode) + 1,
        NULL, NULL);
    bstrWide = SysAllocStringLen(NULL, nLength);

    // Change UTF-8 to Unicode (UTF-16)
    MultiByteToWideChar(CP_UTF8, 0, pszCode, strlen(pszCode) + 1, bstrWide, nLength);

    // Get nLength of the multi byte buffer
    nLength = WideCharToMultiByte(CP_ACP, 0, bstrWide, -1, NULL, 0, NULL, NULL);
    pszAnsi = new char[nLength];

    // Change from unicode to mult byte
    WideCharToMultiByte(CP_ACP, 0, bstrWide, -1, pszAnsi, nLength, NULL, NULL);
    SysFreeString(bstrWide);

    return pszAnsi;
}
AnsiString __fastcall Utf8ToAscii(UTF8String AUtf8)
{
    int nLen;
    WideString sUtf16;
    AnsiString sAscii = "";

    nLen = ::MultiByteToWideChar(CP_UTF8, 0, AUtf8.c_str(), AUtf8.Length(), NULL, 0);
    sUtf16.SetLength(nLen);

    ::MultiByteToWideChar(CP_UTF8, 0, AUtf8.c_str(), AUtf8.Length(), sUtf16.c_bstr(), nLen);

    nLen = ::WideCharToMultiByte(CP_ACP, 0, sUtf16.c_bstr(), sUtf16.Length(), NULL, 0, NULL, NULL);
    sAscii.SetLength(nLen);
    ::WideCharToMultiByte(CP_ACP, 0, sUtf16.c_bstr(), sUtf16.Length(), sAscii.c_str(), nLen, NULL, NULL);
    return sAscii;
}
//---------------------------------------------------------------------------

#if 0
    TJSONArray *jsonArr = NULL;
    try {
        reMsg->Lines->BeginUpdate();
        try {
            //TStringStream *stream = new TStringStream(AData, TEncoding::UTF8);

            //jsonArr = (TJSONArray*)TJSONObject::ParseJSONValue(TEncoding::UTF8->GetBytes(AnsiString(AData)), 0);
            jsonArr = (TJSONArray*)TJSONObject::ParseJSONValue(BytesOf(AData), 0);
            //jsonArr = (TJSONArray*)TJSONObject::ParseJSONValue(stream->DataString, 0);
            if (!jsonArr) {
                reMsg->Lines->Add("*******************************************: ");
                reMsg->Lines->Add("JSON Data Reading Failed: ");
                reMsg->Lines->Add("*******************************************: ");
                return;
            }

            reMsg->Lines->Add("Objects: " + String(jsonArr->Size()));
            reMsg->Lines->Add("*******************************************: ");

            cameraNmbr   = "";
            cameraId     = "";
            cameraNm     = "";
            cameraIp     = "";
            cameraStream = "";

            for (int ii = 0; ii < jsonArr->Size(); ii++) {
                TJSONObject *jo = (TJSONObject*)jsonArr->Get(ii);
                for (int jj = 0; jj < jo->Size(); jj++) {
                    TJSONPair *obj = jo->Get(jj);
                    if (obj->JsonString->Value() == CAMERA_NMBR) {
                        cameraNmbr = obj->JsonValue->Value();
                    }
                    else if (obj->JsonString->Value() == CAMERA_ID) {
                        cameraId = obj->JsonValue->Value();
                    }
                    else if (obj->JsonString->Value() == CAMERA_NM) {
                        cameraNm = obj->JsonValue->Value();
                        //RawByteString rbstr = (char*)(AnsiString(cameraNm).c_str());
                        //SetCodePage(rbstr, 949, false);
                        //cameraNm = rbstr;
                        //cameraNm= String(UTF8ToANSI(AnsiString(cameraNm).c_str()));
                        reMsg->Lines->Add(cameraNm);
                        cameraNm = (UTF8String)(obj->JsonValue->Value()).c_str();
                        /*
                        String sStrVal = obj->JsonValue->Value();
                        reMsg->Lines->Add(TEncoding::Default->GetString(TEncoding::Default->GetBytes(sStrVal)));
                        reMsg->Lines->Add(TEncoding::UTF8->GetString(TEncoding::UTF8->GetBytes(sStrVal)));
                        reMsg->Lines->Add(TEncoding::UTF7->GetString(TEncoding::UTF7->GetBytes(sStrVal)));
                        reMsg->Lines->Add(TEncoding::Unicode->GetString(TEncoding::Unicode->GetBytes(sStrVal)));
                        reMsg->Lines->Add((TEncoding::UTF8->GetBytes(sStrVal)));
                        reMsg->Lines->Add((TEncoding::UTF7->GetBytes(sStrVal)));
                        reMsg->Lines->Add((TEncoding::Unicode->GetBytes(sStrVal)));
                        */
                    }
                    else if (obj->JsonString->Value() == CAMERA_IP) {
                        cameraIp = obj->JsonValue->Value();
                    }
                    else if (obj->JsonString->Value() == CAMERA_STREAM) {
                        cameraStream = obj->JsonValue->Value();
                    }
                }
                reMsg->Lines->Add(cameraNmbr + "," + cameraId + "," + cameraNm + "," + cameraIp + "," + cameraStream);

                ObjCtlrManager->SaveCameraInfo(ii+1, cameraNmbr, cameraId, cameraNm, cameraIp, cameraStream, "");
            }
        } catch(Exception &e) {
        }
    } __finally {
        if (jsonArr) jsonArr->Free();
        reMsg->Lines->EndUpdate();
    }

#endif