def edit_text(request, ref=None, lang=None, version=None, new_name=None): """ Opens a view directly to adding, editing or translating a given text. """ if ref is not None: version = version.replace("_", " ") if version else None text = get_text(ref, lang=lang, version=version) text["mode"] = request.path.split("/")[1] initJSON = json.dumps(text) else: new_name = new_name.replace("_", " ") if new_name else new_name initJSON = json.dumps({"mode": "add new", "title": new_name}) titles = json.dumps(get_text_titles()) page_title = "%s %s" % (text["mode"].capitalize(), ref) if ref else "Add a New Text" email = request.user.email if request.user.is_authenticated() else "" return render_to_response('reader.html', {'titles': titles, 'initJSON': initJSON, 'page_title': page_title, 'toc': get_toc(), 'titlesJSON': json.dumps(get_text_titles()), 'email': email}, RequestContext(request))
def map_wms(request, mapid): """ Publish local map layers as group layer in local OWS. /maps/:id/wms GET: return endpoint information for group layer, PUT: update existing or create new group layer. """ map_obj = _resolve_map(request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) if request.method == 'PUT': try: layerGroupName = map_obj.publish_layer_group() response = dict( layerGroupName=layerGroupName, ows=getattr(ogc_server_settings, 'ows', ''), ) return HttpResponse( json.dumps(response), mimetype="application/json") except: return HttpResponseServerError() if request.method == 'GET': response = dict( layerGroupName=getattr(map_obj.layer_group, 'name', ''), ows=getattr(ogc_server_settings, 'ows', ''), ) return HttpResponse(json.dumps(response), mimetype="application/json") return HttpResponseNotAllowed(['PUT', 'GET'])
def map_json(request, mapid, snapshot = None): if request.method == 'GET': if not mapid.isdigit(): map_obj = _resolve_map_custom(request, mapid, 'urlsuffix', 'base.view_resourcebase', _PERMISSION_MSG_VIEW) else: map_obj = _resolve_map(request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) return HttpResponse(json.dumps(map_obj.viewer_json(request.user))) elif request.method == 'PUT': if not request.user.is_authenticated(): return HttpResponse( _PERMISSION_MSG_LOGIN, status=401, mimetype="text/plain" ) if not mapid.isdigit(): map_obj = _resolve_map_custom(request, mapid, 'urlsuffix', 'base.change_resourcebase') else: map_obj = _resolve_map(request, mapid, 'base.change_resourcebase') try: map_obj.update_from_viewer(request.body) MapSnapshot.objects.create(config=clean_config(request.body),map=map_obj,user=request.user) return HttpResponse(json.dumps(map_obj.viewer_json(request.user))) except ValueError, e: return HttpResponse( "The server could not understand the request." + str(e), mimetype="text/plain", status=400 )
def postear(request, formulario, evento_id): evento=get_object_or_404(Eventos, pk=evento_id) form = FormTexto(formulario, usuario=request.user, evento=evento) if form.is_valid(): form.save() return simplejson.dumps({'status':False, 'evento_id':evento_id}) return simplejson.dumps({'status': 'Error al enviar'})
def map_json(request, mapid, snapshot=None): if request.method == 'GET': map_obj = _resolve_map(request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) return HttpResponse(json.dumps(map_obj.viewer_json(request.user))) elif request.method == 'PUT': if not request.user.is_authenticated(): return HttpResponse( _PERMISSION_MSG_LOGIN, status=401, mimetype="text/plain" ) map_obj = Map.objects.get(id=mapid) if not request.user.has_perm('change_resourcebase', map_obj.get_self_resource()): return HttpResponse( _PERMISSION_MSG_SAVE, status=401, mimetype="text/plain" ) try: map_obj.update_from_viewer(request.body) MapSnapshot.objects.create( config=clean_config( request.body), map=map_obj, user=request.user) return HttpResponse(json.dumps(map_obj.viewer_json(request.user))) except ValueError as e: return HttpResponse( "The server could not understand the request." + str(e), mimetype="text/plain", status=400 )
def multipath_status_json(request): multipaths = notifier().multipath_all() _id = 1 items = [] for mp in multipaths: children = [] for cn in mp.consumers: actions = {} items.append({ 'id': str(_id), 'name': cn.devname, 'status': cn.status, 'type': 'consumer', 'actions': simplejson.dumps(actions), }) children.append({'_reference': str(_id)}) _id += 1 data = { 'id': str(_id), 'name': mp.devname, 'status': mp.status, 'type': 'root', 'children': children, } items.append(data) _id += 1 return HttpResponse(simplejson.dumps({ 'identifier': 'id', 'label': 'name', 'items': items, }, indent=2), content_type='application/json')
def render(self, name, value, attrs=None): if value is None: value = '' value = smart_unicode(value) final_attrs = self.build_attrs(attrs) final_attrs['name'] = name assert 'id' in final_attrs, "TinyMCE widget attributes must contain 'id'" mce_config = tinymce_settings.DEFAULT_CONFIG.copy() mce_config.update(get_language_config(self.content_language)) if tinymce_settings.USE_FILEBROWSER: mce_config['file_browser_callback'] = "djangoFileBrowser" mce_config.update(self.mce_attrs) mce_config['mode'] = 'exact' mce_config['elements'] = final_attrs['id'] mce_config['strict_loading_mode'] = 1 mce_json = simplejson.dumps(mce_config) html = [u'<textarea%s>%s</textarea>' % (flatatt(final_attrs), escape(value))] if tinymce_settings.USE_COMPRESSOR: compressor_config = { 'plugins': mce_config.get('plugins', ''), 'themes': mce_config.get('theme', 'advanced'), 'languages': mce_config.get('language', ''), 'diskcache': True, 'debug': False, } compressor_json = simplejson.dumps(compressor_config) html.append(u'<script type="text/javascript">tinyMCE_GZ.init(%s)</script>' % compressor_json) html.append(u'<script type="text/javascript">tinyMCE.init(%s)</script>' % mce_json) return mark_safe(u'\n'.join(html))
def post(request): """ Parameters: a: Action t: Type p: Parameters d: Data(Optional) Response: rc: Return code msg: message """ # initial the responsor request returnobj = default_returnobj.copy() form = RequestForm(request.POST, request.FILES) # Error handler if not form.is_valid(): returnobj['rc'] = 1 returnobj['msg'] = form.errors return HttpResponse(simplejson.dumps(returnobj)) p = form.cleaned_data['p'] # Get the uploaded file contents if form.cleaned_data.get('d'): # If the file is loaded with generic POST method d = form.cleaned_data['d'] mime_type = d.content_type file_name = p.get('file_name', 'untitiled.' + mime_type.split('/')[1]) else: returnobj['rc'] = 1 returnobj['msg'] = 'File(Parameter "d") is necessary by uploading' return HttpResponse(simplejson.dumps(returnobj)) # Get the phone info phone = None pi = p.get('phone_info') if pi: phone, create = PhoneInfo.objects.get_or_create(device_id = pi['device_id']) phone.model = pi.get('model') phone.android_version = pi.get('android_version') phone.phone_number = pi.get('phone_number') phone.save() # Save the data desc = p.get('desc') latitude, longitude = p.get('latitude'), p.get('longitude') data = Data.objects.create( phone = phone, file_name = file_name, mime_type = mime_type, desc = desc, ip_address = request.META['REMOTE_ADDR'], latitude = latitude, longitude = longitude, ) data.data.save(file_name, request.FILES['d']) data.save() data.generate_thumbnails() return HttpResponse(simplejson.dumps(returnobj))
def layer_from_viewer_config(model, layer, source, ordering): """ Parse an object out of a parsed layer configuration from a GXP viewer. ``model`` is the type to instantiate ``layer`` is the parsed dict for the layer ``source`` is the parsed dict for the layer's source ``ordering`` is the index of the layer within the map's layer list """ layer_cfg = dict(layer) for k in ["format", "name", "opacity", "styles", "transparent", "fixed", "group", "visibility", "source", "getFeatureInfo"]: if k in layer_cfg: del layer_cfg[k] source_cfg = dict(source) for k in ["url", "projection"]: if k in source_cfg: del source_cfg[k] return model( stack_order = ordering, format = layer.get("format", None), name = layer.get("name", None), opacity = layer.get("opacity", 1), styles = layer.get("styles", None), transparent = layer.get("transparent", False), fixed = layer.get("fixed", False), group = layer.get('group', None), visibility = layer.get("visibility", True), ows_url = source.get("url", None), layer_params = json.dumps(layer_cfg), source_params = json.dumps(source_cfg) )
def tipos_usuarios_view(request): if request.method=="POST": if "product_id" in request.POST: try: l = None id_product = request.POST['product_id'] p = Tipo_Usuario.objects.get(pk=id_product) try: l = Usuario.objects.get(tipo_usuario__id = id_product) except: l = None if l == None: p.delete() #p.delete() mensaje={"status":"True","product_id":id_product} return HttpResponse(simplejson.dumps(mensaje),mimetype='application/json') except: mensaje={"status":"False"} return HttpResponse(simplejson.dumps(mensaje),mimetype='application/json') tipo = Tipo_Usuario.objects.all() ctx = {'tipos_usuarios' :tipo} return render_to_response ('home/tipo_usuario.html', ctx, context_instance = RequestContext(request))
def usuarios_view(request): if request.method=="POST": if "product_id" in request.POST: try: l = None id_usuario = request.POST['product_id'] p = Usuario.objects.get(pk=id_usuario) u = User.objects.get (pk = p.user.id) try: l = Prestamo.objects.get(usuario__id = id_usuario, usuario__user__id = u.id) except: l = None if l == None: u.delete() #p.delete() mensaje={"status":"True","product_id":p.id} return HttpResponse(simplejson.dumps(mensaje),mimetype='application/json') except: mensaje={"status":"False"} return HttpResponse(simplejson.dumps(mensaje),mimetype='application/json') p = Usuario.objects.all() ctx = {'usuarios':p} return render_to_response ('home/usuarios.html', ctx, context_instance = RequestContext(request))
def list_playlists(request): if request.method == 'GET': pl_list = Playlist.objects.all().order_by('name') return render_to_response('templates/playlist-byname.t', {'pl_list': pl_list}) logger.log_debug("list_playlists: POST=%s" % request.POST) json='' if request.POST['action'] == 'list': playlists = [] for pl in Playlist.objects.all().order_by('name'): playlists.append({'id': pl.id, 'title': pl.name, 'len': len(pl)}) json = simplejson.dumps({'status': 200, 'playlists': playlists}) elif request.POST['action'] == 'create': playlist = Playlist(name=request.POST['title']) playlist.save() json = simplejson.dumps({'status': 200, 'title': playlist.name, 'id': playlist.id, 'len': len(playlist)}) elif request.POST['action'] == 'rename': playlist = Playlist.objects.get(id=request.POST['id']) playlist.name = request.POST['title'] playlist.save() json = simplejson.dumps({'status': 200, 'id': request.POST['id']}) elif request.POST['action'] == 'delete': playlist = Playlist.objects.get(id=request.POST['id']) playlist.delete() json = simplejson.dumps({'status': 200}) return HttpResponse(json, mimetype="application/json")
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 livesearch(request, template_name="lfs/search/livesearch_results.html"): """ """ phrase = request.GET.get("phrase", "") if phrase == "": result = simplejson.dumps({ "state" : "failure", }) else: # Products query = Q(active=True) & \ Q(name__icontains=phrase) & \ Q(sub_type__in = (STANDARD_PRODUCT, PRODUCT_WITH_VARIANTS)) temp = Product.objects.filter(query) total = len(temp) products = temp[0:5] products = render_to_string(template_name, RequestContext(request, { "products" : products, "phrase" : phrase, "total" : total, })) result = simplejson.dumps({ "state" : "success", "products" : products, }) return HttpResponse(result)
def nextPage(request): picsOnRequiredPage=[] if request.is_ajax() and request.method=='GET': albumIDValue=int(request.GET.get('albumID')) pageNumValue=request.GET.get('pageNum') picsOfAlbum=Picture.objects.filter(albumID=albumIDValue) #check if there are pictures on the page with page number 'pageNumValue' isMorePic='false' for pic in picsOfAlbum: if pic.pagesID==pageNumValue: isMorePic='true' #no more pictures if isMorePic=='false': data={'lastPage':'true'} json1=simplejson.dumps(data) return HttpResponse(json1, mimetype='application/json') #record layout id, name and description information about each picture for pic in picsOfAlbum: if pic.pagesID == pageNumValue: singlePic={} singlePic['layoutID']=pic.layoutID singlePic['img_holder']=pic.img_holder singlePic['layoutNameID']=pic.layoutNameID singlePic['layoutDescrID']=pic.layourDescrID singlePic['picUrl']=pic.picUrl singlePic['pictName']=pic.pictName singlePic['pictDescription']=pic.pictDescription picsOnRequiredPage.append(singlePic) data={'pics':picsOnRequiredPage,'lastPage':'false'} json=simplejson.dumps(data) return HttpResponse(json, mimetype='application/json')
def new_location(request, provider_id): provider = get_object_or_404(Provider, id=provider_id) admin_user = provider.admin if request.user == admin_user: # only the provider's registered user if request.method == "POST": location_form = LocationForm(request.POST) if location_form.is_valid(): location = location_form.save(commit=False) location.provider = provider location.save() data = { 'location_id': location.id, } return HttpResponse(simplejson.dumps(data), content_type="application/json") else: errors_dict = {} if location_form.errors: for error in location_form.errors: e = location_form.errors[error] errors_dict[error] = unicode(e) return HttpResponseBadRequest(simplejson.dumps(errors_dict)) else: template = 'location/new.html' data = { 'location_form': LocationForm(), 'provider_id': provider.id, } return render(request, template, data) else: return HttpResponseRedirect(reverse('provider_detail', kwargs={'provider_id': provider.id}))
def loginajax(request): """ Displays the login form and handles the login action. """ redirect_to = request.REQUEST.get(REDIRECT_FIELD_NAME, "") if request.method == "POST": form = AuthenticationForm(data=request.POST) if form.is_valid(): netloc = urlparse.urlparse(redirect_to)[1] # Use default setting if redirect_to is empty if not redirect_to: redirect_to = settings.LOGIN_REDIRECT_URL # Heavier security check -- don't allow redirection to a different # host. elif netloc and netloc != request.get_host(): redirect_to = settings.LOGIN_REDIRECT_URL # Okay, security checks complete. Log the user in. auth_login(request, form.get_user()) if request.session.test_cookie_worked(): request.session.delete_test_cookie() login_output = {"status": True, "redirect_to": redirect_to} return HttpResponse(simplejson.dumps(login_output)) else: login_output = {"status": False, "error": "Could not find matching user."} return HttpResponse(simplejson.dumps(login_output)) else: # return HttpResponse("not ajax") form = AuthenticationForm(request, label_suffix="") return render_to_response("accounts/login.html", {"form": form}, context_instance=RequestContext(request))
def test_queryjobrequest(request, jobid): """Render the test_transformrequest page""" if jobid: resp = { "queryJobRequest" : { "queryJobInfo" : { "jobInfo" : { "jobID" : { "jobGUID" : "CDDA518D-4A42-45d0-A866-9C340AA98C11", "serviceProviderJobID" : "121e23e9-2168-46f1-a891-7f6bb8bdbddb" }, "operationName" : "transformrequest", "priority" : "immediate", "status" : { "code" : "running", "description" : "In Progress" } } } } } return HttpResponse( simplejson.dumps(resp), mimetype="application/json") else: resp = { "active transfers" : 1, "transfer_id_1" : "CDDA518D-4A42-45d0-A866-9C340AA98C11" } return HttpResponse( simplejson.dumps(resp), mimetype="application/json")
def ajax_add_short_comments_post(request): if "post_id" in request.POST and "short_comment_id" in request.POST: try: try: post_id = int(request.POST["post_id"]) except ValueError: post_id = 0 post = Post.objects.get(id=post_id) try: try: short_comment_id = int(request.POST["short_comment_id"]) except ValueError: short_comment_id = 0 short_comment = ShortComment.objects.get(id=short_comment_id) try: post_short_comments = PostShortComments.objects.get(short_comment=short_comment, post=post) post_short_comments.count = post_short_comments.count + 1 except PostShortComments.DoesNotExist: post_short_comments = PostShortComments(count=1, post=post, short_comment=short_comment) post_short_comments.save() return HttpResponse( simplejson.dumps({"success": True, "short_comment_count": post_short_comments.count}), content_type="application/json", ) except ShortComment.DoesNotExist: pass except Post.DoesNotExist: pass return HttpResponse(simplejson.dumps({"success": False}), content_type="application/json")
def submit_cargo_form(request): cargo_id = request.POST.get('cargo_id', False) if not cargo_id: error_msg = 'Error posting cargo form' return HttpResponseBadRequest(json.dumps(error_msg), mimetype="application/json") cargo = get_object_or_404(Cargo, id=cargo_id) categories = ('food', 'medicaments', 'duty_free', 'electronics', 'baggage', 'books', 'documents', 'personal_belongings', 'clothes', 'others') cats = [request.POST.get(cat, False) for cat in categories] active_cats = filter(None, cats) if not active_cats: error_msg = 'At least one category must be selected' return HttpResponseBadRequest(json.dumps(error_msg), mimetype="application/json") form = CargoForm(request.POST, instance=cargo) if not form.is_valid(): error_msg = 'Error posting cargo form' return HttpResponseBadRequest(json.dumps(error_msg), mimetype="application/json") obj = form.save() obj.state = 1 # Cargo form pending to be confirmed or rejected # Send notification to requesting user obj.cargoformnotification_set.create(user=obj.requesting_user) obj.save() msg = _('I am attaching form for you to review. By accepting it you will be confirming your cargo.') obj.cargocomment_set.create(user=request.user, content=msg, comment_type=1) response = '/my/trips/' messages.success(request, _("You have successfully posted a cargo form to the requesting user")) return HttpResponse(json.dumps(response), mimetype="application/json")
def view_create_group(request): try: error = {'nombre': [], 'descripcion': []} if request.method == "POST": if request.POST.get('nombre') and request.POST.get('descripcion'): nombre = request.POST.get('nombre') descripcion = request.POST.get('descripcion') if not Group.objects.filter(creador=request.user.get_profile(), name=nombre): Group.objects.create(name=nombre, information=descripcion, creador=request.user.get_profile()) return HttpResponse(simplejson.dumps({'estado': 1}), mimetype='application/json') else: error['nombre'].append('Ya existe un grupo con ese nombre') elif request.POST.get('nombre') and not request.POST.get('descripcion'): nombre = request.POST.get('nombre') if Group.objects.filter(creador=request.user.get_profile(), name=nombre): error['nombre'].append('Ya existe un grupo con ese nombre') error['descripcion'].append('Debe ingresar una descripcion') elif request.POST.get('descripcion') and not request.POST.get('nombre'): error['nombre'].append('Debe ingresar un nombre') elif not request.POST.get('descripcion') and not request.POST.get('nombre'): error['descripcion'].append('Debe ingresar una descripcion') error['nombre'].append('Debe ingresar un nombre') return HttpResponse(simplejson.dumps({'estado': 0, 'error': error}), mimetype='application/json') else: return render_to_response("desktop/create-group.html", context_instance=RequestContext(request)) except Exception, ex: print ex return HttpResponse(simplejson.dumps({'estado': 0, 'error': 'No se pudo crear el grupo'}), mimetype='application/json')
def remove_module(request, revision_id): """ Remove module from PackageRevision """ revision = get_object_with_related_or_404(PackageRevision, pk=revision_id) if request.user.pk != revision.author.pk: log_msg = ("[security] Attempt to remove a module from package (%s) " "by non-owner (%s)" % (revision_id, request.user)) log.warning(log_msg) return HttpResponseForbidden('You are not the author of this Package') filenames = request.POST.get('filename').split(',') revision.add_commit_message('module removed') try: removed_modules, removed_dirs = revision.modules_remove_by_path( filenames) except Module.DoesNotExist: log_msg = 'Attempt to delete a non existing module(s) %s from %s.' % ( str(filenames), revision_id) log.warning(log_msg) return HttpResponseForbidden( 'There is no such module in %s' % escape( revision.package.full_name)) return render_json(request, "json/module_removed.json", {'revision': revision, 'removed_modules': simplejson.dumps(removed_modules), 'removed_dirs': simplejson.dumps(removed_dirs)})
def view_sheet(request, sheet_id): sheet = get_sheet(sheet_id) if "error" in sheet: return HttpResponse(sheet["error"]) # Count this as a view db.sheets.update({"id": int(sheet_id)}, {"$inc": {"views": 1}}) try: owner = User.objects.get(id=sheet["owner"]) author = owner.first_name + " " + owner.last_name owner_groups = [g.name for g in owner.groups.all()] if sheet["owner"] == request.user.id else None except User.DoesNotExist: author = "Someone Mysterious" owner_groups = None can_edit_flag = can_edit(request.user, sheet) sheet_group = sheet["group"] if sheet["status"] in GROUP_SHEETS else None viewer_groups = get_viewer_groups(request.user) return render_to_response('sheets.html', {"sheetJSON": json.dumps(sheet), "sheet": sheet, "can_edit": can_edit_flag, "title": sheet["title"], "author": author, "owner_groups": owner_groups, "sheet_group": sheet_group, "viewer_groups": viewer_groups, "current_url": request.get_full_path, "toc": get_toc(), "titlesJSON": json.dumps(get_text_titles()), }, RequestContext(request))
def login(request, template="accounts/account_login.html"): """ Login form. """ isAjax = False form = LoginForm(request.POST or None) next = get_login_redirect_url(request) if request.method == "POST" and form.is_valid(): authenticated_user = form.save() #info(request, _("Successfully logged in")) auth_login(request, authenticated_user) if request.is_ajax(): if request.user.is_authenticated(): return HttpResponse(simplejson.dumps(dict(url=next, success=True))) else: return HttpResponse(simplejson.dumps(dict(success=False))) else: return login_redirect(request) elif form.errors: return HttpResponse(simplejson.dumps(dict(errors=form.errors, success=False))) if request.is_ajax(): template = "accounts/ajax_account_login.html" context = {"form": form, "title": _("Log in"), "next":next} return render(request, template, context)
def api_graph_layer_2(request, map_id=None): """ Layer2 network topology representation in d3js force-direct graph layout http://mbostock.github.com/d3/ex/force.html """ load_traffic = 'traffic' in request.GET if map_id: view = get_object_or_404(NetmapView, pk=map_id) session_user = get_account(request) if view.is_public or (session_user == view.owner): json = _json_layer2(load_traffic, view) response = HttpResponse(simplejson.dumps(json)) response['Content-Type'] = 'application/json; charset=utf-8' response['Cache-Control'] = 'no-cache' response['Pragma'] = 'no-cache' response['Expires'] = "Thu, 01 Jan 1970 00:00:00 GMT" response['x-nav-viewid'] = map_id return response else: return HttpResponseForbidden() json = _json_layer2(load_traffic) response = HttpResponse(simplejson.dumps(json)) response['Content-Type'] = 'application/json; charset=utf-8' response['Cache-Control'] = 'no-cache' response['Pragma'] = 'no-cache' response['Expires'] = "Thu, 01 Jan 1970 00:00:00 GMT" return response
def ajax_main_search(request): if xapian is None: result =[] return HttpResponse(simplejson.dumps(result, mimetype="text/javascript")) if request.is_ajax(): if request.POST: # try: search = request.POST['q'] if " " in search: search = search.replace(" ", " OR ") if "." in search: search = search.replace(".", ' AND ') flags= xapian.QueryParser.FLAG_PARTIAL|xapian.QueryParser.FLAG_WILDCARD \ |xapian.QueryParser.FLAG_BOOLEAN |xapian.QueryParser.FLAG_PHRASE indexers = [Article.indexer] comp = CompositeIndexer(*indexers) res = comp.search(search).flags(flags) rlist = [dict(name=x.instance.__unicode__(), ct_id=x.instance.get_ctype_id(), ct=x.instance.get_ct_proxy(), obj_id=x.instance.pk, image=x.instance.get_search_url(), url=x.instance.get_absolute_url() or None) for x in res] return HttpResponse(simplejson.dumps(rlist), mimetype='text/javascript') #except: # return HttpResponseBadRequest() else: return HttpResponse(simplejson.dumps({'error':True}, mimetype="text/javascript")) else: # can probably change to redirect to a search # page view as well return HttpResponseBadRequest()
def test_invalid_data(self): resp = self.client.post(self.keys_url, json.dumps({'content':"""key 2 content"""}), content_type='application/json') self.assertEqual(resp.status_code, 500) self.assertEqual(resp.content, """{"non_field_key": "__all__", "errors": """ """{"name": ["This field cannot be blank."]}}""") settings.USERDATA_MAX_SSH_KEYS_PER_USER = 2 # test ssh limit resp = self.client.post(self.keys_url, json.dumps({'name':'key1', 'content':"""key 1 content"""}), content_type='application/json') resp = self.client.post(self.keys_url, json.dumps({'name':'key1', 'content':"""key 1 content"""}), content_type='application/json') resp = self.client.post(self.keys_url, json.dumps({'name':'key1', 'content':"""key 1 content"""}), content_type='application/json') self.assertEqual(resp.status_code, 500) self.assertEqual(resp.content, """{"non_field_key": "__all__", "errors": """ """{"__all__": ["SSH keys limit exceeded."]}}""")
def js_response(request): message = '' # если запрос аякс if request.is_ajax(): if request.method == 'GET': message = 'Only POST allowed here!' # и если метод пост elif request.method == 'POST' and request.POST.has_key('value'): try: value = int(request.POST.get('value')) gallery = Gallery.objects.get(id=value); images = Image.objects.filter(gallery=gallery) dump = list() for image in images: dic = dict() dic['pk'] = str(image.pk) dic['admin_thumbnail_view'] = image.admin_thumbnail_view() dump.append(dic) dump = simplejson.dumps(dump) callback = request.GET.get('callback', '') req = dict() req['dump'] = str(dump) response = simplejson.dumps(req) return HttpResponse(response, mimetype="application/json") except Gallery.DoesNotExist, ValueError: return HttpResponse('error')
def comentar(request, formulario, actualizacion_id): actualizacion=get_object_or_404(Actualizaciones_Eventos, pk=actualizacion_id) form = FormComentario(formulario, usuario=request.user, actualizacion=actualizacion) if form.is_valid(): form.save() return simplejson.dumps({'status':False, 'evento_id':actualizacion.evento.id}) return simplejson.dumps({'status': 'Error al enviar'})
def submit_new_comment(request, fk_name='cargo', model=Cargo, comment_model=CargoComment): """Adds a new comment to an existing object""" if request.is_ajax(): # Validate all POST params are there and are valid comment_txt = request.POST.get('content', False) object_id = request.POST.get('object_id', False) if not comment_txt or not object_id: error_msg = 'Error posting comment' return HttpResponseBadRequest(json.dumps(error_msg), mimetype="application/json") # Get object try: obj = model.objects.get(id=object_id) except model.DoesNotExist: error_msg = 'Error posting comment' return HttpResponseBadRequest(json.dumps(error_msg), mimetype="application/json") # Create new comment fields = { 'user': request.user, 'content': comment_txt, } fields[fk_name] = obj comment = comment_model.objects.create(**fields) # JSON Response html = render_to_string('comment.html', {'comment': comment}) response = {'html': html} return HttpResponse(json.dumps(response), mimetype="application/json")
def get_node_personality(request): isCloud = isCloudBuild() response_data = {'cloud': isCloud, 'controller-node': not isCloud} response_data = simplejson.dumps(response_data) return HttpResponse(response_data, JSON_DATA_TYPE)
def layer_detail(request, layername, template='layers/layer_detail.html'): layer = _resolve_layer(request, layername, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) # assert False, str(layer_bbox) config = layer.attribute_config() # Add required parameters for GXP lazy-loading layer_bbox = layer.bbox bbox = [float(coord) for coord in list(layer_bbox[0:4])] config["srs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913') config["bbox"] = bbox if config["srs"] != 'EPSG:900913' \ else llbbox_to_mercator([float(coord) for coord in bbox]) config["title"] = layer.title config["queryable"] = True if layer.storeType == "remoteStore": service = layer.service source_params = { "ptype": service.ptype, "remote": True, "url": service.base_url, "name": service.name } maplayer = GXPLayer(name=layer.typename, ows_url=layer.ows_url, layer_params=json.dumps(config), source_params=json.dumps(source_params)) else: maplayer = GXPLayer(name=layer.typename, ows_url=layer.ows_url, layer_params=json.dumps(config)) # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != layer.owner and not request.user.is_superuser: Layer.objects.filter(id=layer.id).update( popular_count=F('popular_count') + 1) # center/zoom don't matter; the viewer will center on the layer bounds map_obj = GXPMap( projection=getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')) NON_WMS_BASE_LAYERS = [ la for la in default_map_config()[1] if la.ows_url is None ] metadata = layer.link_set.metadata().filter( name__in=settings.DOWNLOAD_FORMATS_METADATA) context_dict = { "resource": layer, 'perms_list': get_perms(request.user, layer.get_self_resource()), "permissions_json": _perms_info_json(layer), "documents": get_related_documents(layer), "metadata": metadata, "is_layer": True, "wps_enabled": settings.OGC_SERVER['default']['WPS_ENABLED'], } context_dict["viewer"] = json.dumps( map_obj.viewer_json(request.user, *(NON_WMS_BASE_LAYERS + [maplayer]))) context_dict["preview"] = getattr(settings, 'LAYER_PREVIEW_LIBRARY', 'leaflet') if request.user.has_perm('download_resourcebase', layer.get_self_resource()): if layer.storeType == 'dataStore': links = layer.link_set.download().filter( name__in=settings.DOWNLOAD_FORMATS_VECTOR) else: links = layer.link_set.download().filter( name__in=settings.DOWNLOAD_FORMATS_RASTER) context_dict["links"] = links if settings.SOCIAL_ORIGINS: context_dict["social_links"] = build_social_links(request, layer) return render_to_response(template, RequestContext(request, context_dict))
def layer_upload(request, template='upload/layer_upload.html'): if request.method == 'GET': ctx = { 'charsets': CHARSETS, 'is_layer': True, } return render_to_response(template, RequestContext(request, ctx)) elif request.method == 'POST': form = NewLayerUploadForm(request.POST, request.FILES) tempdir = None errormsgs = [] out = {'success': False} if form.is_valid(): title = form.cleaned_data["layer_title"] # Replace dots in filename - GeoServer REST API upload bug # and avoid any other invalid characters. # Use the title if possible, otherwise default to the filename if title is not None and len(title) > 0: name_base = title else: name_base, __ = os.path.splitext( form.cleaned_data["base_file"].name) name = slugify(name_base.replace(".", "_")) try: # Moved this inside the try/except block because it can raise # exceptions when unicode characters are present. # This should be followed up in upstream Django. tempdir, base_file = form.write_files() saved_layer = file_upload( base_file, name=name, user=request.user, overwrite=False, charset=form.cleaned_data["charset"], abstract=form.cleaned_data["abstract"], title=form.cleaned_data["layer_title"], metadata_uploaded_preserve=form. cleaned_data["metadata_uploaded_preserve"]) except Exception as e: exception_type, error, tb = sys.exc_info() logger.exception(e) out['success'] = False out['errors'] = str(error) # Assign the error message to the latest UploadSession from that user. latest_uploads = UploadSession.objects.filter( user=request.user).order_by('-date') if latest_uploads.count() > 0: upload_session = latest_uploads[0] upload_session.error = str(error) upload_session.traceback = traceback.format_exc(tb) upload_session.context = log_snippet(CONTEXT_LOG_FILE) upload_session.save() out['traceback'] = upload_session.traceback out['context'] = upload_session.context out['upload_session'] = upload_session.id else: out['success'] = True if hasattr(saved_layer, 'info'): out['info'] = saved_layer.info out['url'] = reverse('layer_detail', args=[saved_layer.service_typename]) upload_session = saved_layer.upload_session upload_session.processed = True upload_session.save() permissions = form.cleaned_data["permissions"] if permissions is not None and len(permissions.keys()) > 0: saved_layer.set_permissions(permissions) finally: if tempdir is not None: shutil.rmtree(tempdir) else: for e in form.errors.values(): errormsgs.extend([escape(v) for v in e]) out['errors'] = form.errors out['errormsgs'] = errormsgs if out['success']: status_code = 200 else: status_code = 400 return HttpResponse(json.dumps(out), content_type='application/json', status=status_code)
def jsonify(object): if isinstance(object, QuerySet): return mark_safe(serialize('json', object)) return mark_safe(simplejson.dumps(object))
def manage_inbox(request): """delete, mark as new or seen user's response memo objects, excluding flags request data is memo_list - list of integer id's of the ActivityAuditStatus items and action_type - string - one of delete|mark_new|mark_seen """ response_data = dict() try: if request.is_ajax(): if request.method == 'POST': post_data = simplejson.loads(request.raw_post_data) if request.user.is_authenticated(): activity_types = const.RESPONSE_ACTIVITY_TYPES_FOR_DISPLAY activity_types += (const.TYPE_ACTIVITY_MENTION, const.TYPE_ACTIVITY_MARK_OFFENSIVE, const.TYPE_ACTIVITY_MODERATED_NEW_POST, const.TYPE_ACTIVITY_MODERATED_POST_EDIT) user = request.user memo_set = models.ActivityAuditStatus.objects.filter( id__in=post_data['memo_list'], activity__activity_type__in=activity_types, user=user) action_type = post_data['action_type'] if action_type == 'delete': memo_set.delete() elif action_type == 'mark_new': memo_set.update( status=models.ActivityAuditStatus.STATUS_NEW) elif action_type == 'mark_seen': memo_set.update( status=models.ActivityAuditStatus.STATUS_SEEN) elif action_type == 'remove_flag': for memo in memo_set: activity_type = memo.activity.activity_type if activity_type == const.TYPE_ACTIVITY_MARK_OFFENSIVE: request.user.flag_post( post=memo.activity.content_object, cancel_all=True) elif activity_type in \ ( const.TYPE_ACTIVITY_MODERATED_NEW_POST, const.TYPE_ACTIVITY_MODERATED_POST_EDIT ): post_revision = memo.activity.content_object request.user.approve_post_revision( post_revision) memo.delete() #elif action_type == 'close': # for memo in memo_set: # if memo.activity.content_object.post_type == "question": # request.user.close_question(question = memo.activity.content_object, reason = 7) # memo.delete() elif action_type == 'delete_post': for memo in memo_set: content_object = memo.activity.content_object if isinstance(content_object, models.PostRevision): post = content_object.post else: post = content_object request.user.delete_post(post) reject_reason = models.PostFlagReason.objects.get( id=post_data['reject_reason_id']) body_text = string_concat( _('Your post (copied in the end),'), '<br/>', _('was rejected for the following reason:'), '<br/><br/>', reject_reason.details.html, '<br/><br/>', _('Here is your original post'), '<br/><br/>', post.text) mail.send_mail( subject_line=_('your post was not accepted'), body_text=unicode(body_text), recipient_list=[ post.author.email, ]) memo.delete() user.update_response_counts() response_data['success'] = True data = simplejson.dumps(response_data) return HttpResponse(data, mimetype="application/json") else: raise exceptions.PermissionDenied( _('Sorry, but anonymous users cannot access the inbox') ) else: raise exceptions.PermissionDenied('must use POST request') else: #todo: show error page but no-one is likely to get here return HttpResponseRedirect(reverse('index')) except Exception, e: message = unicode(e) if message == '': message = _('Oops, apologies - there was some error') response_data['message'] = message response_data['success'] = False data = simplejson.dumps(response_data) return HttpResponse(data, mimetype="application/json")
def vote(request, id): """ todo: this subroutine needs serious refactoring it's too long and is hard to understand vote_type: acceptAnswer : 0, questionUpVote : 1, questionDownVote : 2, favorite : 4, answerUpVote: 5, answerDownVote:6, offensiveQuestion : 7, remove offensiveQuestion flag : 7.5, remove all offensiveQuestion flag : 7.6, offensiveAnswer:8, remove offensiveAnswer flag : 8.5, remove all offensiveAnswer flag : 8.6, removeQuestion: 9, removeAnswer:10 questionSubscribeUpdates:11 questionUnSubscribeUpdates:12 accept answer code: response_data['allowed'] = -1, Accept his own answer 0, no allowed - Anonymous 1, Allowed - by default response_data['success'] = 0, failed 1, Success - by default response_data['status'] = 0, By default 1, Answer has been accepted already(Cancel) vote code: allowed = -3, Don't have enough votes left -2, Don't have enough reputation score -1, Vote his own post 0, no allowed - Anonymous 1, Allowed - by default status = 0, By default 1, Cancel 2, Vote is too old to be canceled offensive code: allowed = -3, Don't have enough flags left -2, Don't have enough reputation score to do this 0, not allowed 1, allowed status = 0, by default 1, can't do it again """ response_data = { "allowed": 1, "success": 1, "status": 0, "count": 0, "message": '' } try: if request.is_ajax() and request.method == 'POST': vote_type = request.POST.get('type') else: raise Exception(_('Sorry, something is not right here...')) if vote_type == '0': if request.user.is_authenticated(): answer_id = request.POST.get('postId') answer = get_object_or_404(models.Post, post_type='answer', id=answer_id) # make sure question author is current user if answer.accepted(): request.user.unaccept_best_answer(answer) response_data['status'] = 1 #cancelation else: request.user.accept_best_answer(answer) #################################################################### answer.thread.update_summary_html( ) # regenerate question/thread summary html #################################################################### else: raise exceptions.PermissionDenied( _('Sorry, but anonymous users cannot accept answers')) elif vote_type in ('1', '2', '5', '6'): #Q&A up/down votes ############################### # all this can be avoided with # better query parameters vote_direction = 'up' if vote_type in ('2', '6'): vote_direction = 'down' if vote_type in ('5', '6'): #todo: fix this weirdness - why postId here #and not with question? id = request.POST.get('postId') post = get_object_or_404(models.Post, post_type='answer', id=id) else: post = get_object_or_404(models.Post, post_type='question', id=id) # ###################### response_data = process_vote(user=request.user, vote_direction=vote_direction, post=post) #################################################################### if vote_type in ('1', '2'): # up/down-vote question post.thread.update_summary_html( ) # regenerate question/thread summary html #################################################################### elif vote_type in ['7', '8']: #flag question or answer if vote_type == '7': post = get_object_or_404(models.Post, post_type='question', id=id) if vote_type == '8': id = request.POST.get('postId') post = get_object_or_404(models.Post, post_type='answer', id=id) request.user.flag_post(post) response_data['count'] = post.offensive_flag_count response_data['success'] = 1 elif vote_type in ['7.5', '8.5']: #flag question or answer if vote_type == '7.5': post = get_object_or_404(models.Post, post_type='question', id=id) if vote_type == '8.5': id = request.POST.get('postId') post = get_object_or_404(models.Post, post_type='answer', id=id) request.user.flag_post(post, cancel=True) response_data['count'] = post.offensive_flag_count response_data['success'] = 1 elif vote_type in ['7.6', '8.6']: #flag question or answer if vote_type == '7.6': post = get_object_or_404(models.Post, id=id) if vote_type == '8.6': id = request.POST.get('postId') post = get_object_or_404(models.Post, id=id) request.user.flag_post(post, cancel_all=True) response_data['count'] = post.offensive_flag_count response_data['success'] = 1 elif vote_type in ['9', '10']: #delete question or answer post = get_object_or_404(models.Post, post_type='question', id=id) if vote_type == '10': id = request.POST.get('postId') post = get_object_or_404(models.Post, post_type='answer', id=id) if post.deleted == True: request.user.restore_post(post=post) else: request.user.delete_post(post=post) elif request.is_ajax() and request.method == 'POST': if not request.user.is_authenticated(): response_data['allowed'] = 0 response_data['success'] = 0 question = get_object_or_404(models.Post, post_type='question', id=id) vote_type = request.POST.get('type') #accept answer if vote_type == '4': fave = request.user.toggle_favorite_question(question) response_data[ 'count'] = models.FavoriteQuestion.objects.filter( thread=question.thread).count() if fave == False: response_data['status'] = 1 elif vote_type == '11': #subscribe q updates user = request.user if user.is_authenticated(): if user not in question.thread.followed_by.all(): user.follow_question(question) if askbot_settings.EMAIL_VALIDATION == True \ and user.email_isvalid == False: response_data['message'] = \ _( 'Your subscription is saved, but email address ' '%(email)s needs to be validated, please see ' '<a href="%(details_url)s">more details here</a>' ) % {'email':user.email,'details_url':reverse('faq') + '#validate'} subscribed = user.subscribe_for_followed_question_alerts() if subscribed: if 'message' in response_data: response_data['message'] += '<br/>' response_data['message'] += _( 'email update frequency has been set to daily') #response_data['status'] = 1 #responst_data['allowed'] = 1 else: pass #response_data['status'] = 0 #response_data['allowed'] = 0 elif vote_type == '12': #unsubscribe q updates user = request.user if user.is_authenticated(): user.unfollow_question(question) else: response_data['success'] = 0 response_data[ 'message'] = u'Request mode is not supported. Please try again.' if vote_type not in (1, 2, 4, 5, 6, 11, 12): #favorite or subscribe/unsubscribe #upvote or downvote question or answer - those #are handled within user.upvote and user.downvote post = models.Post.objects.get(id=id) post.thread.invalidate_cached_data() data = simplejson.dumps(response_data) except Exception, e: response_data['message'] = unicode(e) response_data['success'] = 0 data = simplejson.dumps(response_data)
def func_with_json_conversion(*args, **kwargs): return_value = func(*args, **kwargs) return HttpResponse(simplejson.dumps(return_value), mimetype='application/json')
def edit_file(request, form_class=FileForm, template_name="theme_editor/index.html"): if not has_perm(request.user, 'theme_editor.view_themefileversion'): raise Http403 selected_theme = request.GET.get("theme_edit", get_theme()) original_theme_root = os.path.join(settings.ORIGINAL_THEMES_DIR, selected_theme) if settings.USE_S3_THEME: theme_root = os.path.join(settings.THEME_S3_PATH, selected_theme) else: theme_root = os.path.join(settings.ORIGINAL_THEMES_DIR, selected_theme) # get the default file and clean up any input default_file = request.GET.get("file", DEFAULT_FILE) if default_file: default_file = default_file.replace('\\', '/') default_file = default_file.strip('/') default_file = default_file.replace('////', '/') default_file = default_file.replace('///', '/') default_file = default_file.replace('//', '/') is_file = qstr_is_file(default_file, ROOT_DIR=theme_root) is_dir = qstr_is_dir(default_file, ROOT_DIR=theme_root) if is_file: pass elif is_dir: # if default_file is a directory then append the # trailing slash so we can get the dirname below default_file = '%s/' % default_file else: # if the default_file is not a directory or file within # the themes folder then return a 404 raise Http404( _("Custom template not found. Make sure you've copied over the themes to the THEME_DIR." )) # get the current file name current_file = os.path.basename(default_file) # get file ext name = current_file.split('/')[-1] ext = name.split('.')[-1] stylesheets = ['css', 'less'] # get the present working directory # and make sure they cannot list root pwd = os.path.dirname(default_file) if pwd == '/': pwd = '' current_file_path = os.path.join(pwd, current_file) # get the previous directory name and path prev_dir = '/' prev_dir_name = 'theme base' pwd_split = pwd.split('/') if len(pwd_split) > 1: prev_dir_name = pwd_split[-2] pwd_split.pop() prev_dir = '/'.join(pwd_split) elif not pwd_split[0]: prev_dir = '' # get the direcory list dirs = get_dir_list(pwd, ROOT_DIR=theme_root) # get the file list files, non_editable_files = get_file_list(pwd, ROOT_DIR=theme_root) all_files_folders = get_all_files_list(ROOT_DIR=theme_root) # non-deletable files non_deletable_files = [ 'homepage.html', 'default.html', 'footer.html', 'header.html', 'sidebar.html', 'nav.html', 'styles.less', 'styles.css' ] # get the number of themes in the themes directory on the site theme_choices = [i for i in theme_choice_list()] theme_count = len(theme_choices) # get a list of revisions archives = ThemeFileVersion.objects.filter( relative_file_path=default_file).order_by("-create_dt") if request.is_ajax() and request.method == "POST": file_form = form_class(request.POST) response_status = 'FAIL' response_message = _('Cannot update file.') if file_form.is_valid(): if file_form.save(request, default_file, ROOT_DIR=theme_root, ORIG_ROOT_DIR=original_theme_root): response_status = 'SUCCESS' response_message = unicode(_('Your changes have been saved.')) EventLog.objects.log() response = json.dumps({ 'status': response_status, 'message': response_message }) return HttpResponse(response, mimetype="application/json") content = get_file_content(default_file, ROOT_DIR=theme_root) file_form = form_class({"content": content, "rf_path": default_file}) theme_form = ThemeSelectForm(initial={'theme_edit': selected_theme}) return render_to_response(template_name, { 'file_form': file_form, 'theme_form': theme_form, 'current_theme': selected_theme, 'current_file_path': current_file_path, 'current_file': current_file, 'prev_dir_name': prev_dir_name, 'prev_dir': prev_dir, 'pwd': pwd, 'dirs': dirs, 'files': files, 'non_editable_files': non_editable_files, 'non_deletable_files': non_deletable_files, 'theme_count': theme_count, 'archives': archives, 'is_file': is_file, 'is_dir': is_dir, 'all_files_folders': all_files_folders, 'ext': ext, 'stylesheets': stylesheets }, context_instance=RequestContext(request))
def user_profile(request): if request.method == 'POST': user = User.objects.get(id=request.POST['id_user']) profile = user.get_profile() form = CommForm(request.POST) # A form bound to the POST data user_user = User.objects.get(id=request.POST['id_user_profil']) profile_user = user_user.get_profile() cars_user = Car.objects.filter(user=user_user) comments_user = Comment.objects.filter(recipient__id=request.POST['id_user_profil']) routes_drivers = Route.objects.filter(is_driver=1, user_route=user_user.id).order_by('date_departure')[:3] routes_passengers = Route.objects.filter(is_driver=0, user_route=user_user.id).order_by('date_departure')[:3] if form.is_valid(): # All validation rules pass comm = form.save(commit=False) comm.writer_id = request.POST['id_user'] comm.recipient_id = request.POST['id_user_profil'] comm.content = request.POST['content'] comm.note = request.POST['note'] comm.date = datetime.now()#date("Y-m-d") # A CHANGER DANS LA BDD pour avoir l'heure comm.save() date = datetime.now().strftime('%d-%m-%Y') #Mise à jour de la note dans le profil de l'utilisateur profile_user.note = ((atof(profile_user.note) * profile_user.nb_rating) + atof(comm.note)) / (profile_user.nb_rating + 1) profile_user.nb_rating += 1 profile_user.save() data = { 'content':comm.content , 'note':comm.note, 'username':user.username, 'id_user':user.id, 'date':date, 'new_note':profile_user.note, 'nb_rating':profile_user.nb_rating } return HttpResponse(simplejson.dumps(data),mimetype='application/json') else: form = CommForm() return render_to_response('apps/user_profile.html', { 'profile_user' :profile_user, 'user_user': user_user, 'cars_user':cars_user, 'comments_user':comments_user, 'form':form, 'routes_drivers':routes_drivers, 'routes_passengers':routes_passengers },context_instance=RequestContext(request)) else: if request.user.is_authenticated(): id_u = request.GET.get('u') user_user = User.objects.get(id=id_u) profile_user = user_user.get_profile() cars_user = Car.objects.filter(user=user_user) comments_user = Comment.objects.filter(recipient__id=user_user.id) comments_user.order_by('-id') routes_drivers = Route.objects.filter(car__in=cars_user, user_route=user_user.id).order_by('date_departure')[:3] routes_passengers = Route.objects.exclude(car__in=cars_user).filter(user_route=user_user.id).order_by('date_departure')[:3] #dans la liste de l'utilisateur courant ou pas ? user = User.objects.get(username=request.user) contact = ContactsList.objects.filter(user = user, contact = user_user) if contact: already_contact = 1; else: already_contact = 0; form = CommForm() return render_to_response('apps/user_profile.html', { 'profile_user' :profile_user, 'user_user': user_user, 'cars_user':cars_user, 'comments_user':comments_user, 'form':form, 'routes_drivers':routes_drivers, 'routes_passengers':routes_passengers, 'already_contact':already_contact },context_instance=RequestContext(request)) else: return HttpResponseRedirect("/login/")
def visitclick_data_json(request, *args, **kwargs): """ For default this function return a data list of week """ google_format = {'rows':[],'cols':[ {'label':_('Time'),'type':'string','pattern':''}, {'label':_('Click'),'type':'number','pattern':''}, ]} if datetime.now().hour == 0: date_init = datetime.now()-timedelta(hours=4) else: date_init = datetime.now().date() date_end = datetime.now() strftime='%H:%M' field='date' display='hours' if 'week' in request.GET.values() or 'week' in request.POST.values(): date_end = get_first_dow(datetime.now().year, datetime.now().isocalendar()[1]) date_init = date_end-timedelta(days=6) strftime='%d/%m' display='days' elif 'month' in request.GET.values() or 'month' in request.POST.values(): date_init = date(date_end.year,date_end.month,1) strftime='%d/%m' display='days' elif 'year' in request.GET.values() or 'year' in request.POST.values(): date_init = datetime.now() - timedelta(days=365) strftime='%m/%Y' display='months' elif 'custom' in request.GET.values() or 'custom' in request.POST.values(): date_init = datetime.strptime(request.POST.get('date_init',False) or request.GET.get('date_init'),'%Y-%m-%d') date_end = datetime.strptime(request.POST.get('date_end',False) or request.GET.get('date_end'),'%Y-%m-%d') date_diff = date_end-date_init if (date_diff.days ==1): strftime='%d/%m' display='hours' elif (date_diff.days >2 and date_diff.days <=31): strftime='%d/%m' display='days' elif (date_diff.days > 31): strftime='%d/%m' display='months' elif 'clicks' in request.GET.values() or 'clicks' in request.POST.values(): date_init = datetime.strptime(request.POST.get('date_init',False) or request.GET.get('date_init'),'%Y-%m-%d %H:%M:%S') date_end = request.POST.get('date_end',False) or request.GET.get('date_end',False) field='url' google_format['cols']=[ {'label':_('Url'),'type':'string','pattern':''}, {'label':_('Click'),'type':'number','pattern':''}, ] if date_end: date_end = datetime.strptime(date_end,'%Y-%m-%d %H:%M:%S') else: date_end =date_init+timedelta(hours=1) elif 'browsers' in request.GET.values() or 'browsers' in request.POST.values(): field='browser' google_format['cols']=[ {'label':_('Browsers'),'type':'string','pattern':''}, {'label':_('Click'),'type':'number','pattern':''}, ] elif 'operating_system' in request.GET.values() or 'operate_system' in request.POST.values(): field='operating_system' google_format['cols']=[ {'label':_('Operating System'),'type':'string','pattern':''}, {'label':_('Click'),'type':'number','pattern':''}, ] clicks = Click.objects.filter( Q(date__gte=date_init), Q(date__lte=date_end) ) if not ('clicks' in request.GET.values() or 'clicks' in request.POST.values()) and \ not ('browsers' in request.GET.values() or 'browsers' in request.POST.values()) and \ not ('operating_system' in request.GET.values() or 'operating_system' in request.POST.values()): clicks = QuerySetStats(clicks, field).time_series(date_init,date_end, display,aggregate=Count(field)) else: clicks= clicks.values(field).order_by(field).annotate(count=Count(field)) if field == 'date': google_format['cols']=[ {'label':_('Date'),'type':'string','pattern':''}, {'label':_('Click'),'type':'number','pattern':''}, ] for click in clicks: if type(click) is tuple: value_line=click[0] label_line=click[0] value_column=str(click[1]) label_column=click[1] if type(click) is dict: value_line, value_column = click.values() label_line, label_column = click.values() if isinstance(value_line,datetime): value_line=value_line.strftime(strftime) if field == 'browser' or field == 'operating_system': google_format['rows'].append({ 'c':[ {'v':label_column,'f':value_column}, {'v':label_line,'f':value_line}, ] }) else: google_format['rows'].append({ 'c':[ {'v':label_line,'f':value_line}, {'v':label_column,'f':value_column}, ] }) return HttpResponse( simplejson.dumps(google_format,cls=DjangoJSONEncoder), mimetype='application/json' )
def map_download(request, mapid, template='maps/map_download.html'): """ Download all the layers of a map as a batch XXX To do, remove layer status once progress id done This should be fix because """ if not mapid.isdigit(): map_obj = _resolve_map_custom(request, mapid, 'urlsuffix', 'base.view_resourcebase', _PERMISSION_MSG_VIEW) else: map_obj = _resolve_map(request, mapid, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) map_status = dict() if request.method == 'POST': url = "%srest/process/batchDownload/launch/" % ogc_server_settings.LOCATION def perm_filter(layer): return request.user.has_perm('base.view_resourcebase', obj=layer.get_self_resource()) mapJson = map_obj.json(perm_filter) # we need to remove duplicate layers j_map = json.loads(mapJson) j_layers = j_map["layers"] for j_layer in j_layers: if (len([l for l in j_layers if l == j_layer])) > 1: j_layers.remove(j_layer) mapJson = json.dumps(j_map) resp, content = http_client.request(url, 'POST', body=mapJson) status = int(resp.status) if status == 200: map_status = json.loads(content) request.session["map_status"] = map_status else: raise Exception( 'Could not start the download of %s. Error was: %s' % (map_obj.title, content)) locked_layers = [] remote_layers = [] downloadable_layers = [] for lyr in map_obj.layer_set.all(): if lyr.group != "background": if not lyr.local: remote_layers.append(lyr) else: ownable_layer = Layer.objects.get(typename=lyr.name) if not request.user.has_perm( 'view_resourcebase', obj=ownable_layer.get_self_resource()): locked_layers.append(lyr) else: # we need to add the layer only once if len( [l for l in downloadable_layers if l.name == lyr.name]) == 0: downloadable_layers.append(lyr) return render_to_response( template, RequestContext( request, { "map_status": map_status, "map": map_obj, "locked_layers": locked_layers, "remote_layers": remote_layers, "downloadable_layers": downloadable_layers, "site": settings.SITEURL }))
def layer_detail(request, layername, template='layers/layer_detail.html'): layer = _resolve_layer(request, layername, 'base.view_resourcebase', _PERMISSION_MSG_VIEW) # assert False, str(layer_bbox) config = layer.attribute_config() # TODO (Mapstory): This has been commented out to force the client to make a getCapabilities request in order # to pull in the time dimension data. Ideally we would cache time data just like the srs and bbox data to prevent # making the getCapabilities request. # Add required parameters for GXP lazy-loading #layer_bbox = layer.bbox #bbox = [float(coord) for coord in list(layer_bbox[0:4])] #srid = layer.srid # Transform WGS84 to Mercator. #config["srs"] = srid if srid != "EPSG:4326" else "EPSG:900913" #config["bbox"] = llbbox_to_mercator([float(coord) for coord in bbox]) #config["title"] = layer.title #config["queryable"] = True if layer.storeType == "remoteStore": service = layer.service source_params = { "ptype": service.ptype, "remote": True, "url": service.base_url, "name": service.name } maplayer = GXPLayer(name=layer.typename, ows_url=layer.ows_url, layer_params=json.dumps(config), source_params=json.dumps(source_params)) else: maplayer = GXPLayer(name=layer.name, ows_url=layer.ows_url, layer_params=json.dumps(config)) # Update count for popularity ranking, # but do not includes admins or resource owners if request.user != layer.owner and not request.user.is_superuser: Layer.objects.filter(id=layer.id).update( popular_count=F('popular_count') + 1) # center/zoom don't matter; the viewer will center on the layer bounds map_obj = GXPMap(projection="EPSG:900913") NON_WMS_BASE_LAYERS = [ la for la in default_map_config()[1] if la.ows_url is None ] metadata = layer.link_set.metadata().filter( name__in=settings.DOWNLOAD_FORMATS_METADATA) if request.method == "POST": keywords_form = KeywordsForm(request.POST, instance=layer) metadata_form = MetadataForm(request.POST, instance=layer) published_form = PublishStatusForm(request.POST, instance=layer) if keywords_form.is_valid(): new_keywords = keywords_form.cleaned_data['keywords'] layer.keywords.clear() layer.keywords.add(*new_keywords) if metadata_form.is_valid(): # update all the metadata if metadata_form.cleaned_data['category'] is not None: new_category = TopicCategory.objects.get( id=metadata_form.cleaned_data['category'].id) Layer.objects.filter(id=layer.id).update(category=new_category) new_language = metadata_form.cleaned_data['language'] new_distribution_url = metadata_form.cleaned_data[ 'distribution_url'] new_data_quality_statement = metadata_form.cleaned_data[ 'data_quality_statement'] new_purpose = metadata_form.cleaned_data['purpose'] layer.language = new_language layer.distribution_url = new_distribution_url layer.data_quality_statement = new_data_quality_statement layer.purpose = new_purpose layer.save() if published_form.is_valid(): layer.is_published = published_form.cleaned_data['is_published'] layer.save() else: keywords_form = KeywordsForm(instance=layer) metadata_form = MetadataForm(instance=layer) published_form = PublishStatusForm(instance=layer) content_moderators = Group.objects.filter(name='content_moderator').first() context_dict = { "resource": layer, "permissions_json": _perms_info_json(layer), "documents": get_related_documents(layer), "metadata": metadata, "is_layer": True, "wps_enabled": settings.OGC_SERVER['default']['WPS_ENABLED'], "keywords_form": keywords_form, "metadata_form": metadata_form, "published_form": published_form, "content_moderators": content_moderators, } context_dict["viewer"] = json.dumps( map_obj.viewer_json(request.user, *(NON_WMS_BASE_LAYERS + [maplayer]))) context_dict["preview"] = getattr(settings, 'LAYER_PREVIEW_LIBRARY', 'leaflet') if request.user.has_perm('download_resourcebase', layer.get_self_resource()): if layer.storeType == 'dataStore': links = layer.link_set.download().filter( name__in=settings.DOWNLOAD_FORMATS_VECTOR) else: links = layer.link_set.download().filter( name__in=settings.DOWNLOAD_FORMATS_RASTER) context_dict["links"] = links if settings.SOCIAL_ORIGINS: context_dict["social_links"] = build_social_links(request, layer) return render_to_response(template, RequestContext(request, context_dict))
def upload(request, album_id=0): id = int(album_id) upload_sessionid = request.COOKIES['sessionid'] gallerys = Gallery.objects.filter(user_id=request.user.id) has_gallery = gallerys.count() > 0 if not has_gallery: return HttpResponseRedirect(reverse('7create_album')) if request.method != 'POST': response = render_to_response('albums/upload.html', RequestContext(request, locals())) response.set_cookie('upload_sessionid', upload_sessionid, httponly=False) return response if request.FILES == None: return HttpResponseBadRequest('Must have files attached!') if 'selected_album' not in request.POST: return HttpResponseBadRequest('Must select a album') ufile = request.FILES[u'Filedata'] id = int(request.POST['selected_album']) parent = str(id / 10000) child = str(id % 10000) print 'in upload :' + ufile.name path = parent + '/' + child + '/' fold = os.path.join(MEDIA_ROOT, path) filename = str(random.randint(1, 1000)) + '_' + ufile.name filepath = path + filename thumbpath = filepath + '.thumbnail' thumbpath2 = thumbpath + '2' squarepath = filepath + '.square' if not os.path.exists(fold): os.makedirs(fold) print 'in uplaod :' + path image = Image.open(ufile) print image.info, filepath image.save(os.path.join(MEDIA_ROOT, filepath)) print 'first save' image_square = image.resize((100, 100), Image.ANTIALIAS) image_square.save(os.path.join(MEDIA_ROOT, squarepath), 'JPEG') image.thumbnail((128, 128), Image.ANTIALIAS) image.save(os.path.join(MEDIA_ROOT, thumbpath), 'JPEG') image.thumbnail((64, 64), Image.ANTIALIAS) image.save(os.path.join(MEDIA_ROOT, thumbpath2), 'JPEG') gallery = Gallery.objects.select_for_update().get(id=id) gallery.photo_num = F('photo_num') + 1 gallery.save() gallery = Gallery.objects.get(pk=gallery.pk) index = gallery.photo_num print 'index:', gallery.photo_num photo = Photo.objects.create(gallery_id=id, index=index, uname=ufile.name, name=filename, path=filepath, thumb128=thumbpath, thumb64=thumbpath2, square=squarepath) print 'after:', gallery.photo_num user_modify_gallery.send(sender=Photo, gallery=gallery) if not gallery.cover: gallery.cover = squarepath gallery.save() # update photo broadcast b_photos = B_Photo.objects.filter(gallery_id=id).order_by('-pub_date') if b_photos.count() != 0 and b_photos[0].pub_date.strftime( "%Y%m%d") == timezone.now().strftime("%Y%m%d"): b_photo = b_photos[0] else: b_photo = B_Photo.objects.create(user_id=request.user.id, gallery_id=id) b_photo.num = F('num') + 1 b_photo.pub_date = timezone.now() b_photo.save() from django.utils import simplejson data = {'thumb64': photo.thumb64, 'index': photo.index} return HttpResponse(simplejson.dumps(data))
def maplayer_attributes(request, layername): #Return custom layer attribute labels/order in JSON format layer = Layer.objects.get(typename=layername) return HttpResponse(json.dumps(layer.attribute_config()), mimetype="application/json")
def _get_extra_layers(): layers = getattr(settings, 'MAP_CUSTOM_BASE_LAYERS', []) return simplejson.dumps(layers, indent=2)
def new_map_config(request): ''' View that creates a new map. If the query argument 'copy' is given, the initial map is a copy of the map with the id specified, otherwise the default map configuration is used. If copy is specified and the map specified does not exist a 404 is returned. ''' DEFAULT_MAP_CONFIG, DEFAULT_BASE_LAYERS = default_map_config() if request.method == 'GET' and 'copy' in request.GET: mapid = request.GET['copy'] if not mapid.isdigit(): map_obj = _resolve_map_custom(request, mapid, 'urlsuffix', 'base.view_resourcebase') else: map_obj = _resolve_map(request, mapid, 'base.view_resourcebase') map_obj.abstract = DEFAULT_ABSTRACT map_obj.title = DEFAULT_TITLE if request.user.is_authenticated(): map_obj.owner = request.user config = map_obj.viewer_json(request.user) del config['id'] else: if request.method == 'GET': params = request.GET elif request.method == 'POST': params = request.POST else: return HttpResponse(status=405) if 'layer' in params: bbox = None map_obj = Map(projection="EPSG:900913") layers = [] for layer_name in params.getlist('layer'): try: layer = _resolve_layer(request, layer_name) except ObjectDoesNotExist: # bad layer, skip continue if not request.user.has_perm('view_resourcebase', obj=layer.get_self_resource()): # invisible layer, skip inclusion continue layer_bbox = layer.bbox # assert False, str(layer_bbox) if bbox is None: bbox = list(layer_bbox[0:4]) else: bbox[0] = min(bbox[0], layer_bbox[0]) bbox[1] = max(bbox[1], layer_bbox[1]) bbox[2] = min(bbox[2], layer_bbox[2]) bbox[3] = max(bbox[3], layer_bbox[3]) config = layer.attribute_config() #Add required parameters for GXP lazy-loading config["srs"] = layer.srid config["title"] = layer.title config["bbox"] = [float(coord) for coord in bbox] \ if layer.srid == "EPSG:4326" else llbbox_to_mercator([float(coord) for coord in bbox]) config["queryable"] = True if layer.storeType == "remoteStore": service = layer.service maplayer = MapLayer(map=map_obj, name=layer.typename, ows_url=layer.ows_url, layer_params=json.dumps(config), visibility=True, source_params=json.dumps({ "ptype": service.ptype, "remote": True, "url": service.base_url, "name": service.name })) else: maplayer = MapLayer(map=map_obj, name=layer.typename, ows_url=layer.ows_url, layer_params=json.dumps(config), visibility=True) layers.append(maplayer) if bbox is not None: minx, miny, maxx, maxy = [float(c) for c in bbox] x = (minx + maxx) / 2 y = (miny + maxy) / 2 center = list(forward_mercator((x, y))) if center[1] == float('-inf'): center[1] = 0 BBOX_DIFFERENCE_THRESHOLD = 1e-5 #Check if the bbox is invalid valid_x = (maxx - minx)**2 > BBOX_DIFFERENCE_THRESHOLD valid_y = (maxy - miny)**2 > BBOX_DIFFERENCE_THRESHOLD if valid_x: width_zoom = math.log(360 / abs(maxx - minx), 2) else: width_zoom = 15 if valid_y: height_zoom = math.log(360 / abs(maxy - miny), 2) else: height_zoom = 15 map_obj.center_x = center[0] map_obj.center_y = center[1] map_obj.zoom = math.ceil(min(width_zoom, height_zoom)) config = map_obj.viewer_json(request.user, *(DEFAULT_BASE_LAYERS + layers)) config['fromLayer'] = True else: config = DEFAULT_MAP_CONFIG return json.dumps(config)
def get_datatables_records(request, querySet, columnIndexNameMap, jsonTemplatePath=None, *args): """ Usage: querySet: query set to draw data from. columnIndexNameMap: field names in order to be displayed. jsonTemplatePath: optional template file to generate custom json from. If not provided it will generate the data directly from the model. """ cols = int(request.GET.get('iColumns', 0)) # Get the number of columns iDisplayLength = min( int(request.GET.get('iDisplayLength', 10)), 100 ) #Safety measure. If someone messes with iDisplayLength manually, we clip it to the max value of 100. startRecord = int(request.GET.get('iDisplayStart', 0)) # Where the data starts from (page) endRecord = startRecord + iDisplayLength # where the data ends (end of page) # Pass sColumns keys = columnIndexNameMap.keys() keys.sort() colitems = [columnIndexNameMap[key] for key in keys] sColumns = ",".join(map(str, colitems)) # Ordering data iSortingCols = int(request.GET.get('iSortingCols', 0)) asortingCols = [] if iSortingCols: for sortedColIndex in range(0, iSortingCols): sortedColID = int( request.GET.get('iSortCol_' + str(sortedColIndex), 0)) if request.GET.get( 'bSortable_{0}'.format(sortedColID), 'false' ) == 'true': # make sure the column is sortable first sortedColName = columnIndexNameMap[sortedColID] sortingDirection = request.GET.get( 'sSortDir_' + str(sortedColIndex), 'asc') if sortingDirection == 'desc': sortedColName = '-' + sortedColName asortingCols.append(sortedColName) querySet = querySet.order_by(*asortingCols) # Determine which columns are searchable searchableColumns = [] for col in range(0, cols): if request.GET.get('bSearchable_{0}'.format(col), False) == 'true': searchableColumns.append(columnIndexNameMap[col]) # Apply filtering by value sent by user customSearch = request.GET.get('sSearch', '').encode('utf-8') if customSearch != '': outputQ = None first = True for searchableColumn in searchableColumns: kwargz = {searchableColumn + "__icontains": customSearch} outputQ = outputQ | Q(**kwargz) if outputQ else Q(**kwargz) querySet = querySet.filter(outputQ) # Individual column search outputQ = None for col in range(0, cols): if request.GET.get('sSearch_{0}'.format(col), False) > '' and request.GET.get( 'bSearchable_{0}'.format(col), False) == 'true': kwargz = { columnIndexNameMap[col] + "__icontains": request.GET['sSearch_{0}'.format(col)] } outputQ = outputQ & Q(**kwargz) if outputQ else Q(**kwargz) if outputQ: querySet = querySet.filter(outputQ) iTotalRecords = iTotalDisplayRecords = querySet.count( ) #count how many records match the final criteria querySet = querySet[startRecord:endRecord] #get the slice sEcho = int(request.GET.get('sEcho', 0)) # required echo response if jsonTemplatePath: jstonString = render_to_string( jsonTemplatePath, locals() ) #prepare the JSON with the response, consider using : from django.template.defaultfilters import escapejs response = HttpResponse(jstonString, mimetype="application/javascript") else: aaData = [] a = querySet.values() for row in a: rowkeys = row.keys() rowvalues = row.values() rowlist = [] for col in range(0, len(colitems)): for idx, val in enumerate(rowkeys): if val == colitems[col]: rowlist.append(str(rowvalues[idx])) aaData.append(rowlist) response_dict = {} response_dict.update({'aaData': aaData}) response_dict.update({ 'sEcho': sEcho, 'iTotalRecords': iTotalRecords, 'iTotalDisplayRecords': iTotalDisplayRecords, 'sColumns': sColumns }) response = HttpResponse(simplejson.dumps(response_dict), mimetype='application/javascript') #prevent from caching datatables result add_never_cache_headers(response) return response
def vote(request): result = {'success': False} # Get an instance of a logger logger = logging.getLogger('scirate.rate') if request.user.is_authenticated(): # [don't remember why I commented that out, is_ajax() property should probably be checked here] # if (request.method == u'GET' and request.is_ajax()): if (request.method == u'GET'): GET = request.GET logger.info(GET) if GET.has_key(u'identifier') and GET.has_key(u'vote'): ident = GET[u'identifier'] vote = GET[u'vote'] # retrieve article, TODO: what if this article does not exist? art = Article.objects.get(identifier=ident) if vote == u"like": # remove possible dislikes art.dislikes.remove(request.user) if art.likes.filter(username=request.user.username): # If this user already likes the article, then the like should be removed art.likes.remove(request.user) else: # add the user to the list of likes art.likes.add(request.user) elif vote == u"dislike": # remove a possible like by this user art.likes.remove(request.user) if art.dislikes.filer(username=request.user.username): # If this user already dislikes the article, then the dislike should be removed art.dislikes.remove(request.user) else: # add the user to the list of dislikes art.dislikes.add(request.user) elif vote == u"abstract": # add user to the abstract_expansion list of the article art.abstract_expansions.add(request.user) # for the many-to-many relation changes above, it is not necessary to call the # the .save() method # now is the moment to update the score of the article art.updatescore() # TODO: inform the javascript if like/dislike has been removed result = {'success': True, 'score': art.score} logger.debug(result) else: # register anonymous abstract expansion # TODO: avoid that the same anonymous user can arbitrarily increase this counter # maybe the anonymous user is not that anonymous after all ? # check what kind of things (like IP-address) one could retrieve from the # django request.user object to make anonymous unique # we might then have to keep track of those IP-addresses... if (request.method == u'GET' and request.is_ajax()): GET = request.GET logger.info(GET) if GET.has_key(u'identifier') and GET.has_key(u'vote'): ident = GET[u'identifier'] vote = GET[u'vote'] if vote == u"abstract": # retrieve article, TODO: what if this article does not exist? art = Article.objects.get(identifier=ident) art.anonymous_abs_exp += 1 art.save() logger.info( 'increased anonymous abstract expansion to {0}'.format( art.anonymous_abs_exp)) result = {'success': True, 'score': art.score} elif (vote == u"like" or vote == u"dislike"): result = {'success': False, 'reason': 'not logged in'} # TODO: javascript should display a message that one has to login in order to vote # return appropriate response # convert result from Python dictionary to proper JSON json = simplejson.dumps(result) return HttpResponse(json, mimetype='application/json')
def last_session(self): if self.session: return json.dumps(self.session.split("\n")) return '[]'
try: model_instance = model_class.objects.get(pk=target_id) links = LinkReference.get_from(model_instance) except Exception, err: jd = json.dumps({'rc': 1, 'response': str(err)}) return HttpJSONResponseServerError(content=jd) jd = [] for link in links: jd.append({'name': link.name, 'url': link.url}) jd = json.dumps(jd) return HttpJSONResponse(content=jd) else: jd = json.dumps({'rc': 1, 'response': form.errors.as_text()}) return HttpJSONResponseBadRequest(content=jd) @user_passes_test(lambda u: u.has_perm('testruns.change_testcaserun')) @require_GET def remove(request, link_id): ''' Remove a specific link with ID ``link_id`` ''' from django.forms import IntegerField from django.forms import ValidationError field = IntegerField(min_value=1) try: value = field.clean(link_id) except ValidationError, err:
def user_detail(request, pk): user = User.objects.get(pk=pk) data = simplejson.dumps(user_dict(user)) return HttpResponse(data, mimetype='application/json')
def render(self, name, value, attrs=None): if not isinstance(value, basestring): value = json.dumps(value, indent=2) return super(JSONWidget, self).render(name, value, attrs)
def json_response(something): '''Turn something into JSON''' o = [] o.append(something) return HttpResponse(simplejson.dumps(o), content_type='application/javascript; charset=utf8')
def user_list(request): users = User.objects.all() data = [user_dict(user) for user in users] data = simplejson.dumps(data) return HttpResponse(data, mimetype='application/json')
def __init__(self, body): super(APNSAlert, self).__init__() self.body(json.dumps(body)[1:-1])
def handle_simple(self, simple): """ Called to handle values that can be handled via simplejson """ esc = self.safe_string(dumps(simple)) self.stream.write(esc)
def convert_context_to_json(self, context): return simplejson.dumps(context)
def render_template(cls, type, names, context, max_len=None): context['cut_encoder'] = lambda s: json.dumps(s)[1:-1] context['cut_decoder'] = lambda s: json.loads('"%s"' % s) return super(iPhonePush, cls).render_template(type, names, context, max_len)
def risk(request): """ This function creates data and serves detailed information about adherence for specific medications.""" # Declare global variables that may be modified here global Global_PATIENT_ID global Global_ADHERE_VARS # Get the name of the drug if a specific one was requested. # The default is 'all' drugs. drug = request.GET.get('drug', 'all') # Current context information smart = client.FHIRClient(state=request.session['client_state']) # Get the medication dispenses for this context dispenses = MedicationDispense.where().patient(smart.patient_id).perform(smart.server) pills = [] for dispense in dispenses: d = dispense.dispense[0] name = d.medication.resolved.name assert d.status == 'completed' quant = list(ext.valueQuantity.value for ext in d.extension if ext.url == 'http://fhir-registry.smarthealthit.org/Profile/dispense#days-supply')[0] when = d.whenHandedOver.isostring pills.append((None,name,quant,when)) # The the fulfillment gap and MPR prediction data meds_flags, gaps, refill_data, refill_day = Global_ADHERE_VARS names = [] if drug == 'all': # get all the drugs for this patient for pill in pills: name = pill[1] names.append(name) d = pill[3] else: # only use the specified drug name meds_flags_new = [] names.append(drug) for item in meds_flags: if drug == item[0]: meds_flags_new.append(item) meds_flags = meds_flags_new ad_data = [] med_names = [] for n in names: d = {} d["title"] = str(n) med_names.append(n) d["subtitle"] = 'adherence' d["measures"] = [1.0] ad_data.append(d) drug_class_array = {} for n in range(len(meds_flags)): drug_class_array[meds_flags[n][5]] = 1 sorted_drug_class_array = sorted(drug_class_array.keys()) # Determine width and height of chart by the number of drugs to be shown width = 400 height = 100 if len(names) == 1: width = 500 height = 200 variables = RequestContext(request, { 'head_title': u'Predicted 1-year medication possession ratio (MPR)', 'med_names': med_names, 'meds_flags': meds_flags, 'refill_day': simplejson.dumps(refill_day), 'refill': simplejson.dumps(refill_data), 'gaps': simplejson.dumps(gaps), 'width': width, 'height': height, 'drug_class_array': sorted_drug_class_array, }) response = render_to_response("risk.html", context_instance=variables ) return HttpResponse(response)
def _build(self): return "%s:%s" % (json.dumps( self.name), self.data if self.encoded else json.dumps(self.data))