Example #1
0
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))
Example #2
0
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'])
Example #3
0
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
            )
Example #4
0
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'})
Example #5
0
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
            )
Example #6
0
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')
Example #7
0
    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))
Example #8
0
File: api.py Project: xueyw/tsCloud
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))
Example #9
0
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)
    )
Example #10
0
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))
Example #11
0
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))
Example #12
0
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")
Example #13
0
 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)))
Example #14
0
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)
Example #15
0
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')
Example #16
0
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}))
Example #17
0
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))
Example #18
0
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")
Example #19
0
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")
Example #20
0
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")
Example #21
0
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')
Example #22
0
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)})
Example #23
0
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))
Example #24
0
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)
Example #25
0
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()
Example #27
0
    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."]}}""")
Example #28
0
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')
Example #29
0
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'})
Example #30
0
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")
Example #31
0
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)
Example #32
0
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))
Example #33
0
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)
Example #34
0
def jsonify(object):
    if isinstance(object, QuerySet):
        return mark_safe(serialize('json', object))
    return mark_safe(simplejson.dumps(object))
Example #35
0
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")
Example #36
0
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)
Example #37
0
 def func_with_json_conversion(*args, **kwargs):
     return_value = func(*args, **kwargs)
     return HttpResponse(simplejson.dumps(return_value),
                         mimetype='application/json')
Example #38
0
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))
Example #39
0
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/")
Example #40
0
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'
	)
Example #41
0
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
            }))
Example #42
0
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))
Example #43
0
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))
Example #44
0
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")
Example #45
0
def _get_extra_layers():
    layers = getattr(settings, 'MAP_CUSTOM_BASE_LAYERS', [])
    return simplejson.dumps(layers, indent=2)
Example #46
0
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)
Example #47
0
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
Example #48
0
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')
Example #49
0
    def last_session(self):
        if self.session:
            return json.dumps(self.session.split("\n"))

        return '[]'
Example #50
0
        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:
Example #51
0
def user_detail(request, pk):
    user = User.objects.get(pk=pk)
    data = simplejson.dumps(user_dict(user))
    return HttpResponse(data, mimetype='application/json')
Example #52
0
	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)
Example #53
0
def json_response(something):
    '''Turn something into JSON'''
    o = []
    o.append(something)
    return HttpResponse(simplejson.dumps(o),
                        content_type='application/javascript; charset=utf8')
Example #54
0
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')
Example #55
0
 def __init__(self, body):
     super(APNSAlert, self).__init__()
     self.body(json.dumps(body)[1:-1])
Example #56
0
 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)
Example #57
0
 def convert_context_to_json(self, context):
     return simplejson.dumps(context)
Example #58
0
    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)
Example #59
0
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)
Example #60
0
 def _build(self):
     return "%s:%s" % (json.dumps(
         self.name), self.data if self.encoded else json.dumps(self.data))