OCStackResult InProcServerWrapper::deleteResourceFromRD(const std::string& host,
OCConnectivityType connectivityType,
ResourceHandles& resourceHandles,
DeleteResourceCallback& callback,
OCQualityOfService qos)
{
ServerCallbackContext::DeleteContext* ctx =
new ServerCallbackContext::DeleteContext(callback);
OCCallbackData cbdata(
static_cast<void*>(ctx),
deleteResourceFromRDCallback,
[](void* c)
{delete static_cast<ServerCallbackContext::DeleteContext*>(c);}
);
auto cLock = m_csdkLock.lock();
OCStackResult result = OC_STACK_ERROR;
if (cLock)
{
std::lock_guard<std::recursive_mutex> lock(*cLock);
result = OCRDDelete(host.c_str(), connectivityType, &resourceHandles[0],
resourceHandles.size(), &cbdata, qos);
}
if (OC_STACK_OK != result)
{
throw OCException(OC::Exception::PUBLISH_RESOURCE_FAILED, result);
}
return result;
}
OCStackResult InProcClientWrapper::ObserveResource(ObserveType observeType, OCDoHandle* handle,
const OCDevAddr& devAddr,
const std::string& uri,
const QueryParamsMap& queryParams, const HeaderOptions& headerOptions,
ObserveCallback& callback, QualityOfService QoS)
{
if(!callback)
{
return OC_STACK_INVALID_PARAM;
}
OCStackResult result;
ClientCallbackContext::ObserveContext* ctx =
new ClientCallbackContext::ObserveContext(callback);
OCCallbackData cbdata(
static_cast<void*>(ctx),
observeResourceCallback,
[](void* c){delete static_cast<ClientCallbackContext::ObserveContext*>(c);}
);
OCMethod method;
if (observeType == ObserveType::Observe)
{
method = OC_REST_OBSERVE;
}
else if (observeType == ObserveType::ObserveAll)
{
method = OC_REST_OBSERVE_ALL;
}
else
{
method = OC_REST_OBSERVE_ALL;
}
std::string url = assembleSetResourceUri(uri, queryParams).c_str();
auto cLock = m_csdkLock.lock();
if(cLock)
{
std::lock_guard<std::recursive_mutex> lock(*cLock);
OCHeaderOption options[MAX_HEADER_OPTIONS];
result = OCDoResource(handle, method,
url.c_str(), &devAddr,
nullptr,
CT_DEFAULT,
static_cast<OCQualityOfService>(QoS),
&cbdata,
assembleHeaderOptions(options, headerOptions),
headerOptions.size());
}
else
{
delete ctx;
return OC_STACK_ERROR;
}
return result;
}
nsresult
WindowHook::RemoveMonitor(UINT nMsg, Callback callback, void *context) {
CallbackData cbdata(callback, context);
MessageData *data = Lookup(nMsg);
if (!data)
return NS_ERROR_UNEXPECTED;
CallbackDataArray::index_type idx = data->monitors.IndexOf(cbdata);
if (idx == CallbackDataArray::NoIndex)
return NS_ERROR_UNEXPECTED;
data->monitors.RemoveElementAt(idx);
DeleteIfEmpty(data);
return NS_OK;
}
nsresult
WindowHook::RemoveHook(UINT nMsg, Callback callback, void *context) {
CallbackData cbdata(callback, context);
MessageData *data = Lookup(nMsg);
if (!data)
return NS_ERROR_UNEXPECTED;
if (data->hook != cbdata)
return NS_ERROR_UNEXPECTED;
data->hook = CallbackData();
DeleteIfEmpty(data);
return NS_OK;
}
void CStats::Init()
{
std::ifstream openfile("config/cubes.txt");
// Read previously stored data
std::string cbdata((std::istreambuf_iterator<char>(openfile)), std::istreambuf_iterator<char>());
cubesdata = JSON->Parse(cbdata);
openfile.close();
openfile.open("config/points.txt");
std::string ptdata((std::istreambuf_iterator<char>(openfile)), std::istreambuf_iterator<char>());
ptsdata = JSON->Parse(ptdata);
return;
}
OCStackResult InProcClientWrapper::ListenErrorForResource(
const std::string& serviceUrl,
const std::string& resourceType,
OCConnectivityType connectivityType,
FindCallback& callback, FindErrorCallback& errorCallback,
QualityOfService QoS)
{
if (!callback)
{
return OC_STACK_INVALID_PARAM;
}
ostringstream resourceUri;
resourceUri << serviceUrl << resourceType;
ClientCallbackContext::ListenErrorContext* context =
new ClientCallbackContext::ListenErrorContext(callback, errorCallback,
shared_from_this());
if (!context)
{
return OC_STACK_ERROR;
}
OCCallbackData cbdata(
static_cast<void*>(context),
listenErrorCallback,
[](void* c){delete static_cast<ClientCallbackContext::ListenErrorContext*>(c);}
);
OCStackResult result;
auto cLock = m_csdkLock.lock();
if (cLock)
{
std::lock_guard<std::recursive_mutex> lock(*cLock);
result = OCDoResource(nullptr, OC_REST_DISCOVER,
resourceUri.str().c_str(),
nullptr, nullptr, connectivityType,
static_cast<OCQualityOfService>(QoS),
&cbdata,
nullptr, 0);
}
else
{
delete context;
result = OC_STACK_ERROR;
}
return result;
}
OCStackResult InProcClientWrapper::PutResourceRepresentation(
const OCDevAddr& devAddr,
const std::string& uri,
const OCRepresentation& rep,
const QueryParamsMap& queryParams, const HeaderOptions& headerOptions,
PutCallback& callback, QualityOfService QoS)
{
if(!callback)
{
return OC_STACK_INVALID_PARAM;
}
OCStackResult result;
ClientCallbackContext::SetContext* ctx = new ClientCallbackContext::SetContext(callback);
OCCallbackData cbdata(
static_cast<void*>(ctx),
setResourceCallback,
[](void* c){delete static_cast<ClientCallbackContext::SetContext*>(c);}
);
std::string url = assembleSetResourceUri(uri, queryParams).c_str();
auto cLock = m_csdkLock.lock();
if(cLock)
{
std::lock_guard<std::recursive_mutex> lock(*cLock);
OCDoHandle handle;
OCHeaderOption options[MAX_HEADER_OPTIONS];
result = OCDoResource(&handle, OC_REST_PUT,
url.c_str(), &devAddr,
assembleSetResourcePayload(rep),
CT_DEFAULT,
static_cast<OCQualityOfService>(QoS),
&cbdata,
assembleHeaderOptions(options, headerOptions),
headerOptions.size());
}
else
{
delete ctx;
result = OC_STACK_ERROR;
}
return result;
}
OCStackResult InProcClientWrapper::DeleteResource(
const OCDevAddr& devAddr,
const std::string& uri,
const HeaderOptions& headerOptions,
DeleteCallback& callback,
QualityOfService /*QoS*/)
{
if(!callback)
{
return OC_STACK_INVALID_PARAM;
}
OCStackResult result;
ClientCallbackContext::DeleteContext* ctx =
new ClientCallbackContext::DeleteContext(callback);
OCCallbackData cbdata(
static_cast<void*>(ctx),
deleteResourceCallback,
[](void* c){delete static_cast<ClientCallbackContext::DeleteContext*>(c);}
);
auto cLock = m_csdkLock.lock();
if(cLock)
{
OCHeaderOption options[MAX_HEADER_OPTIONS];
std::lock_guard<std::recursive_mutex> lock(*cLock);
result = OCDoResource(nullptr, OC_REST_DELETE,
uri.c_str(), &devAddr,
nullptr,
CT_DEFAULT,
static_cast<OCQualityOfService>(m_cfg.QoS),
&cbdata,
assembleHeaderOptions(options, headerOptions),
headerOptions.size());
}
else
{
delete ctx;
result = OC_STACK_ERROR;
}
return result;
}
OCStackResult InProcClientWrapper::SubscribePresence(OCDoHandle* handle,
const std::string& host, const std::string& resourceType,
OCConnectivityType connectivityType, SubscribeCallback& presenceHandler)
{
if(!presenceHandler)
{
return OC_STACK_INVALID_PARAM;
}
ClientCallbackContext::SubscribePresenceContext* ctx =
new ClientCallbackContext::SubscribePresenceContext(presenceHandler);
OCCallbackData cbdata(
static_cast<void*>(ctx),
subscribePresenceCallback,
[](void* c)
{delete static_cast<ClientCallbackContext::SubscribePresenceContext*>(c);}
);
auto cLock = m_csdkLock.lock();
std::ostringstream os;
os << host << OC_RSRVD_PRESENCE_URI;
if(!resourceType.empty())
{
os << "?rt=" << resourceType;
}
if(!cLock)
{
delete ctx;
return OC_STACK_ERROR;
}
return OCDoResource(handle, OC_REST_PRESENCE,
os.str().c_str(), nullptr,
nullptr, connectivityType,
OC_LOW_QOS, &cbdata, NULL, 0);
}
void CStats::FullUpdateCubes()
{
std::ifstream openfile("config/cubes.txt");
// Read previously stored data
std::string cbdata((std::istreambuf_iterator<char>(openfile)), std::istreambuf_iterator<char>());
Json::Value cb = JSON->Parse(cbdata);
std::string ip = "18.4.45.12";
openfile.close();
openfile.open("config/specialapi.txt");
std::string specapi((std::istreambuf_iterator<char>(openfile)), std::istreambuf_iterator<char>());
Json::Value special_api = JSON->Parse(specapi);
openfile.close();
time_t timer = time(NULL);
timer -= (3600 * 7);
std::string prevdate;
do {
std::string date = Utils::MakeDate(timer);
timer -= (3600 * 24);
prevdate = Utils::MakeDate(timer);
std::string callstr = "request=5×pan=custom&startTime="+prevdate+"&endTime="+date;
std::cout << date << std::endl;
char *buf = new char[5];
_itoa(strlen(callstr.c_str()), buf, 10);
std::string len = buf;
delete [] buf;
std::string request;
// Sorry, I can't show you these
request += "POST " + special_api["url"].asString() + " HTTP/1.1\r\n";
request += "Host: " + special_api["host"].asString() + "\r\n";
request += "Content-type: application/x-www-form-urlencoded\r\n";
request += "Connection: close\r\n";
request += "Content-length: " + len + "\r\n\r\n";
request += callstr;
SOCKET sock = Socket->CreateSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
std::string response = Socket->SendData(sock, ip, 80, request);
Socket->DeleteSocket(sock);
int end = response.find("[");
response.erase(0, end);
Json::Value cubedata = JSON->Parse(response);
for (auto user : cubedata)
{
cb[user["username"].asString()][prevdate] = user["cubes"].asString();
}
} while (prevdate != "2012-05-01");
Json::FastWriter writer;
std::string out = writer.write(cb);
std::ofstream fileo("config/cubes.txt", std::ios::trunc);
fileo << out;
fileo.close();
}
