diff --git a/.gitignore b/.gitignore index 3c380580f18f691769890a69eeb01189eb60cd65..2b1cad72ce7494cecbd0640f88ec1755d4d4ca09 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,2 @@ NJModelServiceSDK +.vscode \ No newline at end of file diff --git a/include/INxData.h b/include/INxData.h index ca69f8b2605a43cbab7ea4bf04ba12a858a37f6d..90686e8ce363627b5deed7bd6f1075c5f2948995 100644 --- a/include/INxData.h +++ b/include/INxData.h @@ -11,15 +11,16 @@ namespace NJGIS //! type of data typedef enum { - RAW = 1, - XML = 2, - ZIP = 3 + DAT_UNKNOWN = 0, + DAT_RAW = 1, + DAT_XML = 2, + DAT_ZIP = 3 } NjDataType; class INjData : public virtual INjService { public: - virtual int isExist(); + virtual int isExist() = 0; virtual const char* getID() = 0; @@ -33,7 +34,7 @@ namespace NJGIS virtual const char* getValue() = 0; - virtual int save(const char* path) = 0; + virtual int saveAs(const char* path) = 0; }; } } diff --git a/include/INxDataConfiguration.h b/include/INxDataConfiguration.h index c4d7137ead65ee309493651c4b5b790b851a4448..6b8dbd9ad4c02132b41794069e504c6cec3e7389 100644 --- a/include/INxDataConfiguration.h +++ b/include/INxDataConfiguration.h @@ -10,12 +10,14 @@ namespace NJGIS class INjDataConfiguration : public virtual INxUnknown { - public: - virtual int pushData(const char* state, const char* event, const INjData* data) = 0; + public: + virtual int getCount() = 0; - virtual int getCount() = 0; + virtual int insertData(const char* state, const char* event, INjData* data, bool destoryed = false) = 0; - virtual int getData(std::string& state, std::string& event, INjData* &data) = 0; + virtual int getData(int index, std::string &state, std::string &event, INjData* &data, bool &destoryed) = 0; + + virtual INjData* getData(const char* state, const char* event) = 0; }; } } diff --git a/include/INxFormParam.h b/include/INxFormParam.h new file mode 100644 index 0000000000000000000000000000000000000000..8a379d3f477fe63fe1ae5b92ae396c25d13f84a2 --- /dev/null +++ b/include/INxFormParam.h @@ -0,0 +1,31 @@ +#ifndef __NJGIS_INXFORMPARAM_H__ +#define __NJGIS_INXFORMPARAM_H__ + +#include "INxUnknown.h" + +namespace NJGIS +{ + namespace SERVICE + { + class INjFormParam : public virtual INxUnknown + { + public: + //! get params count + virtual int getCount() = 0; + + //! get the key of param + virtual const char* getKey(int index) = 0; + + //! get the value of the param by index + virtual const char* getValue(int index) = 0; + + //! get the value of the param by key + virtual const char* getValue(const char* key) = 0; + + //! add key and value + virtual int insertParam(const char* key, const char* value) = 0; + }; + } +} + +#endif \ No newline at end of file diff --git a/include/INxLocalFiles.h b/include/INxLocalFiles.h new file mode 100644 index 0000000000000000000000000000000000000000..296b095a62da38f0430f094e1e8fa05d7fda97c3 --- /dev/null +++ b/include/INxLocalFiles.h @@ -0,0 +1,32 @@ +#ifndef __NJGIS_INJLOCALFILE_H__ +#define __NJGIS_INJLOCALFILE_H__ + +#include "INxUnknown.h" + +namespace NJGIS +{ + namespace SERVICE + { + class INjLocalFiles : public virtual INxUnknown + { + public: + //! get files count + virtual int getCount() = 0; + + //! get files name by index + virtual const char* getName(int index) = 0; + + //! get files path by index + virtual const char* getPath(int index) = 0; + + //! get files path by name + virtual const char* getPath(const char* name) = 0; + + //! insert a item + virtual int insertFile(const char* name, const char* path) = 0; + }; + + } +} + +#endif \ No newline at end of file diff --git a/include/INxModelService.h b/include/INxModelService.h index b78201f9892b88a946dff667c1e0d61dfdd025d7..827c525748b0008e36e71a7471cc1e630d0f47bb 100644 --- a/include/INxModelService.h +++ b/include/INxModelService.h @@ -11,31 +11,31 @@ namespace NJGIS //! type of platform typedef enum { - UNKNOWN = 0, - WINDOWS = 1, - LINUX = 2, - MACOS = 4 + PLF_UNKNOWN = 0, + PLF_WINDOWS = 1, + PLF_LINUX = 2, + PLF_MACOS = 4 } NjPlatform; //! type of service status typedef enum { - OFFLINE = 0, - ONLINE = 1 + STAT_OFFLINE = 0, + STAT_ONLINE = 1 } NjModelServiceStatus; //! type of limitation typedef enum { - PRIVATE = 0, - PUBLIC = 1 + LMT_PRIVATE = 0, + LMT_PUBLIC = 1 } NjModelServiceLimitation; //! type of permission typedef enum { - OPEN = 0, - PERMISSION = 1 + PMS_OPEN = 0, + PMS_PERMISSION = 1 } NjModelServicePermission; //! model service @@ -94,7 +94,7 @@ namespace NJGIS virtual const NJGIS::SERVICE::NjModelServicePermission getServicePermission() = 0; //! invoke service - virtual int invoke(const INjDataConfiguration* config, std::string& recordid) = 0; + virtual int invoke(INjDataConfiguration* config, std::string& recordid) = 0; //! get laster information virtual int refresh() = 0; diff --git a/include/INxModelServiceRecord.h b/include/INxModelServiceRecord.h index 5d09ff3fd933909400af292009c0a4f41d3a2ca7..378b5b5b18d417ab06147a089bb8ffd01157bfbf 100644 --- a/include/INxModelServiceRecord.h +++ b/include/INxModelServiceRecord.h @@ -15,9 +15,9 @@ namespace NJGIS { typedef enum { - UNFINISHED = 0, - FINISHED = 1, - ERROR = 2 + MSRS_UNFINISHED = 0, + MSRS_FINISHED = 1, + MSRS_ERROR = 2 } NjRecordStatus; @@ -28,8 +28,6 @@ namespace NJGIS virtual const char* getModelServiceID() = 0; - virtual INjModelService* getModelService() = 0; - virtual const char* getStartDatetime() = 0; virtual int getTimeSpan() = 0; diff --git a/include/INxServiceAccess.h b/include/INxServiceAccess.h index ca3c4da47c96fd9a28b8a07e243b5aa3e8b02ff7..61f090806d9de2ec11d40e59b38efe0293017dc2 100644 --- a/include/INxServiceAccess.h +++ b/include/INxServiceAccess.h @@ -2,7 +2,8 @@ #define __NJGIS_INJSERVICEACCESS_H__ #include "INxModelService.h" -#include "INxData.h" +#include "INxDataConfiguration.h" +#include "INxModelServiceRecord.h" #include namespace NJGIS @@ -21,8 +22,20 @@ namespace NJGIS //! get model servcie by name virtual int getModelServicesByName(const char* name, std::vector &list) = 0; + //! get model service record by id + virtual INjModelServiceRecord* getModelServiceRecordByID(const char* msrid) = 0; + //! get a data service virtual NJGIS::SERVICE::INjData* getDataServiceByID(const char* id) = 0; + + //! upload a data file + virtual NJGIS::SERVICE::INjData* uploadDataByFile(const char* filepath, const char* tag) = 0; + + //! upload a data stream + virtual NJGIS::SERVICE::INjData* uploadDataStream(const char* stream, const char* tag) = 0; + + //! create a data configuration + virtual NJGIS::SERVICE::INjDataConfiguration* createDataConfig() = 0; }; } diff --git a/include/NxServiceAPI.h b/include/NxServiceAPI.h index 23ec80b6335253792055f50bdab3a71b5f39723d..f12980b6165bf81bf6277bc012573ebd5fc53b49 100644 --- a/include/NxServiceAPI.h +++ b/include/NxServiceAPI.h @@ -28,6 +28,8 @@ namespace NJGIS { namespace SERVICE { + extern "C" NJGIS_SERVICE int init(); + extern "C" NJGIS_SERVICE const char* getVersion(); extern "C" NJGIS_SERVICE NJGIS::SERVICE::INjServerFactory* createServerFactory(); diff --git a/src/NxData.cpp b/src/NxData.cpp index a3dde8884acfea025e7f1c0bde52acde691a27d5..5bfd5f69f088cec0413d68ac0ac75aca9dd88c5f 100644 --- a/src/NxData.cpp +++ b/src/NxData.cpp @@ -2,22 +2,22 @@ int NJGIS::SERVICE::NjData::isExist() { - return NULL; + return 0; } const char* NJGIS::SERVICE::NjData::getID() { - return NULL; + return this->_id.c_str(); } const char* NJGIS::SERVICE::NjData::getTag() { - return NULL; + return this->_tag.c_str(); } const char* NJGIS::SERVICE::NjData::getGenarationDateTime() { - return NULL; + return this->_genarationDateTime.c_str(); } NJGIS::SERVICE::NjDataType NJGIS::SERVICE::NjData::getType() @@ -27,16 +27,15 @@ NJGIS::SERVICE::NjDataType NJGIS::SERVICE::NjData::getType() int NJGIS::SERVICE::NjData::getSize() { - return NULL; + return this->_size; } const char* NJGIS::SERVICE::NjData::getValue() { - return NULL; + return this->_value.c_str(); } -int NJGIS::SERVICE::NjData::save( const char* path ) +int NJGIS::SERVICE::NjData::saveAs( const char* path ) { return NULL; -} - +} \ No newline at end of file diff --git a/src/NxData.h b/src/NxData.h index 825a895275e0e078dc8dfc1e898f84bc95ecaa10..83ea02a30e6b218a2ce8c3e85d7626dbe7a56b1e 100644 --- a/src/NxData.h +++ b/src/NxData.h @@ -11,6 +11,27 @@ namespace NJGIS class NjData : public virtual INjData, public virtual NjService { public: + NjData(){}; + + NjData( + const char* id, + const char* tag, + int size, + const char* genarationDateTime, + NJGIS::SERVICE::NjDataType type, + const char* value, + const char* ip, + int port + ): + _id(id), + _tag(tag), + _size(size), + _genarationDateTime(genarationDateTime), + _type(type), + _value(value), + NjService(ip, port) + {}; + virtual int isExist(); virtual const char* getID(); @@ -25,7 +46,7 @@ namespace NJGIS virtual const char* getValue(); - virtual int save( const char* path ); + virtual int saveAs( const char* path ); private: std::string _id; diff --git a/src/NxDataConfiguration.cpp b/src/NxDataConfiguration.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f864aa71c926088251dad19c6ea4c00b2aa22c46 --- /dev/null +++ b/src/NxDataConfiguration.cpp @@ -0,0 +1,67 @@ +#include "NxDataConfiguration.h" + +NJGIS::SERVICE::NjDataConfiguration::~NjDataConfiguration() +{ + +} + +int NJGIS::SERVICE::NjDataConfiguration::getCount() +{ + return this->_items.size(); +} + +int NJGIS::SERVICE::NjDataConfiguration::insertData( const char* state, const char* event, NJGIS::SERVICE::INjData* data, bool destoryed ) +{ + for(int i = 0; i < this->_items.size(); i++) + { + if((strcmp(this->_items[i].state, state) == 0) && (strcmp(this->_items[i].event, event) == 0)) + { + this->_items[i].data = (void*)data; + this->_items[i].destoryed = destoryed; + return 2; + } + } + NjDataConfigItem item; + char* cstate = new char[strlen(state)]; + char* cevent = new char[strlen(event)]; + strcpy(cstate, state); + strcpy(cevent, event); + item.state = cstate; + item.event = cevent; + item.data = (void*)data; + item.destoryed = destoryed; + this->_items.push_back(item); + return 1; +} + +int NJGIS::SERVICE::NjDataConfiguration::getData( int index, std::string &state, std::string &event, INjData* &data, bool &destoryed) +{ + if(index > (this->_items.size() - 1) || index < 0) + { + return -2; + } + for(int i = 0; i < this->_items.size(); i++) + { + if(i == index) + { + state = std::string(this->_items[i].state); + event = std::string(this->_items[i].event); + data = (NJGIS::SERVICE::INjData*)this->_items[i].data; + destoryed = this->_items[i].destoryed; + return 1; + } + } + return 0; +} + +NJGIS::SERVICE::INjData* NJGIS::SERVICE::NjDataConfiguration::getData( const char* state, const char* event ) +{ + for(int i = 0; i < this->_items.size(); i++) + { + if((strcmp(this->_items[i].state, state) == 0) && (strcmp(this->_items[i].event, event) == 0)) + { + return (NJGIS::SERVICE::INjData*)this->_items[i].data; + } + } + return NULL; +} diff --git a/src/NxDataConfiguration.h b/src/NxDataConfiguration.h new file mode 100644 index 0000000000000000000000000000000000000000..30b365b0985be088a41d48cb2d3ccac88d351e59 --- /dev/null +++ b/src/NxDataConfiguration.h @@ -0,0 +1,40 @@ +#ifndef __NJGIS_NJDATACONFIGURATION_H__ +#define __NJGIS_NJDATACONFIGURATION_H__ + +#include +#include +#include +#include "../include/INxDataConfiguration.h" + +namespace NJGIS +{ + namespace SERVICE + { + typedef struct + { + const char* state; + const char* event; + void* data; + bool destoryed; + }NjDataConfigItem; + + class NjDataConfiguration : public virtual INjDataConfiguration + { + public: + ~NjDataConfiguration(); + + virtual int getCount(); + + virtual int insertData( const char* state, const char* event, INjData* data, bool destoryed = false ); + + virtual int getData( int index, std::string &state, std::string &event, INjData* &data, bool &destoryed ); + + virtual INjData* getData( const char* state, const char* event ); + + private: + std::vector _items; + }; + } +} + +#endif \ No newline at end of file diff --git a/src/NxDataFactory.cpp b/src/NxDataFactory.cpp index 414625d202c81464bcb785b7ac9b3156ccde096e..dacac7548685ef3263d2b28c1ed5eac6bb887416 100644 --- a/src/NxDataFactory.cpp +++ b/src/NxDataFactory.cpp @@ -1,6 +1,33 @@ #include "NxDataFactory.h" +#include "NxData.h" NJGIS::SERVICE::INjData* NJGIS::SERVICE::NjDataFactory::createDataByJSON( Json::Value jData, const char* ip, int port ) { - return NULL; + std::string gd_id = jData["gd_id"].asString(); + std::string gd_tag = jData["gd_tag"].asString(); + std::string gd_datetime = jData["gd_datetime"].asString(); + std::string gd_type = jData["gd_type"].asString(); + NJGIS::SERVICE::NjDataType type; + if (gd_type == "XML") + { + type = NJGIS::SERVICE::NjDataType::DAT_XML; + } + else if (gd_type == "ZIP") + { + type = NJGIS::SERVICE::NjDataType::DAT_ZIP; + } + else if (gd_type == "RAW") + { + type = NJGIS::SERVICE::NjDataType::DAT_RAW; + } + else + { + type = NJGIS::SERVICE::NjDataType::DAT_UNKNOWN; + } + // int gd_size = jData["gd_size"].asInt(); + std::string sszie = jData["gd_size"].asString(); + int gd_size = atoi(sszie.c_str()); + std::string gd_value = jData["gd_value"].asString(); + NJGIS::SERVICE::INjData* pData = new NJGIS::SERVICE::NjData(gd_id.c_str(), gd_tag.c_str(), gd_size, gd_datetime.c_str(), type, gd_value.c_str(), ip, port); + return pData; } \ No newline at end of file diff --git a/src/NxDataFactory.h b/src/NxDataFactory.h index 528aec4bec2638606cf248d527399663e09125ec..256df2b0a939e35d895123f9046e772f887450e3 100644 --- a/src/NxDataFactory.h +++ b/src/NxDataFactory.h @@ -2,6 +2,7 @@ #define __NJGIS_NJDATAFACTORY_H__ #include "../include/INxData.h" +#include "../include/INxDataConfiguration.h" #include "json/json.h" namespace NJGIS @@ -12,6 +13,8 @@ namespace NJGIS { public: static NJGIS::SERVICE::INjData* createDataByJSON(Json::Value jData, const char* ip, int port); + + static NJGIS::SERVICE::INjDataConfiguration* createDataConfigByJSON(Json::Value jConfig); }; } } diff --git a/src/NxModelService.cpp b/src/NxModelService.cpp index a39a008ab43534f78921b8211d1fe6971519e6c6..cade387b63465e5a8ea0eefdbd51a44c1d97fd69 100644 --- a/src/NxModelService.cpp +++ b/src/NxModelService.cpp @@ -1,4 +1,6 @@ +#include #include "NxModelService.h" +#include "../utils/NxHttp.h" const char* NJGIS::SERVICE::NjModelService::getServiceOID() { @@ -85,9 +87,44 @@ const NJGIS::SERVICE::NjModelServicePermission NJGIS::SERVICE::NjModelService::g return this->_permission; } -int NJGIS::SERVICE::NjModelService::invoke( const INjDataConfiguration* config, std::string& recordid ) -{ - return NULL; +int NJGIS::SERVICE::NjModelService::invoke( INjDataConfiguration* config, std::string& recordid ) +{ + std::string url; + this->getBaseUrl(url); + + url += "modelser/"; + url += this->getServiceOID(); + url += "?ac=run&inputdata=["; + + for(int i = 0 ; i < config->getCount(); i++) + { + std::string state; + std::string event; + INjData* data; + bool destoryed; + if(config->getData(i, state, event, data, destoryed) > 0) + { + url += "{\"StateId\":\"" + state + "\",\"Event\":\"" + event + "\",\"DataId\":\"" + data->getID() + "\",\"Destoryed\":\"false\"}"; + } + else + { + continue; + } + } + url += "]&auth="; + + Json::Value jRespones; + NJGIS::SERVICE::NjHttpHelper::request_get_json_sync(url.c_str(), jRespones); + if(jRespones["result"].asString() == "suc") + { + recordid = jRespones["data"].asString(); + return 1; + } + else if(jRespones["result"].asString() == "error") + { + return -1; + } + return 0; } int NJGIS::SERVICE::NjModelService::refresh() diff --git a/src/NxModelService.h b/src/NxModelService.h index bd657fdc97dbc78021382d1d3e6cf00be78ac623..c2a2bf8572f9f914c40fb891bd6918248693a8d9 100644 --- a/src/NxModelService.h +++ b/src/NxModelService.h @@ -88,7 +88,7 @@ namespace NJGIS virtual const NJGIS::SERVICE::NjModelServicePermission getServicePermission(); - virtual int invoke( const INjDataConfiguration* config, std::string& recordid ); + virtual int invoke( INjDataConfiguration* config, std::string& recordid ); //! to refresh the information of this model service virtual int refresh(); diff --git a/src/NxModelServiceRecord.cpp b/src/NxModelServiceRecord.cpp index bab1a43dff5342caffcc6fe1540a449dd2ac7dd3..71d0127d97b6e75b020e8fa074ae910f5e338a9c 100644 --- a/src/NxModelServiceRecord.cpp +++ b/src/NxModelServiceRecord.cpp @@ -1,66 +1,62 @@ #include "NxModelServiceRecord.h" -const char* NJGIS::SERVICE::NxModelServiceRecord::getID() +const char* NJGIS::SERVICE::NjModelServiceRecord::getID() { - throw std::exception("The method or operation is not implemented."); + return this->_oid.c_str(); } -const char* NJGIS::SERVICE::NxModelServiceRecord::getModelServiceID() +const char* NJGIS::SERVICE::NjModelServiceRecord::getModelServiceID() { - throw std::exception("The method or operation is not implemented."); + return this->_msid.c_str(); } -NJGIS::SERVICE::INjModelService* NJGIS::SERVICE::NxModelServiceRecord::getModelService() +const char* NJGIS::SERVICE::NjModelServiceRecord::getStartDatetime() { - throw std::exception("The method or operation is not implemented."); + return this->_datetime.c_str(); } -const char* NJGIS::SERVICE::NxModelServiceRecord::getStartDatetime() +int NJGIS::SERVICE::NjModelServiceRecord::getTimeSpan() { - throw std::exception("The method or operation is not implemented."); + return this->_span; } -int NJGIS::SERVICE::NxModelServiceRecord::getTimeSpan() +NJGIS::SERVICE::INjDataConfiguration* NJGIS::SERVICE::NjModelServiceRecord::getInputData() { - throw std::exception("The method or operation is not implemented."); + return this->_input; } -NJGIS::SERVICE::INjDataConfiguration* NJGIS::SERVICE::NxModelServiceRecord::getInputData() +NJGIS::SERVICE::INjDataConfiguration* NJGIS::SERVICE::NjModelServiceRecord::getOutputData() { - throw std::exception("The method or operation is not implemented."); + return this->_output; } -NJGIS::SERVICE::INjDataConfiguration* NJGIS::SERVICE::NxModelServiceRecord::getOutputData() +NJGIS::SERVICE::NjRecordStatus NJGIS::SERVICE::NjModelServiceRecord::getStatus() { - throw std::exception("The method or operation is not implemented."); + return this->_status; } -NJGIS::SERVICE::NjRecordStatus NJGIS::SERVICE::NxModelServiceRecord::getStatus() +const char* NJGIS::SERVICE::NjModelServiceRecord::getRunningInfo_Standout() { - throw std::exception("The method or operation is not implemented."); + return this->_stdout.c_str(); } -const char* NJGIS::SERVICE::NxModelServiceRecord::getRunningInfo_Standout() +const char* NJGIS::SERVICE::NjModelServiceRecord::getRunningInfo_Standerr() { - throw std::exception("The method or operation is not implemented."); + return this->_stderr.c_str(); } -const char* NJGIS::SERVICE::NxModelServiceRecord::getRunningInfo_Standerr() +const char* NJGIS::SERVICE::NjModelServiceRecord::getRunningInfo_Invokeerr() { - throw std::exception("The method or operation is not implemented."); + return this->_invkerr.c_str(); } -const char* NJGIS::SERVICE::NxModelServiceRecord::getRunningInfo_Invokeerr() +int NJGIS::SERVICE::NjModelServiceRecord::getLogs() { - throw std::exception("The method or operation is not implemented."); + return NULL; } -int NJGIS::SERVICE::NxModelServiceRecord::getLogs() +int NJGIS::SERVICE::NjModelServiceRecord::refresh() { - throw std::exception("The method or operation is not implemented."); -} -int NJGIS::SERVICE::NxModelServiceRecord::refresh() -{ - throw std::exception("The method or operation is not implemented."); + return 0; } diff --git a/src/NxModelServiceRecord.h b/src/NxModelServiceRecord.h index 0946483fb451e5524a0deb2518017ab8a8067f58..3699506aec40cb010f864f7081870c1869365742 100644 --- a/src/NxModelServiceRecord.h +++ b/src/NxModelServiceRecord.h @@ -8,15 +8,42 @@ namespace NJGIS { namespace SERVICE { - class NxModelServiceRecord : public virtual INjModelServiceRecord, public virtual NjService + class NjModelServiceRecord : public virtual INjModelServiceRecord, public virtual NjService { public: + NjModelServiceRecord(){}; + + NjModelServiceRecord( + const char* oid, + const char* msid, + const char* datetime, + int span, + INjDataConfiguration* input, + INjDataConfiguration* output, + NjRecordStatus status, + const char* cstdout, + const char* cstderr, + const char* invkerr, + const char* ip, + int port + ): + _oid(oid), + _msid(msid), + _datetime(datetime), + _span(span), + _input(input), + _output(output), + _status(status), + _stdout(cstdout), + _stderr(cstderr), + _invkerr(invkerr), + NjService(ip, port) + {}; + virtual const char* getID(); virtual const char* getModelServiceID(); - virtual INjModelService* getModelService(); - virtual const char* getStartDatetime(); virtual int getTimeSpan(); @@ -37,6 +64,27 @@ namespace NJGIS virtual int refresh(); + private: + std::string _oid; + + std::string _msid; + + std::string _datetime; + + int _span; + + INjDataConfiguration* _input; + + INjDataConfiguration* _output; + + NjRecordStatus _status; + + std::string _stdout; + + std::string _stderr; + + std::string _invkerr; + }; } } diff --git a/src/NxModelServiceRecordFactory.cpp b/src/NxModelServiceRecordFactory.cpp index 91772235a946b157aaf83f6e50d307d74e8294e8..bb5bf5b6fa9bfaa5beff0bf1c088874aa489dafa 100644 --- a/src/NxModelServiceRecordFactory.cpp +++ b/src/NxModelServiceRecordFactory.cpp @@ -1,6 +1,21 @@ #include "NxModelServiceRecordFactory.h" +#include "NxModelServiceRecord.h" NJGIS::SERVICE::INjModelServiceRecord* NJGIS::SERVICE::NjModelServiceRecordFactory::createModelServiceRecordByJSON( Json::Value jMsr, const char* ip, int port ) { + NJGIS::SERVICE::INjModelServiceRecord* pMsr = new NJGIS::SERVICE::NjModelServiceRecord( + jMsr["_id"].asString().c_str(), + jMsr["ms_id"].asString().c_str(), + jMsr["msr_datetime"].asString().c_str(), + jMsr["msr_span"].asInt(), + NULL, + NULL, + NJGIS::SERVICE::NjRecordStatus::MSRS_FINISHED, + jMsr["msr_runninginfo"]["StdOut"].asString().c_str(), + jMsr["msr_runninginfo"]["StdErr"].asString().c_str(), + jMsr["msr_runninginfo"]["InvokeErr"].asString().c_str(), + ip, + port + ); return NULL; } \ No newline at end of file diff --git a/src/NxServiceAPI.cpp b/src/NxServiceAPI.cpp index 03287560ebf8b03804ec514c6fae4429e317c13d..ad2375a20bdfebaa0cf188ea0404b3d39a490aee 100644 --- a/src/NxServiceAPI.cpp +++ b/src/NxServiceAPI.cpp @@ -1,5 +1,6 @@ #include "../include/NxServiceAPI.h" #include "NxServerFactory.h" +#include "../utils/NxHttp.h" extern "C" NJGIS_SERVICE const char* NJGIS::SERVICE::getVersion() { @@ -9,4 +10,9 @@ extern "C" NJGIS_SERVICE const char* NJGIS::SERVICE::getVersion() extern "C" NJGIS_SERVICE NJGIS::SERVICE::INjServerFactory* NJGIS::SERVICE::createServerFactory() { return new NJGIS::SERVICE::NjServerFactory(); -} \ No newline at end of file +} + +extern "C" NJGIS_SERVICE int NJGIS::SERVICE::init() +{ + return NJGIS::SERVICE::NjHttpHelper::init(); +} diff --git a/src/NxServiceAccess.cpp b/src/NxServiceAccess.cpp index c58345c5548776d4dc17e6e2addb4b2291d42721..f4ddd5e35689beb399442fae2be1bf0821423946 100644 --- a/src/NxServiceAccess.cpp +++ b/src/NxServiceAccess.cpp @@ -1,6 +1,8 @@ #include "NxServiceAccess.h" #include "NxModelService.h" #include "NxModelServiceFactory.h" +#include "NxDataFactory.h" +#include "NxModelServiceRecordFactory.h" #include "../utils/NxHttp.h" int NJGIS::SERVICE::NjServiceAccess::getModelServicesList( std::vector &list ) @@ -54,6 +56,85 @@ int NJGIS::SERVICE::NjServiceAccess::getModelServicesByName( const char* name, s NJGIS::SERVICE::INjData* NJGIS::SERVICE::NjServiceAccess::getDataServiceByID( const char* id ) { - // TODO YL + std::string url; + this->getBaseUrl(url); + url = url + "modelser/json/" + id; + Json::Value jResonese; + NJGIS::SERVICE::NjHttpHelper::request_get_json_sync(url.c_str(), jResonese); + + if(jResonese["result"].asString() == "suc") + { + Json::Value jData = jResonese["data"]; + if(jData.asString() == "") + { + return NULL; + } + NJGIS::SERVICE::INjData* pData = NJGIS::SERVICE::NjDataFactory::createDataByJSON(jData, this->getIP(), this->getPort()); + return pData; + } return NULL; } + +NJGIS::SERVICE::INjData* NJGIS::SERVICE::NjServiceAccess::uploadDataByFile( const char* filepath, const char* tag ) +{ + //! TODO Check the file + + + std::string url = ""; + this->getBaseUrl(url); + url = url + "geodata?type=file"; + + NJGIS::SERVICE::INjFormParam* pFormData = NJGIS::SERVICE::NjFormHelper::createForm(); + NJGIS::SERVICE::INjLocalFiles* pFiles = NJGIS::SERVICE::NjFileHelper::createLocalFiles(); + + pFiles->insertFile("myfile", filepath); + pFormData->insertParam("gd_tag", tag); + + Json::Value jResonese; + int code = NJGIS::SERVICE::NjHttpHelper::request_post_withform_json_sync(url.c_str(), pFormData, pFiles, jResonese); + if(code != 1) return NULL; + if(jResonese["result"].asString() == "suc") + { + std::string gdid = jResonese["data"].asString(); + + //! get the data information + this->getBaseUrl(url); + url = url + "geodata/json/" + gdid; + Json::Value jGeoData; + NJGIS::SERVICE::NjHttpHelper::request_get_json_sync(url.c_str(), jGeoData); + if (jGeoData["result"].asString() == "suc") + { + NJGIS::SERVICE::INjData* pData = NJGIS::SERVICE::NjDataFactory::createDataByJSON(jGeoData["data"], this->getIP(), this->getPort()); + return pData; + } + } + return NULL; +} + +NJGIS::SERVICE::INjData* NJGIS::SERVICE::NjServiceAccess::uploadDataStream( const char* stream, const char* tag ) +{ + //! TODD upload data stream + return NULL; +} + +NJGIS::SERVICE::INjDataConfiguration* NJGIS::SERVICE::NjServiceAccess::createDataConfig() +{ + return new NJGIS::SERVICE::NjDataConfiguration(); +} + +NJGIS::SERVICE::INjModelServiceRecord* NJGIS::SERVICE::NjServiceAccess::getModelServiceRecordByID( const char* msrid ) +{ + std::string url; + this->getBaseUrl(url); + url += "modelserrun/json/" + std::string(msrid); + NJGIS::SERVICE::INjModelServiceRecord* pRecord = NULL; + + Json::Value jResponse; + NJGIS::SERVICE::NjHttpHelper::request_get_json_sync(url.c_str(), jResponse); + if(jResponse["result"].asString() == "suc") + { + NJGIS::SERVICE::NjModelServiceRecordFactory::createModelServiceRecordByJSON(jResponse["data"], this->getIP(), this->getPort()); + } + + return pRecord; +} diff --git a/src/NxServiceAccess.h b/src/NxServiceAccess.h index d0451f175e2bdd763edeac5fe22ee2fa79269f18..acbfdd5ea28961b5945926022c5be92b0d32ced2 100644 --- a/src/NxServiceAccess.h +++ b/src/NxServiceAccess.h @@ -4,6 +4,7 @@ #include "../include/INxServiceAccess.h" #include "json/json.h" #include "NxService.h" +#include "NxDataConfiguration.h" namespace NJGIS { @@ -22,6 +23,14 @@ namespace NJGIS virtual NJGIS::SERVICE::INjData* getDataServiceByID( const char* id ); + virtual NJGIS::SERVICE::INjData* uploadDataByFile( const char* filepath, const char* tag ); + + virtual NJGIS::SERVICE::INjData* uploadDataStream( const char* stream, const char* tag ); + + virtual NJGIS::SERVICE::INjDataConfiguration* createDataConfig(); + + virtual INjModelServiceRecord* getModelServiceRecordByID( const char* msrid ); + }; } } diff --git a/test/test.cpp b/test/test.cpp index 9938bad6bf7f9ab4182b2043d0fa41842050ef70..97739483bdd67f6a141144c1ddb0a9f5ef8d83e2 100644 --- a/test/test.cpp +++ b/test/test.cpp @@ -2,10 +2,12 @@ #include #include + int main() { + int njs_init = NJGIS::SERVICE::init(); NJGIS::SERVICE::INjServerFactory* pServerFactory = NJGIS::SERVICE::createServerFactory(); - NJGIS::SERVICE::INjServer* pServer = pServerFactory->createServer("172.21.212.119"); + NJGIS::SERVICE::INjServer* pServer = pServerFactory->createServer("127.0.0.1"); if(pServer != NULL) { if(pServer->connect() == 1) @@ -19,6 +21,22 @@ int main() if(list_ms[i] == NULL) continue; std::cout << list_ms[i]->getServiceOID() << " - " << list_ms[i]->getServiceName() << " - " << list_ms[i]->getServiceType() << std::endl; } + NJGIS::SERVICE::INjData* pData = pServiceAccess->uploadDataByFile( + "E:\\DemoData\\GeoModeling\\SWAT\\SWATModel664\\testify\\default\\udx_zip_hrudata.zip", "udx_zip_hrudata.zip"); + if(pData != NULL) + { + std::cout << pData->getID() << " - " << pData->getSize() << " - " << pData->getGenarationDateTime() << " - " << pData->getTag() << std::endl; + NJGIS::SERVICE::INjDataConfiguration* pDataconfig = pServiceAccess->createDataConfig(); + pDataconfig->insertData("04579ee0-5983-4d75-bdc9-a1a460229aa0", "LoadHydroResponseUnit", pData); + NJGIS::SERVICE::INjModelService* pMService = pServiceAccess->getModelServiceByOID("5aaabce23f761b048081dd9f"); + std::string recordid; + if( pMService->invoke(pDataconfig, recordid) == 1) + { + std::cout << "Invoke successfully! Model Service Record ID is : [" << recordid << "]" << std::endl; + NJGIS::SERVICE::INjModelServiceRecord* pRecord = pServiceAccess->getModelServiceRecordByID(recordid.c_str()); + + } + } } } diff --git a/utils/NxFile.cpp b/utils/NxFile.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a732e56f2897a8bc8d9699f7942a4192ae394222 --- /dev/null +++ b/utils/NxFile.cpp @@ -0,0 +1,66 @@ +#include "NxFile.h" + + +int NJGIS::SERVICE::NjLocalFiles::getCount() +{ + return this->_mFiles.size(); +} + +int NJGIS::SERVICE::NjLocalFiles::getIterByIndex( int index, std::map::iterator &iter ) +{ + if(index > this->_mFiles.size()) + { + return -2; + } + int localIndex = 0; + for(iter = this->_mFiles.begin(); iter != this->_mFiles.end(); ++iter ) + { + if(localIndex == index) + { + return 1; + } + localIndex++; + } + return -1; +} + +const char* NJGIS::SERVICE::NjLocalFiles::getName( int index ) +{ + std::map::iterator iter; + if(this->getIterByIndex(index, iter) == 1) + { + return iter->first.c_str(); + } + return NULL; +} + +const char* NJGIS::SERVICE::NjLocalFiles::getPath( int index ) +{ + std::map::iterator iter; + if(this->getIterByIndex(index, iter) == 1) + { + return iter->second.c_str(); + } + return NULL; +} + +const char* NJGIS::SERVICE::NjLocalFiles::getPath( const char* name ) +{ + std::map::iterator iter = this->_mFiles.find(name); + if (iter != this->_mFiles.end()) + { + return iter->second.c_str(); + } + return NULL; +} + +int NJGIS::SERVICE::NjLocalFiles::insertFile( const char* name, const char* path ) +{ + this->_mFiles.insert(std::pair(name, path)); + return 1; +} + +NJGIS::SERVICE::INjLocalFiles* NJGIS::SERVICE::NjFileHelper::createLocalFiles() +{ + return new NJGIS::SERVICE::NjLocalFiles(); +} diff --git a/utils/NxFile.h b/utils/NxFile.h new file mode 100644 index 0000000000000000000000000000000000000000..c59bcf1a21ce5c56863c292f4c0ca8f4e0586a9f --- /dev/null +++ b/utils/NxFile.h @@ -0,0 +1,41 @@ +#ifndef __NJGIS_NJFILE_H__ +#define __NJGIS_NJFILE_H__ + +#include +#include +#include "../include/INxLocalFiles.h" + +namespace NJGIS +{ + namespace SERVICE + { + class NjLocalFiles : public virtual INjLocalFiles + { + public: + + virtual int getCount(); + + virtual const char* getName( int index ); + + virtual const char* getPath( int index ); + + virtual const char* getPath( const char* name ); + + virtual int insertFile( const char* name, const char* path ); + + private: + virtual int getIterByIndex( int index, std::map::iterator &iter ); + + private: + std::map _mFiles; + }; + + class NjFileHelper + { + public: + static INjLocalFiles* createLocalFiles(); + }; + } +} + +#endif \ No newline at end of file diff --git a/utils/NxFormParam.cpp b/utils/NxFormParam.cpp new file mode 100644 index 0000000000000000000000000000000000000000..abfcd7b8c084da95558e9fffa14d4bdddaee6531 --- /dev/null +++ b/utils/NxFormParam.cpp @@ -0,0 +1,67 @@ +#include +#include "NxFormParam.h" + +int NJGIS::SERVICE::NjFormParam::getCount() +{ + return this->_mParams.size(); +} + +int NJGIS::SERVICE::NjFormParam::getIterByIndex( int index, std::map::iterator &iter ) +{ + if(index > this->_mParams.size()) + { + return -2; + } + int localIndex = 0; + for(iter = this->_mParams.begin(); iter != this->_mParams.end(); ++iter ) + { + if(localIndex == index) + { + return 1; + } + localIndex++; + } + return -1; +} + +const char* NJGIS::SERVICE::NjFormParam::getKey( int index ) +{ + std::map::iterator iter; + if(this->getIterByIndex(index, iter) == 1) + { + return iter->first.c_str(); + } + return NULL; +} + +const char* NJGIS::SERVICE::NjFormParam::getValue( int index ) +{ + std::map::iterator iter; + if(this->getIterByIndex(index, iter) == 1) + { + return iter->second.c_str(); + } + return NULL; +} + +const char* NJGIS::SERVICE::NjFormParam::getValue( const char* key ) +{ + std::map::iterator iter = this->_mParams.find(key); + if(iter != this->_mParams.end()) + { + return iter->second.c_str(); + } + return NULL; +} + +int NJGIS::SERVICE::NjFormParam::insertParam( const char* key, const char* value ) +{ + this->_mParams.insert(std::pair(key, value)); + return 1; +} + + +NJGIS::SERVICE::INjFormParam* NJGIS::SERVICE::NjFormHelper::createForm() +{ + return new NJGIS::SERVICE::NjFormParam(); +} diff --git a/utils/NxFormParam.h b/utils/NxFormParam.h new file mode 100644 index 0000000000000000000000000000000000000000..3778abca513b5e35ac25d0e06cae47c3d9cbbc85 --- /dev/null +++ b/utils/NxFormParam.h @@ -0,0 +1,40 @@ +#ifndef __NJGIS_NJFORMPARAM_H__ +#define __NJGIS_NJFORMPARAM_H__ + +#include +#include "../include/INxFormParam.h" + +namespace NJGIS +{ + namespace SERVICE + { + class NjFormParam : public virtual INjFormParam + { + public: + virtual int getCount(); + + virtual const char* getKey( int index ); + + virtual const char* getValue( int index ); + + virtual const char* getValue( const char* key ); + + virtual int insertParam( const char* key, const char* value ); + + private: + virtual int getIterByIndex(int index, std::map::iterator &iter); + + private: + std::map _mParams; + + }; + + class NjFormHelper + { + public: + static INjFormParam* createForm(); + }; + } +} + +#endif \ No newline at end of file diff --git a/utils/NxHttp.cpp b/utils/NxHttp.cpp index 05c82adcc49ed7557f0229b262dbab0fb26feb0f..c6a08b217e169e7dd34222eda4c8784d6df0da84 100644 --- a/utils/NxHttp.cpp +++ b/utils/NxHttp.cpp @@ -1,15 +1,21 @@ #include "NxHttp.h" #include "curl/curl.h" +size_t NJGIS::SERVICE::NjHttpHelper::req_reply( void *ptr, size_t size, size_t nmemb, void *stream ) +{ + std::string *str = (std::string*)stream; + (*str).append((char*)ptr, size*nmemb); + return size * nmemb; +} + int NJGIS::SERVICE::NjHttpHelper::init() { curl_global_init(CURL_GLOBAL_ALL); return 1; } -int NJGIS::SERVICE::NjHttpHelper::request_get_sync( const char* url, std::string &responesbody ) +int NJGIS::SERVICE::NjHttpHelper::request_get_sync( const char* url, std::string &responsebody ) { - curl_global_init(CURL_GLOBAL_ALL); // init curl CURL *curl = curl_easy_init(); // res code @@ -27,7 +33,7 @@ int NJGIS::SERVICE::NjHttpHelper::request_get_sync( const char* url, std::string curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL); curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, NJGIS::SERVICE::NjHttpHelper::req_reply); curl_easy_setopt(curl, CURLOPT_HEADERDATA, (void *)&head); - curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&responesbody); + curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&responsebody); curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1); curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 3); // set transport and time out time curl_easy_setopt(curl, CURLOPT_TIMEOUT, 3); @@ -40,9 +46,77 @@ int NJGIS::SERVICE::NjHttpHelper::request_get_sync( const char* url, std::string return 1; } -int NJGIS::SERVICE::NjHttpHelper::request_post_sync( const char* url ) +int NJGIS::SERVICE::NjHttpHelper::request_post_withform_sync( const char* url, NJGIS::SERVICE::INjFormParam* &list_form, NJGIS::SERVICE::INjLocalFiles* &list_files, std::string &responsebody ) { - return 0; + CURL *curl; + CURLcode res; + + std::string head; + + struct curl_httppost *formpost=NULL; + struct curl_httppost *lastptr=NULL; + struct curl_slist *headerlist=NULL; + static const char buf[] = "Expect:"; + + curl_global_init(CURL_GLOBAL_ALL); + + /* Fill in the file upload field */ + for (int i = 0 ; i < list_files->getCount(); i++) + { + curl_formadd(&formpost, + &lastptr, + CURLFORM_COPYNAME, list_files->getName(i), + CURLFORM_FILE, list_files->getPath(i), + CURLFORM_END); + } + + + /* Fill in the submit field too, even if this is rarely needed */ + for (int i = 0; i < list_form->getCount(); i++) + { + curl_formadd(&formpost, + &lastptr, + CURLFORM_COPYNAME, list_form->getKey(i), + CURLFORM_COPYCONTENTS, list_form->getValue(i), + CURLFORM_END); + } + + curl = curl_easy_init(); + /* initialize custom header list (stating that Expect: 100-continue is not + wanted */ + headerlist = curl_slist_append(headerlist, buf); + if(curl) { + /* what URL that receives this POST */ + curl_easy_setopt(curl, CURLOPT_URL, url); + curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost); + + curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL); + curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, NJGIS::SERVICE::NjHttpHelper::req_reply); + curl_easy_setopt(curl, CURLOPT_HEADERDATA, (void *)&head); + curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&responsebody); + curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1); + curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 3); // set transport and time out time + curl_easy_setopt(curl, CURLOPT_TIMEOUT, 3); + + /* Perform the request, res will get the return code */ + res = curl_easy_perform(curl); + /* Check for errors */ + if(res != CURLE_OK) + { + fprintf(stderr, "curl_easy_perform() failed: %s\n", + curl_easy_strerror(res)); + } + + /* always cleanup */ + curl_easy_cleanup(curl); + + /* then cleanup the formpost chain */ + curl_formfree(formpost); + /* free slist */ + curl_slist_free_all (headerlist); + } + + return 1; } int NJGIS::SERVICE::NjHttpHelper::request_get_json_sync( const char* url, Json::Value &value ) @@ -60,9 +134,18 @@ int NJGIS::SERVICE::NjHttpHelper::request_get_json_sync( const char* url, Json:: } } -size_t NJGIS::SERVICE::NjHttpHelper::req_reply( void *ptr, size_t size, size_t nmemb, void *stream ) -{ - std::string *str = (std::string*)stream; - (*str).append((char*)ptr, size*nmemb); - return size * nmemb; +int NJGIS::SERVICE::NjHttpHelper::request_post_withform_json_sync( const char* url, INjFormParam* &list_form, INjLocalFiles* &list_files, Json::Value &value ) +{ + std::string body; + int res = NJGIS::SERVICE::NjHttpHelper::request_post_withform_sync(url, list_form, list_files, body); + Json::Reader reader; + if (reader.parse(body, value)) + { + return 1; + } + else + { + return -2; + } + } diff --git a/utils/NxHttp.h b/utils/NxHttp.h index 294c703f291c47c2019cab75dec6e3dab63d8fef..f57dc2f10ba3c88158f1f88fed66cfa99f36a06f 100644 --- a/utils/NxHttp.h +++ b/utils/NxHttp.h @@ -5,6 +5,8 @@ #include "curl/curl.h" #include "json/json.h" +#include "NxFile.h" +#include "NxFormParam.h" namespace NJGIS { @@ -18,15 +20,18 @@ namespace NJGIS /* TEST */ //! Request -GET - static int request_get_sync(const char* url, std::string &responesbody); + static int request_get_sync(const char* url, std::string &responsebody); //! Request -POST - static int request_post_sync(const char* url); + static int request_post_withform_sync( const char* url, INjFormParam* &list_form, INjLocalFiles* &list_files, std::string &responsebody ); /* JSON */ //! Request -GET static int request_get_json_sync(const char* url, Json::Value &value); + //! Request -Post + static int request_post_withform_json_sync(const char* url, INjFormParam* &list_form, INjLocalFiles* &list_files, Json::Value &value); + private: //! reply static size_t req_reply(void *ptr, size_t size, size_t nmemb, void *stream);