def query_bitly(longUrl, user):
l = urllib.quote(longUrl, '')
if (longUrl[:7].lower() != 'http://'
and urllib.unquote(longUrl)[:7].lower() != 'http://'
and longUrl[:8].lower() != 'https://'
and urllib.unquote(longUrl)[:8].lower() != 'https://'):
l = urllib.quote('http://' + longUrl, '')
result = urlfetch.fetch(JMP_URL + l)
logging.debug('posted to bit.ly: %s' % l)
if result.status_code != 200:
return 'Sorry! Query failed.'
j = json.JSONDecoder()
data = j.decode(result.content)
if data.get('status_code') == 403:
logging.warning('RATE LIMIT EXCEEDED')
return 'Sorry! Experiencing rate limits from bit.ly'
if data.get('status_code') != 200:
logging.error(result.content)
return 'Sorry! bit.ly did not accept the query. Make sure that your message only contains a URL.'
url = Url(longUrl=data.get('data').get('long_url'),
shortUrl=data.get('data').get('url'),
creator=user)
url.put()
return data.get('data').get('url')
def post(self):
decoded = simplejson.JSONDecoder().decode(self.request.body)
mySensor = db.GqlQuery(
"SELECT __key__ FROM Sensor WHERE name=:1 AND vendor=:2 AND version=:3",
decoded.get('name'), decoded.get('vendor'),
decoded.get('version')).get()
if mySensor == None:
newSensor = Sensor()
type = decoded.get('type')
testsensortype = db.GqlQuery(
"SELECT __key__ FROM SensorType WHERE type=:1", type).get()
if testsensortype == None:
sensortype = SensorType()
sensortype.type = type
sensortype.put()
newSensor.type = sensortype.key().id()
else:
newSensor.type = testsensortype.id()
newSensor.name = decoded.get('name')
newSensor.vendor = decoded.get('vendor')
newSensor.version = decoded.get('version')
newSensor.put()
self.response.set_status(201)
self.response.out.write(simplejson.JSONEncoder().encode(
{"id": newSensor.key().id()}))
else:
self.response.set_status(200)
self.response.out.write(simplejson.JSONEncoder().encode(
{"id": mySensor.id()}))
def list_competitors(self, campaignid, type):
#type 0=array for drop down,1=json for drop down,2=all values
self.blResource = (self.blUrl + self.key + "/campaigns/" +
str(campaignid) + "/hotCompetitors")
self.url = self.blResource
self.method = "GET"
response = self.apiCall()
newdata = simplejson.JSONDecoder().decode(response)
if type == 0:
#Array for Drop Down
choices = []
choices.append(('0', '(all)'))
for i in newdata["items"]:
choices.append((i["url"], i["name"]))
elif type == 1:
#JSON
choices = {}
choices[0] = "(all)"
for i in newdata["items"]:
choices[i["url"]] = i["name"]
elif type == 2:
#Array (all values)
choices = []
for i in newdata["items"]:
choices.append((i["id"], i["url"], i["name"]))
return choices
def __init__(self, verbose_name=None, name=None,
encoder=DjangoJSONEncoder(), decoder=simplejson.JSONDecoder(),
**kwargs):
blank = kwargs.pop('blank', True)
models.TextField.__init__(self, verbose_name, name, blank=blank,
**kwargs)
self.encoder = encoder
self.decoder = decoder
def campaign_save(self, id, values):
self.blResource = (self.blUrl + self.key + "/campaigns/" + str(id))
self.url = self.blResource
self.method = "POST"
self.params = values
response = self.apiCall()
newdata = simplejson.JSONDecoder().decode(response)
return newdata
def list_keywords(self, campaignid, groupid):
self.blResource = (self.blUrl + self.key + "/campaigns/" +
str(campaignid) + "/groups/" + str(groupid))
self.url = self.blResource
response = self.apiCall()
newdata = simplejson.JSONDecoder().decode(response)
kwlist = newdata["data"]["terms"]
return kwlist
def get(self):
tracks = Track.get_all(self.request.get('offset'))
dec = json.JSONDecoder()
for t in tracks:
if t.raw is None:
continue
if '-' in t.uuid:
continue
data = dec.decode(t.raw)
dist = 0
prev_lat = None
prev_lng = None
max_diff = 0.0
nr = 0
sum_acc = 0
for p in data['track']:
if p['acc'] > 30:
continue
sum_acc += p['acc']
lat = p['lat']
lng = p['long']
if prev_lat and prev_lng:
lat_diff = math.fabs(lat - prev_lat)
lng_diff = math.fabs(lng - prev_lng)
diff = math.sqrt((lat_diff * 111111)**2 +
(lng_diff * 75500)**2)
if diff > max_diff:
max_diff = diff
nr += 1
dist += diff
prev_lat = lat
prev_lng = lng
if not nr:
continue
avg_acc = sum_acc / float(nr)
avg_dist = float(dist) / float(nr)
t.avg_dist = avg_dist
t.avg_acc = float(avg_acc)
t.nr = nr
t.put()
if max_diff > 200:
self.response.out.write(
"[%d] Track distance: %d nr: %d - our distance: %d - max diff: %f - avg acc: %f - avg dist: %f\n"
% (t.key().id(), data['distance'], nr, dist, max_diff,
avg_acc, avg_dist))
def encode_json(obj):
""" also encode Django objects to Json, preferebly by id-name"""
if isinstance(obj, Medium):
return "%s - %s" % (obj.id, obj.name)
if isinstance(obj, table3.Table):
return simplejson.JSONDecoder().decode(TableToJson().run(obj)) # TODO: this is very ugly and inefficient.. (double encoding..)
if isinstance(obj, datetime.datetime):
return obj.strftime('%Y-%m-%d %H:%M')
raise TypeError("%r is not JSON serializable" % (obj,))
def post(self, id=None):
decoded = simplejson.JSONDecoder().decode(self.request.body)
#Create a new device and save it
device = Device()
device.sensors = decoded.get('sensors')
device.put()
self.response.set_status(201)
self.response.out.write(Utils.GqlEncoder().encode({"id":
device.key()}))
def load_events(self, obj, path):
"""
Load events from JSON file
"""
# Decode JSON
with open(path) as f:
try:
data = simplejson.JSONDecoder().decode(f.read())
except ValueError, why:
raise CommandError("Failed to decode JSON file \"%s\": %s" %
(path, why))
def post(self):
decoded = simplejson.JSONDecoder().decode(self.request.body)
data = Data()
data.test_id = decoded.get('test_id')
data.device_id = decoded.get('device_id')
data.content = decoded.get('content')
data.put()
self.response.set_status(201)
self.response.out.write(simplejson.JSONEncoder().encode(
{"id": data.key().id()}))
def log_action(request, game_name):
play = get_object_or_404(SavedPlay, pk=request.session['current_play_id_for_%s' % game_name])
log = request.POST.get('log','')
for line in StringIO(log.encode('utf-8')):
ev = simplejson.JSONDecoder().decode(line)
entry = LogEntry(savedplay=play, type=ev['type'],
ms=ev['time'], order=ev['order'], _data='')
entry.data = ev['data']
entry.save()
return json_to_response({'status':200})
def set_score(request, game_name):
play = get_object_or_404(SavedPlay, pk=request.session['current_play_id_for_%s' % game_name])
if request.user.is_authenticated():
user = get_object_or_404(Profile, username=request.user.profile.username)
state = simplejson.JSONDecoder().decode(user.current_state)
state[game_name] = request.GET.getlist('state')
user.current_state = simplejson.dumps(state)
user.save()
if play.score < int(request.GET['score']):
play.score = request.GET['score']
play.save()
return json_to_response({'status':200})
def shorten(url):
gurl = 'http://goo.gl/api/url?url=%s' % urllib.unquote(url)
req = Request(gurl, data='')
req.add_header('User-Agent', 'toolbar')
logging.info('Shortening ' + gurl)
try:
res = urlopen(req)
results = json.load(res)
logging.info(res.code)
except HTTPError, e: #triggers on HTTP code 201
logging.info(e.code)
error_content = e.read()
results = json.JSONDecoder().decode(error_content)
def deserialize(self, string):
params_dict = urlparse.parse_qs(string)
params = dict(params_dict)
parameters = params.get('params')
if (parameters == None):
parameters = []
json_obj = {
"method": str(params.get('method')[0]),
"params": parameters,
"id": 1
}
return json.JSONDecoder().decode(
AugmentedJSONEncoder().encode(json_obj))
def list_campaigns(self, all, array):
self.blResource = (self.blUrl + self.key + "/campaigns")
self.url = self.blResource
response = self.apiCall()
if array == True:
newdata = simplejson.JSONDecoder().decode(response)
choices = []
if all == True:
for i in newdata["items"]:
choices.append((i["id"], i["name"]))
else:
for i in newdata["items"]:
if i["isActive"] == True:
choices.append((i["id"], i["name"]))
return choices
else:
return response
def __init__(self, request, response):
self.request = request
self.status = None
if hasattr(response, 'code'):
self.status = response.code
self.json = None
self.data = None
if response:
self.data = response.read()
if response.code in [200]:
#log('request', 'debug', 'got api response: ' +self.data)
decoder = simplejson.JSONDecoder()
if self.data.startswith('{id:'):
self.data = self.data.replace('id', '"id"')
if self.data:
try:
if request.getType().lower() == 'delete':
self.json = {}
else:
self.json = decoder.decode(self.data)
except ValueError:
try:
keys = [
u'\xef', u'\xa0', u'\xa1', u'\xa2',
u'\xa3', u'\xa4', u'\xa5', u'\xa6',
u'\xa7', u'\xa8', u'\xa9', u'\xaa',
u'\xab', u'\xac', u'\xad', u'\xae',
u'\xaf', u'\xb0', u'\xb1', u'\xb2',
u'\xb3', u'\xb4', u'\xb5', u'\xb6',
u'\xb7', u'\xb8', u'\xb9', u'\xba',
u'\xbb', u'\xbc', u'\xbd', u'\xbe',
u'\xbf', u'\xef'
]
ucontent = unicode(self.data, 'latin-1')
for key in keys:
ucontent = ucontent.replace(key, u'')
self.data = ucontent.encode('utf-8')
self.json = decoder.decode(self.data)
except ValueError:
raise APIParseError(
'unable to parse json: %s' % self.data)
else:
self.json = {}
def __init__(self, verbose_name=None, name=None,
encoder=DjangoJSONEncoder(), decoder=simplejson.JSONDecoder(),
datatype=dict,
**kwargs):
"""
Create a new JSONField
:param verbose_name: The verbose name of the field
:param name: The short name of the field.
:param encoder: The encoder used to turn native datatypes into JSON.
:param decoder: The decoder used to turn JSON into native datatypes.
:param datatype: The native datatype to store.
:param kwargs: Other arguments to pass to parent constructor.
"""
blank = kwargs.pop('blank', True)
models.TextField.__init__(self, verbose_name, name, blank=blank,
**kwargs)
self.encoder = encoder
self.decoder = decoder
self.datatype = datatype
def list_keyword_groups(self, campaignid, type):
self.blResource = (self.blUrl + self.key + "/campaigns/" +
str(campaignid) + "/groups")
self.url = self.blResource
response = self.apiCall()
newdata = simplejson.JSONDecoder().decode(response)
if type == 0:
choices = []
choices.append(('0', '(all)'))
for i in newdata["items"]:
choices.append((str(i["id"]) + "|" + i["name"], i["name"]))
elif type == 1:
choices = {}
choices[0] = "(all)"
for i in newdata["items"]:
choices[str(i["id"]) + "|" + i["name"]] = i["name"]
elif type == 2:
choices = []
for i in newdata["items"]:
choices.append((i["id"], i["name"], i["numTerms"]))
return choices
def post(self):
try:
decoder = json.JSONDecoder()
trk = self.request.get('track')
if not trk:
raise Err("no track found")
data = decoder.decode(trk)
uploadtime = datetime.datetime.now()
distance = int(data['distance'])
track = Track(uuid=data['uuid'],
uploadtime=uploadtime,
distance=distance)
counter = Counter.get_by_key_name('distance')
if not counter:
counter = Counter(key_name='distance', value=24000)
counter.value += distance
counter.put()
number = Counter.get_by_key_name('number')
if not number:
number = Counter(key_name='number', value=130)
number.value += 1
number.put()
track.raw = trk
track.put()
# for p in data['track']:
# point = Point(parent=track, lat=p['lat'], lng=p['long'], acc=p['acc'], ts=datetime.datetime.fromtimestamp(p['ts']))
# point.put()
self.response.out.write('{"success":true}')
except Err, e:
self.response.out.write('{"success":false, "error":"%s"}' %
e.message)
def getReport(self, campaignId, report, format, values):
self.method = "POST"
self.blResource = (self.blUrl + self.key + "/reports/" + campaignId +
"/" + report + "/" + format)
self.url = self.blResource
self.params = values
response = self.apiCall()
if format == "json":
newdata = simplejson.JSONDecoder().decode(response)
self.values = []
for i in newdata["rows"]:
#for i in range(1, 7):
#print i["advertiser_url"]
for j in specs['brandlock'][report]:
self.values.append(i[j[1]])
#print i[j[1]]
#print values
self.specSize = len(specs['brandlock'][report])
return self.getReportHTML(report)
else:
return response
def getApiResponse(api_req):
''' Makes the API request and returns the response. The response is an APIResponse object.
Raises APIError on error conditions. The error conditions and the error raised are -
- APIParseError : Error parsing response. When response is not valid JSON with HTTP 200
- APIBadReqError : Error if request is malformed
- APIUnauthorizedError : API returned 403
- APIUnauthenticatedError : API returned 401
- APIServerError : API returned 5xx
'''
res = None
try:
data = None
url = api_req.getUrl()
req = None
if api_req.getData():
data = api_req.getData()
headers = {'Content-Type': 'application/json; charset=UTF-8'}
req = urllib2.Request(url, data, headers)
#logging.getLogger('pl').info(url)
#logging.getLogger('pl').info(data)
else:
if api_req.type.lower() == 'delete':
req = RequestWithMethod(url, data, api_req.getType())
else:
req = urllib2.Request(url, data)
#logging.getLogger('pl').info('testing')
#log('request','info','making api request - %s' % repr(api_req))
res = urllib2.urlopen(req)
except IOError, e:
logging.getLogger('pl').exception('error making api request')
if hasattr(e, 'reason'):
# unknown error, log it
log('error', 'exception',
'error conversing with api %s %s' % (repr(api_req), repr(e)))
raise APIError(e.reason)
if hasattr(e, 'code'):
# log all errors
log(
'error', 'exception', 'http error conversing with api %s %s' %
(repr(api_req), repr(e)))
expected_error_codes = [
400, 401, 403, 404, 500, 501, 502, 503, 504, 505
]
if e.code not in expected_error_codes:
raise APIError('invalid response from server')
else:
if e.code == 400:
badRequest = APIBadReqError('bad request : %s' %
repr(api_req))
resp = e.read()
log('error', 'error', 'Bad request in API usage %s' % resp)
decoder = simplejson.JSONDecoder()
resJson = decoder.decode(resp)
badRequest.json = resJson
raise badRequest
if e.code == 401:
raise APIUnauthenticatedError('not authenticated : %s' %
repr(api_req))
if e.code == 403:
raise APIUnauthorizedError('not authorized : %s' %
repr(api_req))
if e.code == 404:
raise APINotFoundError('resource not found : %s' %
repr(api_req))
# server error
raise APIServerError('server error during api req : %s' %
repr(api_req))
def decode(self, obj):
super(JSONDecoder, self).decode(obj)
import django.utils.simplejson as json
return json.JSONDecoder().decode(obj)
def campaign_info(self, id):
self.blResource = (self.blUrl + self.key + "/campaigns/" + str(id))
self.url = self.blResource
response = self.apiCall()
newdata = simplejson.JSONDecoder().decode(response)
return newdata
def get(self):
dump_tracks = False
if self.request.get('ids'):
tracks = Track.get_by_id(
[int(id) for id in self.request.get('ids').split(',')])
elif self.request.get('cursor'):
tracks = Track.all()
tracks.filter("ok =", True)
if self.request.get('cursor') != 'start':
tracks.with_cursor(memcache.get('cursor'))
ttt = tracks.fetch(limit=20)
logging.info("New cursor: " + tracks.cursor())
memcache.set('cursor', tracks.cursor())
tracks = ttt
else:
"""offset=123"""
tracks = Track.all()
tracks.filter("nr >", 40)
if self.request.get('limit'):
limit = int(self.request.get('limit'))
dump_tracks = True
else:
limit = 100
offset = int(self.request.get('offset'))
ttt = tracks.fetch(limit=limit, offset=offset)
logging.info("New cursor: " + tracks.cursor())
tracks = ttt
count = 0
dec = json.JSONDecoder()
for t in tracks:
if t.raw is None:
logging.critical("Track illegal %d" % t.key().id())
continue
if not t.max_diff:
logging.critical("max diff not found [%d]" % t.key().id())
continue
# if not t.avg_dist or not t.avg_acc:
# continue
#
if '-' in t.uuid:
logging.critical("Uid illegal %d" % t.key().id())
continue
# if len(t.uuid) == 40:
# type = 'iphone'
# elif len(t.uuid) < 20 and len(t.uuid) > 0:
# type = 'android'
# else:
# logging.critical('ehj')
self.response.out.write(
"<Placemark><ExtendedData>" +
"<Data name=\"avg_acc\"><displayName>avg_acc</displayName><value>%f</value></Data>"
% t.avg_acc +
"<Data name=\"avg_dist\"><displayName>avg_dist</displayName><value>%f</value></Data>"
% t.avg_dist +
"<Data name=\"max_diff\"><displayName>max_diff</displayName><value>%d</value></Data>"
% t.max_diff + "</ExtendedData><LineString><coordinates>")
count += 1
if dump_tracks:
if t.avg_dist > 100 or t.max_diff > 100 or t.avg_acc > 50:
logging.debug(
"Track [%d] - avg_dist=%f, max_diff=%d, avg_acc=%f" %
(t.key().id(), t.avg_dist, t.max_diff, t.avg_acc))
data = dec.decode(t.raw)
for p in data['track']:
self.response.out.write("%f,%f\n" % (p['long'], p['lat']))
self.response.out.write(
"</coordinates></LineString></Placemark>\n")
logging.info("processed %d tracks" % count)
