def copy_design(request, uid): try: design_obj = get_feature_by_uid(uid) except Feature.DoesNotExist: raise Http404 #check permissions viewable, response = design_obj.is_viewable(request.user) if not viewable: return response design_obj.pk = None design_obj.user = request.user design_obj.save() json = [] json.append({ 'id': design_obj.id, 'uid': design_obj.uid, 'name': design_obj.name, 'description': design_obj.description, 'attributes': design_obj.serialize_attributes }) return HttpResponse(dumps(json), status=200)
def overlap_geotiff(collection_uids, user=None): collections = [get_feature_by_uid(x) for x in collection_uids.split(',')] collections = [ x for x in collections if x.__class__ in get_collection_models() ] if len(collections) < 1: raise Http404 filenames = [] for collection in collections: viewable, response = collection.is_viewable(user) if user and not viewable: return response fs = collection.feature_set(recurse=True) poly_fs = [x for x in fs if isinstance(x, PolygonFeature)] unique_types = list(set([x.__class__ for x in poly_fs])) for model in unique_types: responder = ShpResponder( model.objects.filter( pk__in=[x.pk for x in poly_fs if x.__class__ == model])) responder.geo_field = 'geometry_final' fn = responder('return_file_not_response') filenames.append(fn) temp_geotiff = create_heatmap(filenames) return temp_geotiff
def copy_design(request, uid): try: design_obj = get_feature_by_uid(uid) except Feature.DoesNotExist: raise Http404 #check permissions viewable, response = design_obj.is_viewable(request.user) if not viewable: return response design_obj.pk = None design_obj.user = request.user design_obj.save() json = [] json.append({ 'id': design_obj.id, 'uid': design_obj.uid, 'name': design_obj.name, 'description': design_obj.description, 'attributes': design_obj.serialize_attributes }) return HttpResponse(dumps(json), status=200)
def get_object_for_editing(request, uid, target_klass=None): """ Return the specified instance by uid for editing. If a target_klass is provided, uid will be checked for consistency. If the request has no logged-in user, a 401 Response will be returned. If the item is not found, a 404 Response will be returned. If the user is not authorized to edit the item (not the owner or a staff user), a 403 Not Authorized Response will be returned. usage: instance = get_object_for_editing(request, 'mlpa_mpa_12', target_klass=Mpa) if isinstance(instance, HttpResponse): return instance """ if target_klass and not target_klass.model_uid() in uid: return HttpResponse( "Target class %s doesn't match the provided uid %s" % (target_klass, uid), status=401) try: instance = get_feature_by_uid(uid) except ValueError: return HttpResponse("Uid not valid: %s" % uid, status=401) except: return HttpResponse("Feature not found - %s" % uid, status=404) if not request.user.is_authenticated(): return HttpResponse('You must be logged in.', status=401) # Check that user owns the object or is staff if not request.user.is_staff and request.user != instance.user: return HttpResponseForbidden( 'You do not have permission to modify this object.') return instance
def get_object_for_editing(request, uid, target_klass=None): """ Return the specified instance by uid for editing. If a target_klass is provided, uid will be checked for consistency. If the request has no logged-in user, a 401 Response will be returned. If the item is not found, a 404 Response will be returned. If the user is not authorized to edit the item (not the owner or a staff user), a 403 Not Authorized Response will be returned. usage: instance = get_object_for_editing(request, 'mlpa_mpa_12', target_klass=Mpa) if isinstance(instance, HttpResponse): return instance """ if target_klass and not target_klass.model_uid() in uid: return HttpResponse("Target class %s doesn't match the provided uid %s" % (target_klass, uid), status=401) try: instance = get_feature_by_uid(uid) except ValueError: return HttpResponse("Uid not valid: %s" % uid, status=401) except: return HttpResponse("Feature not found - %s" % uid, status=404) if not request.user.is_authenticated(): return HttpResponse('You must be logged in.', status=401) # Check that user owns the object or is staff if not request.user.is_staff and request.user != instance.user: return HttpResponseForbidden( 'You do not have permission to modify this object.') return instance
def get_data_for_feature(user, uid): try: f = get_feature_by_uid(uid) except: return False, HttpResponse("Feature %s does not exist" % uid, status=404) viewable, response = f.is_viewable(user) if not viewable: return viewable, response features = [] collections = [] if isinstance(f, FeatureCollection): obj_id = f.pk ct = ContentType.objects.get_for_model(f.__class__) for fmodel in get_feature_models(): unattached = list( fmodel.objects.filter(content_type=ct, object_id=obj_id)) features.extend(unattached) for cmodel in get_collection_models(): collections_top = list( cmodel.objects.filter(content_type=ct, object_id=obj_id)) collections.extend(collections_top) elif isinstance(f, Feature): features.append(f) return features, collections
def get_object_for_viewing(request, uid, target_klass=None): """ Return the specified instance by uid for viewing. If a target_klass is provided, uid will be checked for consistency. If the request has no authenticated user, a 401 Response will be returned. If the item is not found, a 404 Response will be returned. If the user is not authorized to view the item (not the owner or part of a group the item is shared with), a 403 Not Authorized Response will be returned. usage: instance = get_object_for_viewing(request, 'mlpa_mpa_12', target_klass=Mpa) if isinstance(instance, HttpResponse): return instance """ if target_klass and not target_klass.model_uid() in uid: return HttpResponse("Target class %s doesn't match the provided uid %s" % (target_klass, uid), status=401) try: instance = get_feature_by_uid(uid) except ValueError: return HttpResponse("Uid not valid: %s" % uid, status=401) except: return HttpResponse("Feature not found - %s" % uid, status=404) viewable, response = instance.is_viewable(request.user) if viewable: return instance else: return response
def get_data_for_feature(user, uid): try: f = get_feature_by_uid(uid) except: return False, HttpResponse("Feature %s does not exist" % uid, status=404) viewable, response = f.is_viewable(user) if not viewable: return viewable, response features = [] collections = [] if isinstance(f, FeatureCollection): obj_id = f.pk ct = ContentType.objects.get_for_model(f.__class__) for fmodel in get_feature_models(): unattached = list(fmodel.objects.filter(content_type=ct,object_id=obj_id)) features.extend(unattached) for cmodel in get_collection_models(): collections_top = list(cmodel.objects.filter(content_type=ct,object_id=obj_id)) collections.extend(collections_top) elif isinstance(f, Feature): features.append(f) return features, collections
def get_object_for_viewing(request, uid, target_klass=None): """ Return the specified instance by uid for viewing. If a target_klass is provided, uid will be checked for consistency. If the request has no authenticated user, a 401 Response will be returned. If the item is not found, a 404 Response will be returned. If the user is not authorized to view the item (not the owner or part of a group the item is shared with), a 403 Not Authorized Response will be returned. usage: instance = get_object_for_viewing(request, 'mlpa_mpa_12', target_klass=Mpa) if isinstance(instance, HttpResponse): return instance """ if target_klass and not target_klass.model_uid() in uid: return HttpResponse( "Target class %s doesn't match the provided uid %s" % (target_klass, uid), status=401) try: instance = get_feature_by_uid(uid) except ValueError: return HttpResponse("Uid not valid: %s" % uid, status=401) except: return HttpResponse("Feature not found - %s" % uid, status=404) viewable, response = instance.is_viewable(request.user) if viewable: return instance else: return response
def bioconnect(request, uid): try: feature = get_feature_by_uid(uid) except: raise Http404("UID %s does not exist" % uid) fgeom = feature.output_geom if not fgeom.valid: fgeom = fgeom.buffer(0) hits = [] for mb in MyBioregion.objects.filter(output_geom__bboverlaps=fgeom): mbgeom = mb.output_geom if not mbgeom.valid: mbgeom = mbgeom.buffer(0) if mbgeom.intersects(fgeom): hits.append(mb) for d in DrawnBioregion.objects.filter(geometry_final__bboverlaps=fgeom): dgeom = d.output_geom if not dgeom.valid: dgeom = dgeom.buffer(0) if dgeom.intersects(fgeom): hits.append(d) context = {"hits": hits} return render_to_response("bioconnect.html", RequestContext(request, context))
def bioconnect(request, uid): try: feature = get_feature_by_uid(uid) except: raise Http404('UID %s does not exist' % uid) fgeom = feature.output_geom if not fgeom.valid: fgeom = fgeom.buffer(0) hits = [] for mb in MyBioregion.objects.filter(output_geom__bboverlaps=fgeom): mbgeom = mb.output_geom if not mbgeom.valid: mbgeom = mbgeom.buffer(0) if mbgeom.intersects(fgeom): hits.append(mb) for d in DrawnBioregion.objects.filter(geometry_final__bboverlaps=fgeom): dgeom = d.output_geom if not dgeom.valid: dgeom = dgeom.buffer(0) if dgeom.intersects(fgeom): hits.append(d) context = { 'hits': hits, } return render_to_response('bioconnect.html', RequestContext(request, context))
def get_bioregion(uid): ''' Gets the bioregions instance for a given uid ''' try: return get_feature_by_uid(uid) except: raise Http404('UID %s does not exist' % uid)
def get_bioregion(uid): ''' Gets the bioregions instance for a given uid ''' try: return get_feature_by_uid(uid) except: raise Http404('UID %s does not exist' % uid)
def get_features(uids, user): """ Returns list of tuples representing mapnik layers Tuple => (model_class, [pks]) Note: currently just a single pk per 'layer' which is incredibly inefficient but the only way to ensure proper layer ordering (??). features = [ (Mpa, [49, 50]), (Pipeline, [32, 31]), (Shipwreck, [32, 31]) ] """ feature_models = get_feature_models() collection_models = get_collection_models() features = [] # list of tuples => (model, [pks]) for uid in uids: log.debug("processing uid %s" % uid) applabel, modelname, pk = uid.split('_') model = get_model_by_uid("%s_%s" % (applabel, modelname)) feature = get_feature_by_uid(uid) if user: viewable, response = feature.is_viewable(user) if not viewable: continue if model in collection_models: collection = get_feature_by_uid(uid) if user: viewable, response = collection.is_viewable(user) if not viewable: continue all_children = collection.feature_set(recurse=True) children = [ x for x in all_children if x.__class__ in feature_models ] for child in children: features.append((child.__class__, [child.pk])) else: features.append((model, [int(pk)])) return features
def get_attributes(request, uid): try: scenario_obj = get_feature_by_uid(uid) except Scenario.DoesNotExist: raise Http404 #check permissions viewable, response = scenario_obj.is_viewable(request.user) if not viewable: return response return HttpResponse(dumps(scenario_obj.serialize_attributes))
def get_attributes(request, uid): try: scenario_obj = get_feature_by_uid(uid) except Scenario.DoesNotExist: raise Http404 #check permissions viewable, response = scenario_obj.is_viewable(request.user) if not viewable: return response return HttpResponse(dumps(scenario_obj.serialize_attributes))
def get_features(uids,user): """ Returns list of tuples representing mapnik layers Tuple => (model_class, [pks]) Note: currently just a single pk per 'layer' which is incredibly inefficient but the only way to ensure proper layer ordering (??). features = [ (Mpa, [49, 50]), (Pipeline, [32, 31]), (Shipwreck, [32, 31]) ] """ feature_models = get_feature_models() collection_models = get_collection_models() features = [] # list of tuples => (model, [pks]) for uid in uids: log.debug("processing uid %s" % uid) applabel, modelname, pk = uid.split('_') model = get_model_by_uid("%s_%s" % (applabel,modelname)) feature = get_feature_by_uid(uid) if user: viewable, response = feature.is_viewable(user) if not viewable: continue if model in collection_models: collection = get_feature_by_uid(uid) if user: viewable, response = collection.is_viewable(user) if not viewable: continue all_children = collection.feature_set(recurse=True) children = [x for x in all_children if x.__class__ in feature_models] for child in children: features.append((child.__class__,[child.pk])) else: features.append((model,[int(pk)])) return features
def remove_bookmark(request): try: bookmark_uid = request.POST['uid'] bookmark = get_feature_by_uid(bookmark_uid) viewable, response = bookmark.is_viewable(request.user) if not viewable: return response bookmark.delete() return HttpResponse(status=200) except: return HttpResponse(status=304)
def delete_drawing(request, uid): try: drawing_obj = get_feature_by_uid(uid) except Feature.DoesNotExist: raise Http404 #check permissions viewable, response = drawing_obj.is_viewable(request.user) if not viewable: return response drawing_obj.delete() return HttpResponse("", status=200)
def delete_drawing(request, uid): try: drawing_obj = get_feature_by_uid(uid) except Feature.DoesNotExist: raise Http404 #check permissions viewable, response = drawing_obj.is_viewable(request.user) if not viewable: return response drawing_obj.delete() return HttpResponse("", status=200)
def share_design(request): from django.contrib.auth.models import Group group_names = request.POST.getlist('groups[]') design_uid = request.POST['scenario'] design = get_feature_by_uid(design_uid) viewable, response = design.is_viewable(request.user) if not viewable: return response #remove previously shared with groups, before sharing with new list design.share_with(None) groups = [] for group_name in group_names: groups.append(Group.objects.get(name=group_name)) design.share_with(groups, append=False) return HttpResponse("", status=200)
def delete_scenario(request, uid): try: scenario_obj = get_feature_by_uid(uid) except Scenario.DoesNotExist: raise Http404 #check permissions viewable, response = scenario_obj.is_viewable(request.user) if not viewable: return response scenario_obj.active = False scenario_obj.save(rerun=False) return HttpResponse("", status=200)
def share_design(request): from django.contrib.auth.models import Group group_names = request.POST.getlist('groups[]') design_uid = request.POST['scenario'] design = get_feature_by_uid(design_uid) viewable, response = design.is_viewable(request.user) if not viewable: return response #remove previously shared with groups, before sharing with new list design.share_with(None) groups = [] for group_name in group_names: groups.append(Group.objects.get(name=group_name)) design.share_with(groups, append=False) return HttpResponse("", status=200)
def delete_design(request, uid): try: design_obj = get_feature_by_uid(uid) except Feature.DoesNotExist: raise Http404 #check permissions viewable, response = design_obj.is_viewable(request.user) if not viewable: return response design_obj.delete() #design_obj.active = False #design_obj.save(rerun=False) return HttpResponse("", status=200)
def delete_design(request, uid): try: design_obj = get_feature_by_uid(uid) except Feature.DoesNotExist: raise Http404 #check permissions viewable, response = design_obj.is_viewable(request.user) if not viewable: return response design_obj.delete() #design_obj.active = False #design_obj.save(rerun=False) return HttpResponse("", status=200)
def copy_design(request, uid): try: design_obj = get_feature_by_uid(uid) except Feature.DoesNotExist: raise Http404 #check permissions viewable, response = design_obj.is_viewable(request.user) if not viewable: return response design_obj.pk = None design_obj.user = request.user design_obj.save() return HttpResponse("", status=200)
def storyconnect(request, uid): try: feature = get_feature_by_uid(uid) except: raise Http404("UID %s does not exist" % uid) fgeom = feature.output_geom if not fgeom.valid: fgeom = fgeom.buffer(0) hits = [] for s in StoryPoint.objects.filter(geometry_final__bboverlaps=fgeom): sgeom = s.geometry_final if sgeom.intersects(fgeom): hits.append(s) context = {"hits": hits} return render_to_response("storyconnect.html", RequestContext(request, context))
def share_bookmark(request): group_names = request.POST.getlist('groups[]') bookmark_uid = request.POST['bookmark'] bookmark = get_feature_by_uid(bookmark_uid) viewable, response = bookmark.is_viewable(request.user) if not viewable: return response #remove previously shared with groups, before sharing with new list bookmark.share_with(None) groups = [] for group_name in group_names: groups.append(Group.objects.get(name=group_name)) bookmark.share_with(groups, append=False) return HttpResponse("", status=200)
def storyconnect(request, uid): try: feature = get_feature_by_uid(uid) except: raise Http404('UID %s does not exist' % uid) fgeom = feature.output_geom if not fgeom.valid: fgeom = fgeom.buffer(0) hits = [] for s in StoryPoint.objects.filter(geometry_final__bboverlaps=fgeom): sgeom = s.geometry_final if sgeom.intersects(fgeom): hits.append(s) context = { 'hits': hits, } return render_to_response('storyconnect.html', RequestContext(request, context))
def overlap_geotiff(collection_uids, user=None): collections = [get_feature_by_uid(x) for x in collection_uids.split(',')] collections = [x for x in collections if x.__class__ in get_collection_models()] if len(collections) < 1: raise Http404 filenames = [] for collection in collections: viewable, response = collection.is_viewable(user) if user and not viewable: return response fs = collection.feature_set(recurse=True) poly_fs = [x for x in fs if isinstance(x,PolygonFeature)] unique_types = list(set([x.__class__ for x in poly_fs])) for model in unique_types: responder = ShpResponder(model.objects.filter(pk__in=[x.pk for x in poly_fs if x.__class__ == model])) responder.geo_field = 'geometry_final' fn = responder('return_file_not_response') filenames.append(fn) temp_geotiff = create_heatmap(filenames) return temp_geotiff