void ofxTwitter::checkHelpConfigurationFile() {
ofFile file(ofToDataPath("ofxTwitter_configuration.json"));
bool configFileNeedsUpdate = false;
if(file.exists()) {
Poco::File &filepoco = file.getPocoFile();
Poco::Timestamp tfile = filepoco.getLastModified();
time_t timer;
time(&timer);
double seconds;
seconds = difftime(timer,tfile.epochTime());
if(seconds < 86400) {
configFileNeedsUpdate = false;
} else {
configFileNeedsUpdate = true;
}
} else {
configFileNeedsUpdate = true;
}
if(!configFileNeedsUpdate) {
ofLogNotice("ofxTwitter::authorize") << "Config up to date.";
parseConfigurationFile();
} else {
updateHelpConfiguration();
}
}
void Context::flushSessionCache()
{
poco_assert (isForServerUse());
Poco::Timestamp now;
SSL_CTX_flush_sessions(_pSSLContext, static_cast<long>(now.epochTime()));
}
void TrafficDataObject::deleteOld()
{
Poco::Timestamp achshav;
Poco::Timespan days = Poco::Timespan::DAYS * Poco::Util::Application::instance().config().getUInt("ion.trafficage");
achshav -= days;
std::time_t age = achshav.epochTime();
_session << "DELETE FROM traffic WHERE time<?", use(age), now;
}
std::time_t UIShader::getLastModified( ofFile& _file ){
if( _file.exists() ){
Poco::File& pocoFile = _file.getPocoFile();
Poco::Timestamp timestamp = pocoFile.getLastModified();
std::time_t fileChangedTime = timestamp.epochTime();
return fileChangedTime;
} else {
return 0;
}
}
void TrafficDataObject::checkAuthStatus()
{
Poco::Timestamp achshav;
Poco::Timespan days = Poco::Timespan::MINUTES * Poco::Util::Application::instance().config().getUInt("ion.traffic-interval");
achshav -= days;
std::time_t age = achshav.epochTime();
unsigned count = 0;
_session << "SELECT sum(count) AS count FROM traffic WHERE time>? AND "
"traffic.domain NOT IN (SELECT value FROM authorized_traffic WHERE type='domain') AND "
"traffic.ip NOT IN (SELECT value FROM authorized_traffic WHERE type='ip') AND "
"traffic.port NOT IN (SELECT value FROM authorized_traffic WHERE type='port') AND "
"traffic.process NOT IN (SELECT value FROM authorized_traffic WHERE type='process')", use(age), into(count), now;
if (count > 0) {
_logger.notice("Non authorized traffic count %u", count);
EventNotification::notifyTraffic(count);
}
}
void ICalendarWatcher::refresh()
{
Poco::Timestamp now; // the current time
if (_calendar)
{
ICalendar::EventInstances oldInstances = _watches;
ICalendar::EventInstances newInstances = _calendar->getEventInstances(now);
// sort uids lexigraphically
std::sort(oldInstances.begin(), oldInstances.end(), compareUID);
std::sort(newInstances.begin(), newInstances.end(), compareUID);
// unmatchedOldInstances are those events instances that are NOT
// seen in the current instanaces. if an instance is NOT seen,
// that means that an instance has ended (we can check for that)
// OR the event was "modified" -- that is -- the equality
// relationship didn't hold and we need to check for UID equality
// in this case -- OR the event was deleted altogether from the
// calendar.
ICalendar::EventInstances unmatchedOldInstances;
// unmatchedNewInstances are those instances that did not have an
// equality match inside of the watchedInstances vector. Events in
// this array can fall into three categories: 1) a modified event
// -- == opererator failed because of a different modified date,
// 2) an event that has just started 3) an in-progress event that
// was added after its start time.
ICalendar::EventInstances unmatchedNewInstances;
// newWatches will eventually replace _watches when the refresh is done
ICalendar::EventInstances newWatches;
// std::set_difference - what is in first set, but not in the second one
// TODO: combine all three of these steps into a single loop
// find any instances that are in the current watch list that are no longer there
std::set_difference(oldInstances.begin(),
oldInstances.end(),
newInstances.begin(),
newInstances.end(),
std::inserter(unmatchedOldInstances,
unmatchedOldInstances.end()),
compareUID);
// find any new instances that are not matched in the current watchlist
std::set_difference(newInstances.begin(),
newInstances.end(),
oldInstances.begin(),
oldInstances.end(),
std::inserter(unmatchedNewInstances,
unmatchedNewInstances.end()),
compareUID);
// find all instances that are still are the same in both sets.
// these instances must be checked for modification times.
std::set_intersection(newInstances.begin(),
newInstances.end(),
oldInstances.begin(),
oldInstances.end(),
std::inserter(newWatches,
newWatches.end()),
compareUID);
// process the unmatched old instances
ICalendar::EventInstances::iterator unmatchedOldInstancesIter = unmatchedOldInstances.begin();
while (unmatchedOldInstancesIter != unmatchedOldInstances.end())
{
ICalendarEventInstance& instance = *unmatchedOldInstancesIter;
Poco::Timestamp startTime = instance.getInterval().getStart();
Poco::Timestamp endTime = instance.getInterval().getEnd();
if (!instance.isValidEventInstance() || endTime.epochTime() < _lastUpdate.epochTime())
{
ofNotifyEvent(events.onEventRemoved, instance, this);
}
else
{
ofNotifyEvent(events.onEventEnded, instance, this);
}
++unmatchedOldInstancesIter;
}
// process the old matches and check them for updates
// process the unmatched old instances
ICalendar::EventInstances::iterator newWatchesIter = newWatches.begin();
while (newWatchesIter != newWatches.end())
{
const ICalendarEvent& evt = (*newWatchesIter).getEvent();
std::string uid = evt.getUID();
Poco::Timestamp lastModified = evt.getLastModified();
std::map<std::string, Poco::Timestamp>::iterator lastUpdatedIter = _watchesLastUpdated.find(uid);
if (lastUpdatedIter != _watchesLastUpdated.end() &&
lastModified.epochTime() > _watchesLastUpdated[uid].epochTime())
{
ofNotifyEvent(events.onEventModified, *newWatchesIter, this);
}
++newWatchesIter;
}
// process the new instances (add them to the watch list and the updated group)
ICalendar::EventInstances::iterator unmatchedNewInstancesIter = unmatchedNewInstances.begin();
while (unmatchedNewInstancesIter != unmatchedNewInstances.end())
{
ICalendarEventInstance& instance = *unmatchedNewInstancesIter;
std::string uid = instance.getEvent().getUID();
Poco::Timestamp startTime = instance.getInterval().getStart();
Poco::Timestamp endTime = instance.getInterval().getEnd();
if (startTime.epochTime() >= _lastUpdate.epochTime())
{
ofNotifyEvent(events.onEventStarted, instance, this);
}
else
{
ofNotifyEvent(events.onEventAdded, instance, this);
}
newWatches.push_back(instance); // add to current watches
++unmatchedNewInstancesIter;
}
// make a record of the watches
_watches = newWatches;
// clear out old last udpated lists
_watchesLastUpdated.clear();
ICalendar::EventInstances::iterator iter = _watches.begin();
while (iter != _watches.end())
{
const ICalendarEvent& evt = (*iter).getEvent();
_watchesLastUpdated[evt.getUID()] = evt.getLastModified();
++iter;
}
}
else
{
ofLogError("ICalendarWatcher::refresh()") << "Calendar null.";
}
_lastUpdate = now;
}
//--------------------------------------------------------------
void CloudsVHXAuth::threadedFunction()
{
completeArgs.success = false;
completeArgs.result = "";
if (mode == REQUEST_TOKEN || mode == REFRESH_TOKEN) {
_ssl.setup();
_ssl.setOpt(CURLOPT_CAINFO, ofToDataPath(GetCloudsDataPath(true) + "vhx/cacert.pem"));
_ssl.setURL("https://api.vhx.tv/oauth/token");
if (mode == REQUEST_TOKEN) {
_ssl.addFormField("client_id", _clientId);
_ssl.addFormField("client_secret", _clientSecret);
_ssl.addFormField("grant_type", "client_credentials");
}
else {
_ssl.addFormField("refresh_token", _refreshToken);
_ssl.addFormField("grant_type", "refresh_token");
}
_ssl.perform();
string response = _ssl.getResponseBody();
ofLogVerbose("CloudsVHXAuth::threadedFunction") << "Response:" << endl << response;
completeArgs.success = false;
ofxJSONElement json;
if (json.parse(response)) {
if (json.isMember("access_token")) {
_accessToken = json["access_token"].asString();
_refreshToken = json["refresh_token"].asString();
_tokenExpiry = (ofGetSystemTime() / 1000.f) + json["expires_in"].asFloat();
// Save the tokens to disk.
CloudsCryptoSaveTokens(_accessToken, _refreshToken, _tokenExpiry, _tokensPath);
completeArgs.success = true;
completeArgs.result = _accessToken;
}
else {
ofLogError("CloudsVHXAuth::threadedFunction") << "Unexpected JSON format:" << endl << response;
}
}
else {
ofLogError("CloudsVHXAuth::threadedFunction") << "Unable to parse JSON:" << endl << response;
}
_ssl.clear();
bNotifyComplete = true;
}
else if (mode == REQUEST_CODE) {
_ssl.setup();
_ssl.setOpt(CURLOPT_CAINFO, ofToDataPath(GetCloudsDataPath(true) + "vhx/cacert.pem"));
_ssl.setURL("https://api.vhx.tv/oauth/codes");
_ssl.addFormField("client_id", _clientId);
_ssl.addFormField("client_secret", _clientSecret);
_ssl.perform();
string response = _ssl.getResponseBody();
ofLogVerbose("CloudsVHXAuth::threadedFunction") << "Response:" << endl << response;
completeArgs.success = false;
ofxJSONElement json;
if (json.parse(response)) {
if (json.isMember("code")) {
_code = json["code"].asString();
_codeExpiry = (ofGetSystemTime() / 1000.f) + json["expires_in"].asFloat();
completeArgs.success = true;
completeArgs.result = _code;
}
else {
ofLogError("CloudsVHXAuth::threadedFunction") << "Unexpected JSON format:" << endl << response;
}
}
else {
ofLogError("CloudsVHXAuth::threadedFunction") << "Unable to parse JSON:" << endl << response;
}
_ssl.clear();
bNotifyComplete = true;
}
else if (mode == LINK_CODE) {
stringstream ss;
ss << "http://www.vhx.tv/activate/clouds";
ss << "?client_id=" << _clientId;
ss << "&code=" << _code;
ofLaunchBrowser(ss.str());
ss.str("");
ss << "https://api.vhx.tv/oauth/codes/" << _code;
ss << "?client_id=" << _clientId;
ss << "&client_secret=" << _clientSecret;
completeArgs.success = false;
bool bWaitForLink = true;
while (bWaitForLink && isThreadRunning()) {
_ssl.setup();
_ssl.setOpt(CURLOPT_CAINFO, ofToDataPath(GetCloudsDataPath(true) + "vhx/cacert.pem"));
_ssl.setURL(ss.str());
_ssl.perform();
string response = _ssl.getResponseBody();
ofLogVerbose("CloudsVHXAuth::threadedFunction") << "Response:" << endl << response;
ofxJSONElement json;
if (json.parse(response)) {
if (json.isMember("access_token")) {
_accessToken = json["access_token"].asString();
_refreshToken = json["refresh_token"].asString();
_tokenExpiry = (ofGetSystemTime() / 1000.f) + json["expires_in"].asFloat();
// Save the tokens to disk.
CloudsCryptoSaveTokens(_accessToken, _refreshToken, _tokenExpiry, _tokensPath);
completeArgs.success = true;
completeArgs.result = _accessToken;
bWaitForLink = false;
}
else {
ofLogVerbose("CloudsVHXAuth::threadedFunction") << "Unexpected JSON result:" << endl << response;
}
}
else {
ofLogError("CloudsVHXAuth::threadedFunction") << "Unable to parse JSON:" << endl << response;
bWaitForLink = false;
}
_ssl.clear();
ofSleepMillis(500);
}
bNotifyComplete = true;
}
else if (mode == VERIFY_PACKAGE) {
stringstream ss;
ss << "Authorization: Bearer " << _accessToken;
_ssl.setup();
_ssl.setOpt(CURLOPT_CAINFO, ofToDataPath(GetCloudsDataPath(true) + "vhx/cacert.pem"));
_ssl.setURL("https://api.vhx.tv/me");
_ssl.addHeader(ss.str());
_ssl.perform();
string response = _ssl.getResponseBody();
ofLogVerbose("CloudsVHXAuth::threadedFunction") << "Response:" << endl << response;
cout << "RESPONSE " << response << endl;
completeArgs.success = false;
ofxJSONElement json;
if (json.parse(response)) {
if (json.isMember("_embedded")) {
const ofxJSONElement& embedded = json["_embedded"];
if (embedded.isMember("packages")) {
const ofxJSONElement& packages = embedded["packages"];
if(packages.size() > 0){
for (int i = 0; i < packages.size(); ++i) {
const ofxJSONElement& element = packages[i];
if (element.isMember("id")) {
string packageId = element["id"].asString();
if (packageId == _packageId || packageId == "8102") { //hack for rental
// Found matching package, check that purchase is valid.
if (element.isMember("purchase_type")) {
string purchaseType = element["purchase_type"].asString();
if (purchaseType == "purchase") {
state = PURCHASE;
completeArgs.success = true;
completeArgs.result = "purchase";
break;
}
else if (purchaseType == "rental") {
if (element.isMember("expires_at")) {
if (element["expires_at"].isNull()) {
// No expiry, assume we're good.
state = RENTAL;
completeArgs.success = true;
completeArgs.result = "rental";
break;
}
else {
// Parse the expiry date.
Poco::DateTime dt;
int tzd;
if (Poco::DateTimeParser::tryParse(element["expires_at"].asString(), dt, tzd)) {
Poco::LocalDateTime ldt(tzd, dt);
Poco::Timestamp expiryTime = ldt.timestamp();
Poco::Timestamp nowTime;
// Make sure the rental is valid.
if (nowTime < expiryTime) {
// Expires in the future, we're good.
_packageExpiry = expiryTime.epochTime();
state = RENTAL;
completeArgs.success = true;
completeArgs.result = "rental";
break;
}
else {
// Expired, no good.
state = EXPIRED;
completeArgs.success = true;
completeArgs.result = "expired";
continue; //check other packages
}
}
else {
// Could not parse expiry, assume no good.
state = EXPIRED;
completeArgs.success = true;
completeArgs.result = "expired";
continue; //check the other packages
}
}
}
else {
// No expiry, assume we're good.
state = RENTAL;
completeArgs.success = true;
completeArgs.result = "rental";
break;
}
}
else {
// Not a rental or purchase, assume no good.
state = INACTIVE;
completeArgs.success = true;
completeArgs.result = "inactive";
continue; //check the other packages
}
}
else {
ofLogError("CloudsVHXAuth::threadedFunction") << "Unexpected JSON result, 'purchase_type' not found:" << endl << response;
}
}
else {
ofLogNotice("CloudsVHXAuth::threadedFunction") << "Skipping package " << packageId;
}
}
else {
ofLogError("CloudsVHXAuth::threadedFunction") << "Unexpected JSON result, 'id' not found:" << endl << response;
}
}
}
else {
state = INACTIVE;
completeArgs.success = true;
completeArgs.result = "inactive";
}
}
else {
ofLogError("CloudsVHXAuth::threadedFunction") << "Unexpected JSON result, 'packages' not found:" << endl << response;
}
}
else {
ofLogError("CloudsVHXAuth::threadedFunction") << "Unexpected JSON result, '_embedded' not found:" << endl << response;
}
}
else {
ofLogError("CloudsVHXAuth::threadedFunction") << "Unable to parse JSON:" << endl << response;
}
_ssl.clear();
bNotifyComplete = true;
}
else {
ofLogError("CloudsVHXAuth::threadedFunction") << "Mode " << mode << " is unrecongized!";
}
}