main.utils.to_json

Here are the examples of the python api main.utils.to_json taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

40 Examples 7

Example 1

Project: mootiro-maps Source File: views.py
def communities_geojson(request):
    bounds = request.GET.get('bounds', None)
    x1, y2, x2, y1 = [float(i) for i in bounds.split(',')]
    polygon = Polygon(((x1, y1), (x1, y2), (x2, y2), (x2, y1), (x1, y1)))
    # communities = Community.objects.filter(geometry__intersects=polygon)
    intersects_polygon = (Q(points__intersects=polygon) |
                          Q(lines__intersects=polygon) |
                          Q(polys__intersects=polygon))
    communities = Community.objects.filter(intersects_polygon)
    geojson = create_geojson(communities)
    return HttpResponse(to_json(geojson),
        mimetype="application/x-javascript")

Example 2

Project: mootiro-maps Source File: views.py
Function: search_by_name
def search_by_name(request):
    term = request.GET['term']
    communities = Community.objects.filter(Q(name__icontains=term) |
                                           Q(slug__icontains=term))
    d = [{'value': c.id, 'label': c.name} for c in communities]
    return HttpResponse(to_json(d),
                        mimetype="application/x-javascript")

Example 3

Project: mootiro-maps Source File: views.py
def search_tags(request):
    term = request.GET['term']
    qset = TaggedItem.tags_for(Community).filter(name__istartswith=term
            ).annotate(count=Count('taggit_taggeditem_items__id')
            ).order_by('-count', 'slug')[:10]
    tags = [t.name for t in qset]
    return HttpResponse(to_json(tags),
                mimetype="application/x-javascript")

Example 4

Project: mootiro-maps Source File: views.py
def tag_search(request):
    term = request.GET['term']
    qset = TaggedItem.tags_for(Investment).filter(name__istartswith=term)
    tags = [t.name for t in qset]
    return HttpResponse(to_json(tags),
            mimetype="application/x-javascript")

Example 5

Project: mootiro-maps Source File: models.py
Function: geojson
    @property
    def geojson(self):
        geojson = create_geojson([self], convert=False)
        if geojson and geojson.get('features'):
            geojson['features'][0]['properties']['userCanEdit'] = True
            geojson['features'][0]['properties']['alwaysVisible'] = True
        return to_json(geojson)

Example 6

Project: mootiro-maps Source File: views.py
def project_layers(request, proj_id=None):
    project = get_object_or_404(Project, id=proj_id)
    layers = project.layers
    if not layers:
        layers = default_layers()
    return HttpResponse(
        to_json(layers),
        mimetype="application/x-javascript")

Example 7

Project: mootiro-maps Source File: models.py
Function: json
    @property
    def json(self):
        return to_json({
            'name': self.name,
            'slug': self.slug,
            'logo_url': self.logo_url,
            'view_url': self.view_url,
            'partners_logo': [{'url': logo.file.url}
                                for logo in self.partners_logo()],
            'bbox': self.bbox,
            'custom_bbox': self.custom_bbox,
            'maptype': self.maptype,
        })

Example 8

Project: mootiro-maps Source File: views.py
def tag_search(request):
    term = request.GET['term']
    qset = TaggedItem.tags_for(Project).filter(name__istartswith=term)
    tags = [t.name for t in qset]
    return HttpResponse(to_json(tags),
                mimetype="application/x-javascript")

Example 9

Project: mootiro-maps Source File: views.py
def all_tag_search(request):
    term = request.GET['term']
    tags = []
    qset = TaggedItem.tags_for(Community).filter(name__istartswith=term)
    tags += [t.name for t in qset]
    qset = TaggedItem.tags_for(Need).filter(name__istartswith=term)
    tags += [t.name for t in qset]
    qset = TaggedItem.tags_for(Resource).filter(name__istartswith=term)
    tags += [t.name for t in qset]
    qset = TaggedItem.tags_for(Organization).filter(name__istartswith=term)
    tags += [t.name for t in qset]
    tags = list(set(tags))  # remove duplicates
    return HttpResponse(to_json(tags),
                mimetype="application/x-javascript")

Example 10

Project: mootiro-maps Source File: views.py
Function: search_by_name
def search_by_name(request):
    term = request.GET['term']
    projects = Project.objects.filter(Q(name__icontains=term) |
                                           Q(slug__icontains=term))
    d = [{'value': p.id, 'label': p.name} for p in projects
            if p.user_can_edit(request.user)]
    return HttpResponse(to_json(d),
            mimetype="application/x-javascript")

Example 11

Project: mootiro-maps Source File: views.py
def search_by_kind(request):
    term = request.GET.get('term', '')
    kinds = ResourceKind.objects.filter(Q(name__icontains=term) |
        Q(slug__icontains=term))
    d = [{'value': k.id, 'label': k.name} for k in kinds]
    return HttpResponse(to_json(d),
        mimetype="application/x-javascript")

Example 12

Project: mootiro-maps Source File: views.py
def search_tags(request):
    term = request.GET['term']
    qset = TaggedItem.tags_for(Resource).filter(name__istartswith=term
            ).annotate(count=Count('taggit_taggeditem_items__id')
            ).order_by('-count', 'slug')[:10]
    tags = [t.name for t in qset]
    return HttpResponse(to_json(tags),
                mimetype="application/x-javascript")

Example 13

Project: mootiro-maps Source File: views.py
def tag_search(request):
    term = request.GET['term']
    qset = TaggedItem.tags_for(Need).filter(name__istartswith=term)
    tags = [t.name for t in qset]
    return HttpResponse(to_json(tags),
                mimetype="application/x-javascript")

Example 14

Project: mootiro-maps Source File: views.py
def target_audience_search(request):
    term = request.GET['term']
    qset = TargetAudience.objects.filter(name__istartswith=term)
    target_audiences = [ta.name for ta in qset]
    return HttpResponse(to_json(target_audiences),
                mimetype="application/x-javascript")

Example 15

Project: mootiro-maps Source File: views.py
def needs_geojson(request):
    bounds = request.GET.get('bounds', None)
    x1, y2, x2, y1 = [float(i) for i in bounds.split(',')]
    polygon = Polygon(((x1, y1), (x1, y2), (x2, y2), (x2, y1), (x1, y1)))
    needs = Need.objects.filter(
            Q(points__intersects=polygon) |
            Q(lines__intersects=polygon) |
            Q(polys__intersects=polygon)
    )
    geojson = create_geojson(needs)
    return HttpResponse(to_json(geojson),
        mimetype="application/x-javascript")

Example 16

Project: mootiro-maps Source File: models.py
Function: json
    @property
    def json(self):
        return to_json({
            'name': self.name,
            'slug': self.slug,
            'logo_url': self.logo_url,
            'view_url': self.view_url,
        })

Example 17

Project: mootiro-maps Source File: views.py
Function: search_by_name
def search_by_name(request):
    term = request.GET.get('term', '')
    orgs = Organization.objects.filter(Q(name__icontains=term) |
        Q(slug__icontains=term))
    d = [{'value': o.id, 'label': o.name} for o in orgs]
    return HttpResponse(to_json(d),
        mimetype="application/x-javascript")

Example 18

Project: mootiro-maps Source File: views.py
def search_tags(request):
    term = request.GET['term']
    qset = TaggedItem.tags_for(Organization).filter(name__istartswith=term
            ).annotate(count=Count('taggit_taggeditem_items__id')
            ).order_by('-count', 'slug')[:10]
    tags = [t.name for t in qset]
    return HttpResponse(to_json(tags),
                mimetype="application/x-javascript")

Example 19

Project: mootiro-maps Source File: views.py
def search_tags(request):
    term = request.GET['term']
    qset = TaggedItem.tags_for(Proposal).filter(name__istartswith=term
            ).annotate(count=Count('taggit_taggeditem_items__id')
            ).order_by('-count', 'slug')[:10]
    tags = [t.name for t in qset]
    return HttpResponse(to_json(tags),
                mimetype="application/x-javascript")

Example 20

Project: mootiro-maps Source File: relations_tags.py
@register.inclusion_tag('relations/edit.html', takes_context=True)
def edit_relations_for(context, obj=None):
    options = Relation.rel_type_options()
    currencies = RelationMetadata.CURRENCIES_CHOICES
    relations = [
        {
            "id": rel['id'],
            "direction": rel['direction'],
            "rel_type": rel['rel_type'],
            "target_oid": rel['target_oid'],
            "target_name": rel['target'].name,
            "metadata": rel['metadata']
        }
        for rel in Relation.relations_for(obj)]
    oid = Relation.build_oid(obj)
    return {"options": options, "currencies": currencies, "relations": to_json(relations), "oid": oid}

Example 21

Project: mootiro-maps Source File: views.py
def search_relations(request):
    term = request.GET.get('term', '')
    raw_results = search_by_term(term)
    results = [{'label': item['name'], 'value': item['id']} for item in raw_results]
    return HttpResponse(to_json(results),
                        mimetype="application/x-javascript")

Example 22

Project: mootiro-maps Source File: models.py
Function: instances
    @instances.setter
    def instances(self, instances):
        self._names = to_json([i.name for i in instances])
        keys = []
        for i in instances:
            if type(i) == Resource:
                key = i.id
            elif type(i) == Proposal:
                key = i.number
            else:
                key = i.slug
            keys.append(key)
        self._keys = to_json(keys)
        self._links = to_json([i.view_url for i in instances])

Example 23

Project: mootiro-maps Source File: models.py
Function: users
    @users.setter
    def users(self, l):
        try:
            self._users = to_json([user.name for user in l])
            self._user_ids = to_json([user.id for user in l])
        except:
            # dont know what to do =/
            pass

Example 24

Project: mootiro-maps Source File: models.py
Function: push_user
    def push_user(self, u):
        try:
            names = simplejson.loads(self._users)
            ids = simplejson.loads(self._user_ids)
            names.insert(0, u.name)
            ids.insert(0, u.id)
            self._users = to_json(names)
            self._user_ids = to_json(ids)
        except:
            pass

Example 25

Project: mootiro-maps Source File: views.py
Function: url_info
def url_info(request):
    url = request.POST.get('video_url', None)
    if url:
        video_, success = get_video_info_from_url(url)
    else:
        video_ = None
        success = False
    return HttpResponse(to_json({'success': success, 'video': video_}),
                        mimetype="application/x-javascript")

Example 26

Project: mootiro-maps Source File: views.py
Function: profile
@render_to('authentication/profile.html')
def profile(request, id=''):
    logger.debug('id : {}'.format(id))
    if not id:
        if request.user.is_authenticated():
            user = request.user
        else:
            return redirect(reverse('user_login'))
    else:
        user = get_object_or_404(User, id=id)

    geojson = create_geojson([user], convert=False, discard_empty=True)
    if geojson:
        geojson['features'][0]['properties']['image'] = '/static/img/user.png'
        geojson = to_json(geojson)

    filters = request.GET.get('filters', [])
    if filters:
        filters = filters.split(',')
    if filters:
        query_set = Update.objects.filter(object_type__in=filters)
    else:
        query_set = Update.objects.all()

    reg = r'[^0-9]%d[^0-9]' % user.id
    query_set = query_set.filter(_user_ids__regex=reg).order_by('-date')
    updates_page = paginated_query(query_set, request, size=10)

    return dict(user_profile=user, geojson=geojson, updates_page=updates_page)

Example 27

Project: mootiro-maps Source File: views.py
@render_to('authentication/profile_update.html')
@login_required
def profile_update(request):
    signatures = []
    for sig in Signature.objects.filter(user=request.user):
        try:
            ct = ContentType.objects.get_for_id(sig.content_type_id)
            obj = ct.get_object_for_this_type(pk=sig.object_id)

            signatures.append({
                'signature_id': sig.id,
                'obj_name': getattr(obj, 'name', '') or getattr(
                                    obj, 'title', ''),
                'obj_id': obj.id,
                'model_name': ct.name,
                'app_name': ct.app_label,
                'permalink': obj.view_url,
                'has_geojson': not 'EMPTY' in getattr(
                                    obj, 'geometry', 'EMPTY'),
            })
        except:
            # signature for an object that cannot be found (probably deleted)
            sig.delete()

    digest_obj = DigestSignature.objects.filter(user=request.user)
    digest = digest_obj[0].digest_type if digest_obj.count() \
                  else 'N'
    form_profile = FormProfile(instance=request.user)
    geojson = create_geojson([request.user], convert=False)
    geojson['features'][0]['properties']['image'] = '/static/img/me.png'
    geojson = to_json(geojson)
    return dict(signatures=signatures, form_profile=form_profile,
                digest=digest, geojson=geojson)

Example 28

Project: mootiro-maps Source File: views.py
@login_required
@ajax_form('community/edit.html', CommunityForm)
def edit_community(request, id='', *args, **kwargs):
    community = get_object_or_404(Community, pk=id) if id else Community()

    geojson = create_geojson([community], convert=False)
    if geojson and geojson.get('features'):
        geojson['features'][0]['properties']['userCanEdit'] = True
    geojson = to_json(geojson)

    def on_get(request, form_community):
        return CommunityForm(instance=community)

    def on_after_save(request, obj):
        versionate(request.user, obj)
        url = reverse('view_community', args=(obj.id,))
        return {'redirect': url}

    return {'on_get': on_get, 'on_after_save': on_after_save,
            'community': community, 'geojson': geojson}

Example 29

Project: mootiro-maps Source File: helpers.py
def set_geometria(obj):
    gd = obj.row_dict['Geometria']
    point = gd.get('Ponto')
    point_as_area = gd.get('Ponto como área')
    from_kml = gd.get('Identificador do polígono (KML)') if obj.kml_dicts else None

    num_geometries = len([v for v in [point, point_as_area, from_kml] if v])
    if num_geometries == 0:
        return  # nothing to do!
    if num_geometries > 1:
        msg = 'Mais de uma geometria definida. Defina somente a coluna "Ponto",'\
              'ou "Ponto como Área", ou "Identificador do polígono (KML)"'
        obj.errors.append(msg)

    geodict = {
        'type': 'GeometryCollection',
        'geometries': []
    }

    try:
        if point:
            # FIXME: correct order is lat, lng. Before fixing must adjust the
            #        both in DB and in the map.
            lng, lat = point.split(',')
            lat, lng = float(lat), float(lng)
            coords = [[lat, lng]]
            geodict['geometries'] = [{
                'type': 'MultiPoint',
                'coordinates': coords
            }]
        elif point_as_area:
            dt = 0.0005
            lat, lng = point_as_area.split(',')
            lat, lng = float(lat), float(lng)
            # FIXME: correct order is lat, lng. Before fixing must adjust the
            #        both in DB and in the map.
            aux = lng
            lng = lat
            lat = aux
            coords = [[[lat + dt, lng + dt], [lat + dt, lng - dt],
                       [lat - dt, lng - dt], [lat - dt, lng + dt],
                       [lat + dt, lng + dt]]]  # closes polygon
            geodict['geometries'] = [{
                'type': 'Polygon',
                'coordinates': coords
            }]
        elif from_kml:  # Polygon or MultiLineString
            found = False
            for kd in obj.kml_dicts:
                if from_kml == kd['Identificador do polígono']:
                    found = True
                    if 'type' in kd['Geometria'] and \
                            kd['Geometria']['type'] == 'GeometryCollection':

                        if kd['Geometria']['geometries'][0]['type'] == 'LineString':
                            # we got geometry collection with some linestrings
                            # lets crate a `MultiLineString` geometry
                            coords = [geom['coordinates']
                                        for geom in kd['Geometria']['geometries']]
                            geodict['geometries'] = [{
                                'type': 'MultiLineString',
                                'coordinates': coords  # put many linestrings together
                            }]
                        else:
                            # if we dont got linestrings, assume that this is a polygon
                            coords = [geom['coordinates'][0]
                                        for geom in kd['Geometria']['geometries']]
                            geodict['geometries'] = [{
                                'type': 'Polygon',
                                'coordinates': coords  # put many polygons together
                            }]
                    else:  # only 1 polygon
                        geodict['geometries'] = [kd['Geometria']['geometry']]

                    # FIXME: correct order is lat, lng. Before fixing must adjust
                    #        both in DB and in the map.
                    def fixcoords(data):
                        if isinstance(data, list) and isinstance(data[0], float):
                            # swap coords and chomp possible z axis.
                            return [data[1], data[0]]
                        if isinstance(data, list):
                            for i in range(len(data)):
                                data[i] = fixcoords(data[i])
                        if isinstance(data, dict):
                            for k, v in data.items():
                                data[k] = fixcoords(v)
                        return data

                    geodict = fixcoords(geodict)

                    break
            if not found:
                msg = 'Identificador do polígono não encontrado: {}'.format(from_kml)
                obj.errors.append(msg)
                return

        g = GeoRefModel()
        geojson = to_json(geodict)
        g.geometry = geojson
        obj.object_dict['geometry'] = geojson
        obj.object_dict['geometry_preview'] = point or point_as_area or from_kml or ''

    except ValueError:
        msg = 'Dado de geometria não é um número válido.'
        obj.errors.append(msg)

    except OGRException:
        msg = 'Má formação da(s) coluna(s) de geometria.'
        obj.errors.append(msg)

    except GEOSException:
        msg = 'Informação geométrica inconsistente.'
        obj.errors.append(msg)

Example 30

Project: mootiro-maps Source File: models.py
def get_models_json(all=True):
    return to_json([{'type': model.__name__,
                    'appLabel': model._meta.app_label,
                    'modelName': model.__name__,
                    'disabled': not model.get_map_attr('editable'),
                    'title': model.get_map_attr('title') or '{}'.format(model.__name__),
                    'tooltip': model.get_map_attr('tooltip') or 'Add {}'.format(model.__name__),
                    'backgroundColor': model.get_map_attr('background_color'),
                    'backgroundOpacity': model.get_map_attr('background_opacity'),
                    'borderColor': model.get_map_attr('border_color'),
                    'borderOpacity': model.get_map_attr('border_opacity'),
                    'borderSize': model.get_map_attr('border_size'),
                    'borderSizeHover': model.get_map_attr('border_size_hover'),
                    'geometryTypes': model.get_map_attr('geometries'),
                    'categories': model.get_map_attr('categories'),
                    'formUrl': reverse(model.get_map_attr('form_view_name'),
                        args=model.get_map_attr('form_view_args'),
                        kwargs=model.get_map_attr('form_view_kwargs'))
                                if model.get_map_attr('editable') else '',
                    'minZoomGeometry': model.get_map_attr('min_zoom_geometry'),
                    'maxZoomGeometry': model.get_map_attr('max_zoom_geometry'),
                    'minZoomPoint': model.get_map_attr('min_zoom_point'),
                    'maxZoomPoint': model.get_map_attr('max_zoom_point'),
                    'minZoomIcon': model.get_map_attr('min_zoom_icon'),
                    'maxZoomIcon': model.get_map_attr('max_zoom_icon'),
                    'zIndex': model.get_map_attr('zindex'),
                    } for model in (get_models() if all else get_editable_models())])

Example 31

Project: mootiro-maps Source File: komoo_map_tags.py
@register.inclusion_tag('komoo_map/map_templatetag.html',
                        takes_context=True)
def komoo_map(context, geojson={}, arg1='', arg2='', arg3='', arg4='',
              arg5='', arg6='', arg7='', arg8='', arg9='', arg10=''):
    """
    The syntax:
        {% komoo_map <geojson> [<project_id>] [type] [<width>] [<height>]
        [<zoom>] [panel] [ajax] [lazy] [edit_button] [maptype] %}
    """
    if isinstance(arg1, int):
        arg1 = 'project={}'.format(arg1)
    parsed_args = _parse_args(arg1, arg2, arg3, arg4, arg5, arg6, arg7,
                              arg8, arg9, arg10)
    type = parsed_args.get('type', 'main')
    width = parsed_args.get('width', '200')
    height = parsed_args.get('height', '200')
    zoom = parsed_args.get('zoom', 16)
    project = parsed_args.get('project', None)
    panel = parsed_args.get('panel', ('komoo_map/panel.html' if not type in
                                      ('preview', 'tooltip', 'view') else ''))
    ajax = parsed_args.get('ajax', 'True').lower() != 'false'
    lazy = parsed_args.get('lazy', 'False').lower() != 'false'
    edit_button = parsed_args.get('edit_button', 'False').lower() != 'false'
    maptype = parsed_args.get('maptype', 'clean')

    editable = type in ('main', 'editor')
    if geojson:
        geojson_dict = json.loads(geojson)
        for feature in geojson_dict.get('features', []):
            if 'properties' in feature and editable:
                feature['properties']['alwaysVisible'] = True
        geojson = to_json(geojson_dict)

    if not width.endswith('%') and not width.endswith('px'):
        width = width + 'px'
    if not height.endswith('%') and not height.endswith('px'):
        height = height + 'px'

    if getattr(settings, 'KOMOO_DISABLE_MAP', False):
        type = 'disabled'

    return dict(type=type, width=width, height=height, zoom=zoom, panel=panel,
                lazy=lazy, geojson=geojson, edit_button=edit_button,
                project=project, ajax=ajax, editable=editable, maptype=maptype,
                feature_types_json=get_models_json(),
                STATIC_URL=settings.STATIC_URL,
                LANGUAGE_CODE=settings.LANGUAGE_CODE)

Example 32

Project: mootiro-maps Source File: views.py
Function: layers
def layers(request):
    '''Default layers'''
    return HttpResponse(
        to_json(default_layers()),
        mimetype="application/x-javascript")

Example 33

Project: mootiro-maps Source File: models.py
Function: json
    @property
    def json(self):
        return to_json(self.to_dict())

Example 34

Project: mootiro-maps Source File: views.py
Function: project_edit
@login_required
@ajax_form('project/edit.html', FormProject)
def project_edit(request, id='', *arg, **kwargs):
    project = get_object_or_404(Project, pk=id)

    layers = to_json(project.layers)

    if not project.user_can_edit(request.user):
        return redirect(project.view_url)

    def on_get(request, form):
        form = FormProject(instance=project)
        form.helper.form_action = reverse('project_edit',
                                          kwargs={'id': project.id})
        return form

    def on_after_save(request, obj):
        # add user who edited as contributor.
        obj.contributors.add(request.user)
        versionate(request.user, obj)
        return {'redirect': obj.view_url}

    return {'on_get': on_get, 'on_after_save': on_after_save,
            'project': project, 'layers': layers}

Example 35

Project: mootiro-maps Source File: views.py
Function: edit_resource
@login_required
@ajax_form('resource/edit.html', FormResourceGeoRef, 'form_resource')
def edit_resource(request, id='', *arg, **kwargs):
    resource = get_object_or_None(Resource, pk=id)
    geojson = create_geojson([resource], convert=False)

    if geojson and geojson.get('features'):
        geojson['features'][0]['properties']['userCanEdit'] = True
    geojson = to_json(geojson)

    def on_get(request, form):
        form = FormResourceGeoRef(instance=resource)
        form.helper.form_action = reverse('edit_resource',
                                          kwargs={'id': id})

        return form

    def on_after_save(request, obj):
        versionate(request.user, obj)
        return {'redirect': obj.view_url}

    return {'on_get': on_get, 'on_after_save': on_after_save,
            'geojson': geojson, 'resource': resource}

Example 36

Project: mootiro-maps Source File: views.py
@cache_page(54000)
def get_geojson(request):
    """View used by the map javascript to fetch geojson data for each map tile.

    This view receives some parameters via GET request and returns a geojson
    reponse.

    Params:
        bounds: string of the form "lat_lo,lng_lo,lat_hi,lng_hi", where "lo"
            corresponds to the southwest corner of the bounding box,
            while "hi" corresponds to the northeast corner of that box.
        zoom: the map zoom level.
        models: a list of model to filter, separated by comma, of the form
            "app_name.ModelNamel".
        project - the id of the the project with which the filtered objects
            should have ralations. (Optional)

    """
    bounds = request.GET.get('bounds', None)
    zoom = int(request.GET.get('zoom', 13))
    models = request.GET.get('models', '')
    project = request.GET.get('project', None)

    if not bounds and not project:
        return HttpResponseBadRequest(to_json({'error': 'Invalid query'}),
                                      mimetype="application/x-javascript")

    if bounds:
        x1, y2, x2, y1 = [float(i) for i in bounds.split(',')]
        polygon = Polygon(((x1, y1), (x1, y2), (x2, y2), (x2, y1), (x1, y1)))

        intersects_polygon = (Q(points__intersects=polygon) |
                              Q(lines__intersects=polygon) |
                              Q(polys__intersects=polygon))
    else:
        intersects_polygon = Q()

    models = [cache.get_model(*m.split('.')) for m in models.split(',') if m]
    d = _fetch_geo_objects(intersects_polygon, zoom, models, project)
    l = []
    for objs in d.values():
        l.extend(objs)
    geojson = create_geojson(l)
    return HttpResponse(to_json(geojson),
                        mimetype="application/x-javascript")

Example 37

Project: mootiro-maps Source File: views.py
@login_required
@ajax_form('need/edit.html', NeedFormGeoRef)
def edit_need(request, id=""):
    need = get_object_or_404(Need, pk=id)

    geojson = create_geojson([need], convert=False)
    if geojson and geojson.get('features'):
        geojson['features'][0]['properties']['userCanEdit'] = True
    geojson = to_json(geojson)

    def on_get(request, form):
        form = NeedFormGeoRef(instance=need)
        form.helper.form_action = reverse('edit_need', kwargs={'id': id})
        return form

    def on_after_save(request, need):
        versionate(request.user, need)
        redirect_url = reverse('view_need', kwargs={'id': need.pk})
        return {'redirect': redirect_url}

    return {'on_get': on_get, 'on_after_save': on_after_save,
            'geojson': geojson, 'need': need}

Example 38

Project: mootiro-maps Source File: views.py
@login_required
@ajax_form('organization/edit.html', FormOrganizationGeoRef,
           'form_organization')
def edit_organization(request, id='', *arg, **kwargs):
    organization = get_object_or_None(Organization, pk=id) or Organization()

    geojson = create_geojson([organization], convert=False)
    if geojson and geojson.get('features'):
        geojson['features'][0]['properties']['userCanEdit'] = True
    geojson = to_json(geojson)

    def on_get(request, form):
        form = FormOrganizationGeoRef(instance=organization)
        form.helper.form_action = reverse('edit_organization',
                                          kwargs={'id': organization.id})
        return form

    def on_after_save(request, obj):
        versionate(request.user, obj)
        return {'redirect': reverse('view_organization',
                                    kwargs={'id': obj.id})}

    return {'on_get': on_get, 'on_after_save': on_after_save,
            'geojson': geojson, 'organization': organization}

Example 39

Project: mootiro-maps Source File: models.py
Function: communities
    @communities.setter
    def communities(self, l):
        self._communities_names = to_json([c.name for c in l])
        self._communities_slugs = to_json([c.slug for c in l])

Example 40

Project: mootiro-maps Source File: views.py
def youtube_info(request, video_id=None):
    info, success = get_youtube_video_info(video_id)
    return HttpResponse(to_json(info),
                        mimetype="application/x-javascript")