def extract(country_codes):
country_codes = [country_code.upper() for country_code in country_codes]
country_ids = []
region_ids = []
city_ids = []
fixtures_dir = '%s/../../fixtures' % os.path.dirname(__file__)
src_data = simplejson.load(open('%s/geonames_dump.json' % fixtures_dir), 'cp1252')
dest_data = []
for model in src_data:
model_type = model['model']
if model_type == 'cities.country':
if model['fields']['code'] in country_codes:
country_ids.append(model['pk'])
dest_data.append(model)
elif model_type == 'cities.region':
if model['fields']['country'] in country_ids:
region_ids.append(model['pk'])
dest_data.append(model)
elif model_type == 'cities.city':
if model['fields']['region'] in region_ids:
city_ids.append(model['pk'])
dest_data.append(model)
elif model_type == 'cities.district':
if model['fields']['city'] in city_ids: dest_data.append(model)
simplejson.dump(dest_data, open('%s/extracted_data.json' % fixtures_dir, 'w'), encoding='cp1252')
def orden_de_compra(request, numero, anio, format='html'):
orden = get_object_or_404(models.Compra, orden_compra=int(numero), fecha__year=int(anio))
if format == 'html':
return render_to_response('orden_de_compra.html',
{ 'orden': orden },
context_instance=RequestContext(request))
elif format == 'json':
response = HttpResponse(content_type = 'application/javascript')
obj = { 'href': orden.get_absolute_url(),
'numero': orden.oc_numero,
'fecha': orden.fecha.strftime('%Y-%m-%d'),
'importe': str(orden.importe),
'proveedor': { 'nombre': orden.proveedor.nombre,
'href': orden.proveedor.get_absolute_url() },
'destino': { 'nombre': orden.destino.nombre,
'href': orden.destino.get_absolute_url() },
'lineas': [ { 'cantidad': cli.cantidad,
'importe_unitario': str(cli.importe_unitario),
'detalle': cli.detalle } for cli in orden.compralineaitem_set.all()]
}
# si viene de una búsqueda, reemplazo el detalle por la version highlighteada
if '?q=' in request.META.get('HTTP_REFERER'):
qs = urlparse.parse_qs(urlparse.urlparse(request.META.get('HTTP_REFERER')).query)['q'][0]
hilites = [cli.highlight(' & '.join(qs.split())) for cli in orden.compralineaitem_set.all()]
for i in range(len(obj['lineas'])):
obj['lineas'][i]['detalle'] = hilites[i]
simplejson.dump(obj, response)
return response
else:
return HttpResponseBadRequest()
def orden_de_compra(request, numero, anio, format="html"):
orden = get_object_or_404(models.Compra, orden_compra=int(numero), fecha__year=int(anio))
if format == "html":
return render_to_response("orden_de_compra.html", {"orden": orden}, context_instance=RequestContext(request))
elif format == "json":
response = HttpResponse(content_type="application/javascript")
obj = {
"href": orden.get_absolute_url(),
"numero": orden.oc_numero,
"fecha": orden.fecha.strftime("%Y-%m-%d"),
"importe": str(orden.importe),
"proveedor": {"nombre": orden.proveedor.nombre, "href": orden.proveedor.get_absolute_url()},
"destino": {"nombre": orden.destino.nombre, "href": orden.destino.get_absolute_url()},
"lineas": [
{"cantidad": cli.cantidad, "importe_unitario": str(cli.importe_unitario), "detalle": cli.detalle}
for cli in orden.compralineaitem_set.all()
],
}
# si viene de una búsqueda, reemplazo el detalle por la version highlighteada
if "?q=" in request.META.get("HTTP_REFERER"):
qs = urlparse.parse_qs(urlparse.urlparse(request.META.get("HTTP_REFERER")).query)["q"][0]
hilites = [cli.highlight(" & ".join(qs.split())) for cli in orden.compralineaitem_set.all()]
for i in range(len(obj["lineas"])):
obj["lineas"][i]["detalle"] = hilites[i]
simplejson.dump(obj, response)
return response
else:
return HttpResponseBadRequest()
def get(self):
callback = self.request.get("cb")
channel = self.request.get("ch")
last_id = self.request.get("li")
messages = []
if not(last_id):
query = Comment.all()
query.filter('channel =', channel)
query.order('-mid')
results = query.fetch(10)
for result in results:
messages.append(
{"body": result.body, "id": result.mid, "date": result.date.strftime("%Y %m %d %H %M %S")})
else:
query = Comment.all()
query.filter('mid >', int(last_id))
query.filter('channel =', channel)
query.order('-mid')
for result in query:
messages.append(
{"body": result.body, "id": result.mid, "date": result.date.strftime("%Y %m %d %H %M %S")})
if len(messages) > 0:
data = {"success": True, "messages": messages,
"last_id": messages[0]["id"]}
else:
data = {"success": True, "messages": messages, "last_id": last_id}
if not(last_id):
data["init"] = True
else:
data["init"] = False
if not(callback):
simplejson.dump(data, self.response.out, ensure_ascii=False)
else:
self.response.out.write("%s(%s)" %
(callback, simplejson.dumps(data, ensure_ascii=False)))
def get(self):
user = users.get_current_user()
if not user:
json.dump(dict(error="not signed in"), self.response.out)
return
json.dump(application.gameState.get_board(), self.response.out)
def send_update(channel_id, data, already_serialized=False, ignore_errors=False):
if already_serialized:
serialized = data
length = len(data)
else:
serialized = StringIO()
simplejson.dump(data, serialized)
serialized.seek(0, 2)
length = serialized.tell()
serialized.seek(0)
request = urllib.Request(publisher_url(channel_id))
request.add_data(serialized)
request.add_unredirected_header('Content-type', 'application/json; charset=utf-8')
request.add_unredirected_header('Content-length', '%d' % length)
signals.pre_send_update.send(sender=sys.modules[__name__], channel_id=channel_id, data=data, already_serialized=already_serialized, request=request)
try:
response = urllib.urlopen(request)
except Exception as e:
signals.post_send_update.send(sender=sys.modules[__name__], channel_id=channel_id, data=data, already_serialized=already_serialized, request=request, response=e)
if ignore_errors or getattr(settings, 'PUSH_SERVER_IGNORE_ERRORS', False):
return
raise
signals.post_send_update.send(sender=sys.modules[__name__], channel_id=channel_id, data=data, already_serialized=already_serialized, request=request, response=response)
def orden_de_compra(request, numero, anio, format='html'):
orden = get_object_or_404(models.Compra, orden_compra=int(numero), fecha__year=int(anio))
if format == 'html':
return render_to_response('orden_de_compra.html',
{ 'orden': orden },
context_instance=RequestContext(request))
elif format == 'json':
response = HttpResponse(content_type = 'application/javascript')
obj = { 'href': orden.get_absolute_url(),
'numero': orden.oc_numero,
'fecha': orden.fecha.strftime('%Y-%m-%d'),
'importe': str(orden.importe),
'proveedor': { 'nombre': orden.proveedor.nombre,
'href': orden.proveedor.get_absolute_url() },
'destino': { 'nombre': orden.destino.nombre,
'href': orden.destino.get_absolute_url() },
'lineas': [ { 'cantidad': cli.cantidad,
'importe_unitario': str(cli.importe_unitario),
'detalle': cli.detalle } for cli in orden.compralineaitem_set.all()]
}
# si viene de una búsqueda, reemplazo el detalle por la version highlighteada
if '?q=' in request.META.get('HTTP_REFERER'):
qs = urlparse.parse_qs(urlparse.urlparse(request.META.get('HTTP_REFERER')).query)['q'][0]
hilites = [cli.highlight(' & '.join(qs.split())) for cli in orden.compralineaitem_set.all()]
for i in range(len(obj['lineas'])):
obj['lineas'][i]['detalle'] = hilites[i]
simplejson.dump(obj, response)
return response
else:
return HttpResponseBadRequest()
def get(self):
self.response.content_type = "application/json"
callback = self.request.get("cb")
body = self.request.get("bo")
channel = self.request.get("ch")
if not(body) or not(channel):
if not(ch):
simplejson.dump(
{"success": False}, self.response.out, ensure_ascii=False)
else:
self.response.out.write("%s(%s)" %
(callback, simplejson.dumps({"success": False}, ensure_ascii=False)))
else:
tmp = Comment.all()
tmp.filter('channel =', channel).order('-mid')
if tmp.count() <= 0:
latest_id = 1
else:
latest_id = tmp[0].mid + 1
comment = Comment(
body=cgi.escape(body), channel=channel, mid=latest_id)
comment.put()
if not(callback):
simplejson.dump(
{"success": True}, self.response.out, ensure_ascii=False)
else:
self.response.out.write("%s(%s)" %
(callback, simplejson.dumps({"success": True}, ensure_ascii=False)))
def get(self, name):
picture = Picture.find(name)
if picture:
self.response.headers["Content-Type"] = "text/json"
simplejson.dump(picture.to_obj(), self.response.out)
else:
self.error_response(404, API_ERROR_MISSING)
def end_serialization(self):
data = {
'files': self.files,
'objects': self.objects
}
simplejson.dump(data, self.stream, cls=json_s.DjangoJSONEncoder,
**self.options)
def error_response(self, status_code, message):
"""
Triggers an error response from an action
"""
self.response.set_status(status_code)
self.response.headers["Content-Type"] = "text/json"
simplejson.dump({"error": {"status": status_code, "message": message}}, self.response.out)
def building_list(request):
response = HttpResponse(mimetype="application/json")
json.dump([
{"name": b.name, "id": b.pk}
for b in Building.objects.all()
], response)
return response
def post(self, gamekey):
user = users.get_current_user()
self.response.headers.add_header("Content-Type", "application/json")
s = get_live_game(gamekey)
if s is None:
self.error(404)
return
# you can only reserve a spot if you are the owner
if s.get_board().owner != user:
self.error(401)
return
reservedForEmail = self.request.get("reservedFor")
logging.info("ReservedForEmail: %s" % reservedForEmail)
#TODO: make sure it's a valid email address
reservedFor = users.User(reservedForEmail)
#TODO: put reservation time limit in configuration file
reservationKey = s.reserve(reservedFor, 20)
logging.info("Reservation Processing: %s" % reservationKey)
if reservationKey is None:
json.dump({"reserved": False}, self.response.out)
else:
# send an email to them with the game key and reservation key
self.send_invitation(user, gamekey, reservedForEmail,
reservationKey)
json.dump({"reserved": True}, self.response.out)
def post(self):
user_id = self.request.get('user_id')
password = self.request.get('password')
# 验证是否重复添加
users = User.all().filter('owner =', current_user)
count = users.filter('user_id =', user_id).count()
if count:
json.dump({ 'error': True, 'reason': u'用户已存在' },
self.response.out)
return
# 验证用户名密码是否正确
headers = {
'Authorization': 'Basic ' +
base64.b64encode('%s:%s' %
(user_id.encode('utf8'), password.encode('utf8'))),
}
try:
resp = urlfetch.fetch(
'http://api.fanfou.com/account/verify_credentials.json',
headers=headers, deadline=10)
except Exception, e:
json.dump({ 'error': True, 'reason': u'错误 ' + repr(e) },
self.response.out)
def success_response(self, status_code, message, name):
"""
Triggers a success response from an action
"""
self.response.set_status(status_code)
self.response.headers["Content-Type"] = "text/json"
simplejson.dump({"success": {"message": message, "resource": "/picture/" + name}}, self.response.out)
def makeret(**kwargs):
last_changed = self.ajax_schedule_last_changed_cached(
prog).raw_value
kwargs['val'] = last_changed['val']
response = HttpResponse(content_type="application/json")
simplejson.dump(kwargs, response)
return response
def WritePicToPhone(handler, entry): handler.response.headers['Content-Type'] = 'application/jsonrequest' logging.info(entry.tag); logging.info(entry.value); logging.info(entry.extension); json.dump(["PICTURE", entry.tag, entry.value, entry.extension], handler.response.out)
def end_serialization(self):
stream = codecs.getwriter('utf-8')(self.stream)
simplejson.dump(
self.objects, stream,
cls=DjangoJSONEncoder,
ensure_ascii=False,
**self.options)
def list(self):
entries = db.GqlQuery("SELECT * FROM Userm ORDER BY id asc")
items = []
for entry in entries:
entry.password = ""
items.append(self.getOutputJsonObj(entry))
json.dump({Fields.root: items}, self.response.out)
def ajax_form_validate(request, form_class, success_message='ok'):
"""
Generic view to renders a json object with the main error of a field.
"""
if not request.is_ajax():
return HttpResponseForbidden('Access denied!')
field_name = request.POST['field_name']
field_value = request.POST['field_value']
form_errors = form_class({field_name: field_value}).errors
try:
field_message = unicode(form_errors[field_name][0])
status = 'invalid'
except KeyError:
field_message = success_message
status = 'valid'
data = {'field_message': field_message,
'status': status}
response = HttpResponse()
simplejson.dump(data, response)
return response
def get_testresult(request, hash):
""" Returns list of politician candidates ordered by score in a test result"""
# this is secured by hash only (you are the only one who knows the hash)
result = get_object_or_404(VisitorResult, hash = hash)
data = { 'date_time': result.datetime_stamp }
domain = u"http://%s" % Site.objects.get_current().domain
cand = []
for an in result.candidate_answers.select_related('candidate__profile').order_by('-candidates_score'):
profile = an.candidate.profile
party = profile.election_party().party
cand.append({
'id': an.pk,
'score': an.candidates_score,
'name': profile.full_name(),
#[FIXME: scaled version is needed!]
'picture': domain + (an.candidate.profile.picture.url if an.candidate.profile.picture else settings.MEDIA_URL + "defaults/pol-dummy_jpg_140x210_upscale_q85.jpg"),
'age': profile.age,
'region': profile.region(),
'position': profile.position(),
'party_short': party.abbreviation,
'party_name': party.name,
'profile_url': domain + reverse('fo.politician_profile', kwargs = {'id': an.candidate.id}),
})
data.update(candidates = cand)
response = HttpResponse(content_type = 'application/json')
simplejson.dump(data, response, cls=DjangoJSONEncoder, ensure_ascii=False)
return response
def end_serialization(self):
self.options.pop('stream', None)
self.options.pop('fields', None)
simplejson.dump(self.objects,
self.stream,
cls=DjangoJSONEncoder,
**self.options)
def yearly_reports(self):
from tech_services_reports.utility_code import yearly_reports as y
self.sort_orders()
yearly_totals = y()
simplejson.dump(yearly_totals,
open("%s/yearly.json" % settings_app.REPORT_DIR, 'w'), indent=2)
print>>sys.stderr, "Building sort and yearly totals dumped to to %s." % settings_app.REPORT_DIR
def reverse_geocoder(request):
"""Vue généralement appelée en AJAX. Retourne du JSON.
Paramètres: lat, lng - Coordonnées du point à reverse-géocoder.
Retourne le reverse-geocodage des paramètres, sous la forme 'Ville
(numéro du département)'.
Ne fonctionne que sur les données françaises.
"""
lat = float(request.REQUEST['lat'])
lng = float(request.REQUEST['lng'])
rgeocoder = ReverseGeocoder()
(city_name, city_zip, country_code) = rgeocoder.reverse({
'lat': lat,
'lng': lng,
'maxRows': 1,
})
response_dict = {}
if city_name and city_zip and country_code == 'FR':
response_dict = {
'city_name': u"%s (%s)" % (city_name, int(city_zip)/1000)
}
resp = HttpResponse()
simplejson.dump(
response_dict,
resp,
ensure_ascii=False,
separators=(',',':')
)
return resp
def get_givens(request):
# Parameters
handle = request.POST['handle']
services = request.POST['service']
# The source is the logged in user
source = request.user.get_profile().active_profile
# The destination is given in the query
try:
dest = Agent.objects.get(handle=handle,service=service)
except Agent.DoesNotExist:
return HttpResponse(json.dump({'tags': {}}))
# Get our connection
try:
connections = Connection.objects.get(src=source,dst=dest)
except Connection.DoesNotExist:
return HttResponse(json.dump({'tags': {}}))
# Get all the tags
tags = Tag.objects.filter(connection=connection).values(['name', 'confidence'])
# Send the response
return HttpResponse(json.dump({'tags': tags}))
def soft_download(request, apk_name):
"""
Return a downloadable file of the mobile soft
"""
response_content = {}
res, response = check_token(request)
if not res:
return response
file_path = "%s%s" % (settings.MOBILE_SOFT_PATH, apk_name)
try:
wrapper = FileWrapper(file(file_path))
response = HttpResponse(wrapper, content_type='text/plain')
response['Content-Length'] = os.path.getsize(file_path)
response['Content-Disposition'] = 'attachment; filename=%s' % (apk_name)
except:
response_content.update({
'status_code': _("1"),
'status_message': "APK file is not available (%s)" % (apk_name)
})
response = HttpResponse(status=404)
simplejson.dump(response_content, response,
ensure_ascii=False, separators=(',', ':'))
return response
return response
def data_download(request, mbtiles_name):
"""
Return the required mbtiles file
"""
response_content = {}
res, response = check_token(request)
if not res:
return response
file_path = "%s%s" % (settings.MOBILE_MBTILES_PATH, mbtiles_name)
try:
wrapper = FileWrapper(file(file_path))
response = HttpResponse(wrapper, content_type='text/plain')
response["Last-Modified"] = http_date(os.stat(file_path).st_mtime)
response['Content-Length'] = os.path.getsize(file_path)
response['Content-Disposition'] = 'attachment; filename=%s' % (mbtiles_name)
except:
response_content.update({
'status_code': _("1"),
'status_message': "File is not available (%s)" % (mbtiles_name)
})
response = HttpResponse(status=404)
simplejson.dump(response_content, response,
ensure_ascii=False, separators=(',', ':'))
return response
return response
def import_data(request):
"""
Import data from json to DataBase
"""
response_content = {}
params = request.POST
if params:
data = params['data']
else:
response_content.update({
'status': _("No POST param given")
})
response = HttpResponse()
simplejson.dump(response_content, response,
ensure_ascii=False, separators=(',', ':'))
return response
res, response = check_token(request)
if not res:
return response
json_data = simplejson.loads(data)
if json_data['input_type'] == 'flora':
response = import_data_flora(json_data, data)
else:
response = import_data_fmi(json_data, data)
return response
def soft_version(request):
"""
Return the version of the mobile soft (JSON) by reading a json config file
"""
response_content = {'apps': []}
res, response = check_token(request)
if not res:
return response
# read the version file
version_file = "%sversion.json" % (settings.MOBILE_SOFT_PATH)
try:
json_data = open(version_file)
version_data = simplejson.load(json_data)
json_data.close()
for apps in version_data['apps']:
response_content['apps'].append({
"package": apps["package"],
"sharedUserId": apps["sharedUserId"],
"versionCode": apps["versionCode"],
"versionName": apps["versionName"],
"apkName": apps["apkName"],
})
except:
response_content.update({
'status_code': _("1"),
'status_message': "Version file is not available"
})
response = HttpResponse()
simplejson.dump(response_content, response,
ensure_ascii=False, separators=(',', ':'))
return response
def orden_de_compra(request, numero, anio, format='html'):
orden = get_object_or_404(models.Compra, orden_compra=int(numero), fecha__year=int(anio))
if format == 'html':
return render_to_response('orden_de_compra.html',
{ 'orden': orden },
context_instance=RequestContext(request))
elif format == 'json':
response = HttpResponse(content_type = 'application/javascript')
obj = { 'href': orden.get_absolute_url(),
'numero': orden.oc_numero,
'fecha': orden.fecha.strftime('%Y-%m-%d'),
'importe': str(orden.importe),
'proveedor': { 'nombre': orden.proveedor.nombre,
'href': orden.proveedor.get_absolute_url() },
'destino': { 'nombre': orden.destino.nombre,
'href': orden.destino.get_absolute_url() },
'lineas': [ { 'cantidad': cli.cantidad,
'importe_unitario': str(cli.importe_unitario),
'detalle': cli.detalle } for cli in orden.compralineaitem_set.all()]
}
simplejson.dump(obj, response)
return response
else:
return HttpResponseBadRequest()
def end_serialization(self):
stream = codecs.getwriter('utf8')(self.stream)
simplejson.dump(self.objects,
stream,
cls=DjangoJSONEncoder,
ensure_ascii=False,
**self.options)
def sitemap_json_view(self, request):
"""Returns a JSON data structure describing the sitemap."""
# Get the homepage.
homepage = request.pages.homepage
# Compile the initial data.
data = {
"canAdd": self.has_add_permission(request),
"createHomepageUrl": reverse("admin:pages_page_add") + "?{0}={1}".format(PAGE_FROM_KEY, PAGE_FROM_SITEMAP_VALUE),
"moveUrl": reverse("admin:pages_page_move_page") or None,
"addUrl": reverse("admin:pages_page_add") + "?{0}={1}&parent=__id__".format(PAGE_FROM_KEY, PAGE_FROM_SITEMAP_VALUE),
"changeUrl": reverse("admin:pages_page_change", args=("__id__",)) + "?{0}={1}".format(PAGE_FROM_KEY, PAGE_FROM_SITEMAP_VALUE),
"deleteUrl": reverse("admin:pages_page_delete", args=("__id__",)) + "?{0}={1}".format(PAGE_FROM_KEY, PAGE_FROM_SITEMAP_VALUE),
}
# Add in the page data.
if homepage:
def sitemap_entry(page):
children = []
for child in page.children:
children.append(sitemap_entry(child))
return {
"isOnline": page.is_online,
"id": page.id,
"title": unicode(page),
"children": children,
"canChange": self.has_change_permission(request, page),
"canDelete": self.has_delete_permission(request, page),
}
data["entries"] = [sitemap_entry(homepage)]
else:
data["entries"] = []
# Render the JSON.
response = HttpResponse(content_type="application/json; charset=utf-8")
json.dump(data, response)
return response
def get(self):
url = "http://viz.se/newsviz-proxy/?"
params = [("_id", "xAk0qJNp3hGy8VaYOIGFTg"), ("_render", "json")]
result = None
count = 0
while result is None:
result = _query_webservice(url, params, "GET")
count += 1
if count == 3:
break
self.response.headers["Content-Type"] = "application/json"
simplejson.dump(result, self.response.out)
if result:
queue = taskqueue.Queue("page-worker")
for item in result["value"]["items"]:
key = item["link"]
if PageStore.get_by_key_name(key) is None:
# Only add to queue if item hasn't been analyzed already
try:
task = taskqueue.Task(
name=str(hash(item["link"])),
url="/page/?url=" + item["link"] + "&caller=queue",
method="GET",
)
queue.add(task)
except:
continue
def get(self, gamekey):
user = users.get_current_user()
s = get_live_game(gamekey)
if s is None:
self.response.headers.add_header("Content-Type",
"application/json")
self.response.set_status(404)
json.dump({"error": "game key not found."}, self.response.out)
return
tok = s.registerUser(user)
color = s.joinUser(user)
player = s.board.getPlayer(user)
player.resetResources()
player.adjustResources({"ore": 2, "wheat": 5})
player.adjustResources({"ore": -1, "wheat": -2})
if player.adjustResources({"brick": -1, "wheat": -2}, True):
logging.error(
"error, we removed brick even though there isn't any")
else:
logging.info("successful")
self.response.headers.add_header("Content-Type", "application/json")
json.dump(player, self.response.out, cls=model.BoardEncoder)
def iphone(request, s = None):
if(s == None):
raise Http404
section = ""
try:
section = Section.cached(s)
except KeyError:
raise Http404
stories = Article.objects.recent.filter(section=section)[:15]
objs = []
for story in stories:
curdict = {}
curdict['id'] = story.pk
curdict['date_and_time'] = story.issue.issue_date.strftime("%I:%M %p, %B %d, %Y").upper()
curdict['headline'] = story.headline
curdict['subhead'] = story.subheadline
curdict['byline'] = human_list(story.contributors.all())
curdict['article_text'] = story.text
curdict['photoURL'] = ""
if story.main_rel_content:
curdict['thumbnailURL'] = story.main_rel_content.display_url((69, 69, 1, 1))
curdict['photoURL'] = story.main_rel_content.display_url((280, 240, 1, 1))
curdict['photo_byline'] = human_list(story.main_rel_content.contributors.all())
objs.append(curdict)
io = StringIO()
simplejson.dump(objs, io)
return HttpResponse(io.getvalue(), mimetype='application/json')
def scrape(self, save=True, verbose=True):
counts = {
'saves': 0,
'error': 0,
}
data = []
for title in self:
try:
data = self.api.search(title)
if data:
for item in data:
if save:
movie = self.movie_with_json(item)
counts['saves'] += 1
if verbose:
print movie
else:
data.append(item)
except Exception as e:
connection._rollback() # PostgreSQL rollback mechanism
counts['error'] += 1
if verbose:
print "Exception searching for \"%s\": %s" % (title, str(e))
continue
if not save:
with open('fixtures/title_list.json', 'w') as out:
json.dump(data, out)
print "%(saves)i movies saved, %(error)i titles skipped." % counts
def ajax_rooms_cached(self, prog):
classrooms = prog.getResources().filter(res_type__name="Classroom")
classrooms_grouped = defaultdict(list)
for room in classrooms:
classrooms_grouped[room.name].append(room)
classrooms_dicts = [{
'uid':
room_id,
'text':
classrooms_grouped[room_id][0].name,
'availability': [r.event_id for r in classrooms_grouped[room_id]],
'associated_resources': [
ar.res_type.id for ar in classrooms_grouped[room_id]
[0].associated_resources()
],
'num_students':
classrooms_grouped[room_id][0].num_students,
} for room_id in classrooms_grouped.keys()]
response = HttpResponse(content_type="application/json")
simplejson.dump(classrooms_dicts, response)
return response
def wrapped_f(*args):
# Grab the request
request = args[0]
# Make sure that we're authenticated
if not request.user.is_authenticated():
return HttpResponse('Not logged in!')
# Make sure that the request looks right
if not request.is_ajax() or request.method != 'POST':
return HttpResponse('Wrong kind of request!')
# Make sure that we have the parameters we want
if not this.paramset <= request.POST:
return HttResponse(json.dump({'error': 'Wrong ajax parameters!'}))
# Make sure that the request validates
try:
validate_ajax_params(request.POST)
except ValidationError:
return HttResponse(json.dump({'error': 'Ajax parameters failed to validate!'}))
# Call through
self.f();
def _professor_info_to_output(prof_info,conv_to_json=True,lang='ko'):
if prof_info == None:
item = {
'major': '',
'email': '',
'homepage': '',
'writer': '',
'written_datetime': '',
'professor_id': -1
}
else:
item = {
'major': prof_info.major,
'email': prof_info.email,
'homepage': prof_info.homepage,
'writer': UserProfile.objects.get(user = prof_info.writer).nickname[:2] + '*'*5,
'written_datetime': prof_info.written_datetime.isoformat()[:10],
'professor_id': prof_info.professor.professor_id
}
if conv_to_json:
io = StringIO()
if settings.DEBUG:
json.dump(item,io,ensure_ascii=False,indent=4, cls=DjangoJSONEncoder)
else:
json.dump(item,io,ensure_ascii=False,sort_keys=False,separators=(',',':'), cls=DjangoJSONEncoder)
return io.getvalue()
else:
return item
def end_serialization(self):
if simplejson.__version__.split('.') >= ['2', '1', '3']:
# Use JS strings to represent Python Decimal instances (ticket #16850)
self.options.update({'use_decimal': False})
simplejson.dump(self.objects,
self.stream,
cls=DjangoJSONEncoder,
**self.options)
def ajax_lunch_timeslots_cached(self, prog):
data = list(
Event.objects.filter(
meeting_times__parent_class__category__category="Lunch",
meeting_times__parent_class__parent_program=prog).values_list(
'id', flat=True))
response = HttpResponse(content_type="application/json")
simplejson.dump(data, response)
return response
def end_serialization(self):
self.options.pop('stream', None)
self.options.pop('fields', None)
self.options.pop('use_natural_keys', None)
self.options.pop('crs', None)
self.options.pop('srid', None)
json.dump(self.feature_collection, self.stream, cls=DjangoGeoJSONEncoder, **self.options)
def sort_orders(self):
from tech_services_reports.utility_code import location_sort_order, format_sort_order
#Dump a sort key for locations.
sorted_locations = location_sort_order()
simplejson.dump(sorted_locations,
open("%s/location_sort_order.json" % settings_app.REPORT_DIR, 'w'), indent=2)
sorted_formats = format_sort_order()
simplejson.dump(sorted_formats,
open("%s/format_sort_order.json" % settings_app.REPORT_DIR, 'w'), indent=2)
def abort(request, task_id):
"""
Kill a running celery task.
"""
OcrTask.revoke_celery_task(task_id, kill=True)
out = dict(task_id=task_id, status="ABORT")
response = HttpResponse(mimetype="application/json")
json.dump(out, response, ensure_ascii=False)
return response
def get(self):
user = users.get_current_user()
if not user:
json.dump(dict(error="not signed in"), self.response.out)
return
application.sendMessageAll({'action': 'reset'})
application.gameState = GameState()
application.setupHandlers(application.gameState)
def ajax_schedule_last_changed_cached(self, prog):
# ret['val'] should be a valid nonce that's regenerated no less often than whenever the data changes
ret = { 'val': str(get_uuid()),
'msg': 'UUID that changes every time the schedule is updated' }
response = HttpResponse(content_type="application/json")
simplejson.dump(ret, response)
response.raw_value = ret # So that other functions can call this view and get the original return value back
return response
def write_input_json(self, is_update=False):
generated_input_fn = pathify(
[self.extn_dir, 'content', 'js', 'generated_input.js'],
file_extension=True)
generated_input_f = open(generated_input_fn, 'w')
generated_input_f.write("""
/**
* Generated by xpi builder on the fly when user downloads extension.
*/
function generated_input() {
return """)
data = {
"constants_PD_URL": DOMAIN,
"constants_PD_API_URL": API_DOMAIN,
"is_update": is_update
}
print "DATA: ", data
private_key = "__no_private_key_for_update__"
if not is_update:
recip_pcts = []
if self.recipient:
recip_pcts.append({
"recipient_slug": self.recipient.slug,
"percent": 1.0
})
private_key = self.generate_private_key()
data["private_key"] = private_key
data["preselected_charities"] = recip_pcts
json.dump([data], generated_input_f)
generated_input_f.write("""
}
""")
generated_input_f.close()
# now build generated_javascript.js
print "generate_javascript..."
extn_bin = pathify([self.extn_dir, "content", "bin"])
sys.path.append(extn_bin)
import safe_globals
input_file = pathify(['content', 'overlay_list.txt'],
file_extension=True)
output_file = pathify(['content', 'js', 'generated_javascript.js'],
file_extension=True)
safe_globals.concatenate(self.extn_dir, input_file, output_file)
print "...done"
return private_key
def ajax_schedule_last_changed_helper(self, prog):
ret = { 'val': str(self.ajax_schedule_get_uuid(prog)),
'msg': 'UUID that changes every time the schedule is updated',
'time' : time.time(),
'latest_index' : self.get_change_log(prog).get_latest_index() }
response = HttpResponse(content_type="application/json")
simplejson.dump(ret, response)
response.raw_value = ret # So that other functions can call this view and get the original return value back
return response
def ajax_times_cached(self, prog):
times = list( [ dict(e) for e in prog.getTimeSlots().values('id', 'short_description', 'description', 'start', 'end') ] )
for t in times:
t['start'] = t['start'].timetuple()[:6]
t['end'] = t['end'].timetuple()[:6]
response = HttpResponse(content_type="application/json")
simplejson.dump(times, response)
return response
def end_serialization(self):
"""Output a JSON encoded queryset."""
self.options.pop('stream', None)
self.options.pop('fields', None)
self.options.pop('excludes', None)
self.options.pop('relations', None)
self.options.pop('display', None)
self.options.pop('extras', None)
simplejson.dump(self.objects, self.stream, cls=DjangoJSONEncoder,
**self.options)
def get_trip_results(request, trip_id):
"""Display results for a trip.
"""
trip = get_object_or_404(Trip, pk=trip_id, user=request.user)
#get the trip search details
(offer_radius, demand_radius, interval_min, interval_max, route,
departure_point, arrival_point) = get_trip_search_details(request)
if trip.offer and (route is None or route.geom_type != 'MultiLineString'):
raise Http404
today = datetime.date.today()
if trip.demand:
trip_offers = Trip.objects.get_offers(departure_point, arrival_point, demand_radius).exclude(pk=trip.id)
trip_offers = trip_offers.get_mark_details()
if trip.regular:
trip_offers = trip_offers.filter_dows(trip.dows)
else:
trip_offers = trip_offers.filter_date_interval(trip.date, interval_min, interval_max)
trip_offers = trip_offers.exclude_outdated(today)
# exclude my trips ?
if settings.EXCLUDE_MY_TRIPS:
trip_offers = trip_offers.exclude(user=request.user)
# ordering and limit
trip_offers = trip_offers.order_by('-pourcentage_rank')[:_MAX_TRIP]
trip_offers = sort_offers(trip_offers, trip.date, interval_min, interval_max, trip=trip)
if trip.offer:
trip_demands = Trip.objects.get_demands(route, get_direction_route(route), offer_radius).exclude(pk=trip.id)
trip_demands = trip_demands.get_mark_details()
if trip.regular:
trip_demands = trip_demands.filter_dows(trip.dows)
else:
trip_demands = trip_demands.filter_date_interval(trip.date, interval_min, interval_max)
trip_demands = trip_demands.exclude_outdated(today)
# exclude my trips ?
if settings.EXCLUDE_MY_TRIPS:
trip_demands = trip_demands.exclude(user=request.user)
# ordering and limit
trip_demands = trip_demands.order_by('-pourcentage_rank')[:_MAX_TRIP]
trip_demands = sort_demands(trip_demands, trip.date, interval_min, interval_max, trip=trip)
response_dict = {
'authenticated': request.user.is_authenticated(),
'trip_offers': [get_trip_dict(t) for t in trip_offers] if trip.demand else None,
'trip_demands': [get_trip_dict(t) for t in trip_demands] if trip.offer else None,
}
resp = HttpResponse()
simplejson.dump(response_dict , resp, ensure_ascii=False, separators=(',',':'))
return resp
def export(self, out=None):
if out is None:
out = "forum-export-%d.json" % self.id
data = {
"self": {
"id": self.id,
"title": self.title,
"description": self.description,
"parent": self.parent_id,
"category": self.category_id,
"last_modified":
self.last_modified.strftime("%Y-%m-%d %H:%M:%S"),
"last_thread": self.last_thread_id,
"view_count": self.view_count,
"post_count": self.post_count
},
"threads": [{
"id":
t.id,
"author":
t.author_id,
"content":
t.content,
"created":
t.created.strftime("%Y-%m-%d %H:%M:%S"),
"forum":
t.forum_id,
"title":
t.title,
"last_modified":
t.last_modified.strftime("%Y-%m-%d %H:%M:%S"),
"last_reply":
t.last_reply_id,
"view_count":
t.view_count,
"reply_count":
t.reply_count,
"subscriber_count":
t.subscriber_count,
"replies": [{
"id": r.id,
"author": r.author_id,
"content": r.content,
"created": r.created.strftime("%Y-%m-%d %H:%M:%S"),
"thread": r.thread_id,
} for r in t.replies.all()],
"subscriptions": [{
"id": s.id,
"thread": s.thread_id,
"user": s.user_id,
"kind": s.kind,
} for s in t.subscriptions.all()]
} for t in self.threads.all()]
}
json.dump(data, open(out, "wb"))
def render_json(self, result):
self.response.headers[
'Content-Type'] = 'text/javascript; charset=utf-8'
callback = re.sub("[^\w\d]", "", self.request.get('callback'))
if callback:
self.response.out.write(callback + "(")
simplejson.dump(result, self.response.out, ensure_ascii=False)
if callback:
self.response.out.write(");")
def result(request, task_id):
"""
Fetch the result for one Celery task id.
"""
async = OcrTask.get_celery_result(task_id)
out = dict(task_id=async .task_id,
status=async .status,
results=async .result)
response = HttpResponse(mimetype="application/json")
json.dump(out, response, ensure_ascii=False)
return response
def send_json(response_obj, jdata):
""" Send data in JSON form to an HTTP-response object.
Args:
response_obj: an HTTP response object
jdata: a dict or list in correct 'JSONable' form
Side effects:
sends the JSON form of jdata on response.out
"""
response_obj.content_type = 'application/json'
simplejson.dump(jdata, response_obj.out)
def switch_alert(request, trip_id):
"""Switch alert notifications
"""
trip = get_object_or_404(Trip, pk=trip_id, user=request.user)
trip.alert = not trip.alert
trip.save(update_modification_date=False)
response_dict = {'status': 'ok', 'alert': trip.alert}
resp = HttpResponse()
simplejson.dump(response_dict , resp, ensure_ascii=False, separators=(',',':'))
return resp
def render_json(request, addon, stats):
"""Render a stats series in JSON."""
response = http.HttpResponse(mimetype='text/json')
# XXX: Subclass DjangoJSONEncoder to handle generators.
if isinstance(stats, GeneratorType):
stats = list(stats)
# Django's encoder supports date and datetime.
fudge_headers(response, stats)
simplejson.dump(stats, response, cls=DjangoJSONEncoder)
return response
def handle(self, *args, **options):
"""
Create urls.js file by parsing all of the urlpatterns in the root urls.py file
"""
js_patterns = SortedDict()
print "Generating Javascript urls file %s" % app_settings.URLS_JS_GENERATED_FILE
Command.handle_url_module(js_patterns, project_settings.ROOT_URLCONF)
#output to the file
urls_file = open(app_settings.URLS_JS_GENERATED_FILE, "w")
urls_file.write("dutils.conf.urls = ")
simplejson.dump(js_patterns, urls_file)
print "Done generating Javascript urls file %s" % app_settings.URLS_JS_GENERATED_FILE
