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 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