def perform_payment(request, order_id: int):
try:
_data = serializers.parse_raw_data(request.body)
except:
# TODO
return HttpResponseServerError("cant deserialize")
serializer = serializers.UserDetailsSerializer(
data=_data
)
if not serializer.is_valid():
# TODO
return HttpResponseServerError("cant parse user detail")
user_details = serializer.save()
if user_details.cardAuthorizationInfo != dto.CardAuthorizationInfo.AUTHORIZED.value:
# TODO
return HttpResponseServerError("un auth")
if PaymentInfo.objects.filter(order_id=order_id).exists():
# TODO
return HttpResponseServerError("payment exist")
# TODO need to check order id status and check existing order id in order-service
payment_info = PaymentInfo(order_id=order_id, paymentStatus=PaymentStatus.PAYING)
payment_info.save()
return JsonResponse(
dto.OrderId(
id=payment_info.id
).dict()
)
def _render_get_lesson_detail(request, lesson):
try:
workflow, created = _ensure_workflow(request, lesson)
except ModuleVersion.DoesNotExist:
return HttpResponseServerError('initial_json asks for missing module')
except ValueError as err:
return HttpResponseServerError('initial_json has invalid params: '
+ str(err))
modules = visible_modules(request)
init_state = make_init_state(request, workflow=workflow, modules=modules)
init_state['lessonData'] = LessonSerializer(lesson).data
# If we just initialized this workflow, start fetches and render
if created:
_queue_workflow_updates(workflow)
if lesson.course:
course_slug = lesson.course.slug
else:
course_slug = 'None'
server.utils.log_user_event_from_request(
request,
'Start lesson in course %s' % (course_slug)
)
return TemplateResponse(request, 'workflow.html',
{'initState': init_state})
def comment(request):
if request.method != 'POST':
return HttpResponseBadRequest()
if request.user.id is None:
return HttpResponse('User not found')
user = request.user
comment_text = request.POST.get('commentText', None)
post_id = request.POST.get('postId', None)
parent_id = request.POST.get('parentId', None) or None
if comment_text is None: return HttpResponse('Comment is empty')
if post_id is None: return HttpResponse('Post id not found')
try:
Comment.objects.create(
text=comment_text,
creator=User.objects.get(pk=user.id),
parent_id=parent_id,
post=Post.objects.get(pk=post_id),
)
except ObjectDoesNotExist:
return HttpResponseServerError('На сервере произошла ошибка.')
except IntegrityError:
return HttpResponseServerError(
'При сохраненни комментария произошла ошибка.')
return redirect(f'/posts/{post_id}')
def render_to_json(response, *args, **kwargs):
"""
Creates the main structure and returns the JSON response.
"""
# determine the status code
if hasattr(response, 'status_code'):
status_code = response.status_code
elif issubclass(type(response), Http404):
status_code = 404
elif issubclass(type(response), Exception):
status_code = 500
logger.exception(str(response), extra={'request': kwargs.pop('request', None)})
if settings.DEBUG:
import sys
reporter = ExceptionReporter(None, *sys.exc_info())
text = reporter.get_traceback_text()
response = HttpResponseServerError(text, content_type='text/plain')
else:
response = HttpResponseServerError("An error occured while processing an AJAX request.", content_type='text/plain')
else:
status_code = 200
# creating main structure
data = {
'status': status_code,
'statusText': REASON_PHRASES.get(status_code, 'UNKNOWN STATUS CODE'),
'content': response
}
return JSONResponse(data, *args, **kwargs)
def layer_metadata(request, layer_id):
"""request to get layer's xml metadata"""
if request.method != 'GET':
return HttpResponseBadRequest()
if not layer_id:
return HttpResponseBadRequest()
try:
layer = Layer.objects.get(id=layer_id)
base_file, __ = layer.get_base_file()
if not base_file:
return HttpResponseServerError()
base_file_path, __ = os.path.splitext(base_file.file.path)
xml_file_path = base_file_path + '.xml'
if not os.path.exists(xml_file_path):
return HttpResponseServerError()
with open(xml_file_path) as f:
response = HttpResponse(f.read(), content_type='text/xml')
response['Content-Disposition'] = (
'attachment; filename="{filename}.xml"'.format(
filename=base_file_path))
return response
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
def _render_get_lesson_detail(request, lesson):
try:
workflow, created = _ensure_workflow(request, lesson)
except KeyError as err:
return HttpResponseServerError(
"initial_json asks for missing module: %s" % str(err))
except ValueError as err:
return HttpResponseServerError("initial_json has invalid params: " +
str(err))
modules = visible_modules(request)
init_state = make_init_state(request, workflow=workflow, modules=modules)
init_state["lessonData"] = jsonize_lesson(lesson)
# If we just initialized this workflow, start fetches and render
if created:
_queue_workflow_updates(workflow)
if lesson.course:
course_slug = lesson.course.slug
else:
course_slug = "None"
server.utils.log_user_event_from_request(
request, "Start lesson in course %s" % (course_slug))
return TemplateResponse(request, "workflow.html",
{"initState": init_state})
def _wrapper(request, *args, **kwargs):
try:
return fn(request, *args, **kwargs)
except ArgumentError as e:
obj = {u'msg': e.message}
return HttpResponseBadRequest(json.dumps(obj))
except AppNotFoundExp as e:
obj = {u'msg': e.message}
return HttpResponseNotFound(json.dumps(obj))
except DeviceNotFoundExp as e:
obj = {u'msg': e.message}
return HttpResponseNotFound(json.dumps(obj))
except MultiDeviceFoundExp as e:
obj = {u'msg': e.message}
return HttpResponseServerError(json.dumps(obj))
except MultiAppFoundExp as e:
obj = {u'msg': e.message}
return HttpResponseServerError(json.dumps(obj))
except GatewayApiError as e:
obj = {u'msg': e.message}
return HttpResponseServerError(json.dumps(obj))
except GatewayTimeoutError as e:
obj = {u'msg': e.message}
return HttpResponseServerError(json.dumps(obj))
except GatewayCallError as e:
obj = {u'msg': e.message}
return HttpResponseServerError(json.dumps(obj))
def show_metadata(request, *args, **kwargs):
if request.method == 'GET':
csw_url = request.session['csw_url']
user = request.session['user']
password = request.session['password']
layer_id = request.GET['layer_id']
try:
record = csw_query_metadata_by_id(
csw_url,
layer_id,
username=user,
password=password)
context = {
'metadata': record.xml
}
return render(
request,
'geosafe/metasearch/modal/layer_metadata.html',
context)
except BaseException:
return HttpResponseServerError()
return HttpResponseServerError()
def factory_commission_sale(request):
if request.method == 'POST':
form = CommissionSaleForm(request.POST)
try:
if form.is_valid():
product_id = request.POST.get('product', '')
c_type = request.POST.get('c_type', '')
user = request.user
if user.is_anonymous():
return HttpResponseServerError(u'请登陆')
product = Product.objects.get(id=product_id)
unit_price = float(request.POST.get('price', ''))
quantity = request.POST.get('quantity', '')
try:
user_product = UserProduct.objects.get(user=user,
product=product,
trade_type=2)
except:
user_product = UserProduct(user=user,
product=product,
trade_type=2)
user_product.quantity += int(quantity)
user_product.total_buy_quantity += int(quantity)
user_product.can_pickup_quantity += int(quantity)
user_product.overage_unit_price = unit_price
user_product.total = int(quantity) * float(unit_price)
user_product.save()
new_commissiton_sale(product, user, c_type, unit_price,
quantity, quantity, 1)
return HttpResponse('OK')
else:
return HttpResponseServerError(u'信息错误')
except DealException, e:
return HttpResponseServerError(e.value)
except:
def test_request(view: callable,
method='GET',
user: User = SVAnonymousUser,
session_data: dict = None,
url_kwargs: dict = None,
req_kwargs: dict = None,
headers: dict = None,
just_request: bool = False) -> HttpResponse:
"""Wrapper to make test requests easier
Args:
method (str): Request method. Defaults to GET.
user (User): Requesting user. Defaults to SVAnonymousUser.
session_data (dict): Optional dictionary of session data.
url_kwargs (dict): Optional dictionary of URL arguments.
req_kwargs (dict): Optional dictionary of URL Querystrinng arguments.
headers (dict): Optional dictionary of headers.
just_request (bool): Only return the Request. Defaults to False
"""
if url_kwargs is None:
url_kwargs = {}
if req_kwargs is None:
req_kwargs = {}
if headers is None:
headers = {}
factory = RequestFactory()
factory_handler = getattr(factory, method.lower(), None)
if not factory_handler:
return HttpResponseServerError()
# pylint: disable=not-callable
request = factory_handler(view, req_kwargs, **headers)
session = SessionStore()
if session_data:
for key, value in session_data.items():
session[key] = value
# Fix django.contrib.messages.api.MessageFailure
# because this request doesn't have a session or anything
setattr(request, 'session', session)
setattr(request, '_messages', FallbackStorage(request))
if user is SVAnonymousUser:
user = SVAnonymousUser()
request.user = user
if just_request:
return request
try:
return view(request, **url_kwargs)
except Http404:
return HttpResponseNotFound('not found')
else:
return HttpResponseServerError()
def legend(request, layername, layertitle=False, style=None):
"""Get the legend from a layer.
:param layername: The layer name in Geonode.
:type layername: basestring
:param layertitle: Add the layer title in the legend. Default to False.
:type layertitle: bool
:param style: Layer style to choose
:type style: str
:return: The HTTPResponse with a PNG.
"""
layer = get_object_or_404(Layer, name=layername)
qgis_layer = get_object_or_404(QGISServerLayer, layer=layer)
# get default style name
if not style:
# generate style cache
if not qgis_layer.default_style:
try:
style_list(layer, internal=False)
except Exception:
logger.warning("Failed to fetch styles")
# refresh values
qgis_layer.refresh_from_db()
if qgis_layer.default_style:
style = qgis_layer.default_style.name
tiles_directory = QGIS_SERVER_CONFIG['tiles_directory']
legend_path = QGIS_SERVER_CONFIG['legend_path']
legend_filename = legend_path % (qgis_layer.qgis_layer_name, style)
# GOOD -- Verify with normalised version of path
legend_filename = os.path.normpath(legend_filename)
if not legend_filename.startswith(tiles_directory):
return HttpResponseServerError()
if not os.path.exists(legend_filename):
if not os.path.exists(os.path.dirname(legend_filename)):
os.makedirs(os.path.dirname(legend_filename))
url = legend_url(layer, layertitle, style=style, internal=True)
result = cache_request.apply_async((url, legend_filename))
# Attempt to run task synchronously
if not result.get():
# If not succeded, provides error message.
return HttpResponseServerError('Failed to fetch legend.')
if image_format(legend_filename) != 'png':
logger.error('%s is not valid PNG.' % legend_filename)
os.remove(legend_filename)
if not os.path.exists(legend_filename):
return HttpResponse('The legend could not be found.', status=409)
with open(legend_filename, 'rb') as f:
return HttpResponse(f.read(), content_type='image/png')
def download_report(request, analysis_id, data_type='map'):
"""Download the pdf files of the analysis
available options for data_type:
map: only map report
table: only table report
report: only map and table report
all: map, table, and impact layer
:param request:
:param analysis_id:
:param data_type: can be 'map' or 'table'
"""
if request.method != 'GET':
return HttpResponseBadRequest()
try:
analysis = Analysis.objects.get(id=analysis_id)
layer_title = analysis.impact_layer.title
if data_type == 'map':
return serve_files(analysis.report_map.read(), 'application/pdf',
'%s_map.pdf' % layer_title)
elif data_type == 'table':
return serve_files(analysis.report_table.read(), 'application/pdf',
'%s_table.pdf' % layer_title)
elif data_type == 'reports':
tmp = tempfile.mktemp()
with ZipFile(tmp, mode='w') as zf:
zf.writestr('%s_map.pdf' % layer_title,
analysis.report_map.read())
zf.writestr('%s_table.pdf' % layer_title,
analysis.report_table.read())
return serve_files(open(tmp), 'application/zip',
'%s_reports.zip' % layer_title)
elif data_type == 'all':
tmp = tempfile.mktemp()
with ZipFile(tmp, mode='w') as zf:
zf.writestr('%s_map.pdf' % layer_title,
analysis.report_map.read())
zf.writestr('%s_table.pdf' % layer_title,
analysis.report_table.read())
layer = analysis.impact_layer
for layer_file in layer.upload_session.layerfile_set.all():
base_name = os.path.basename(layer_file.file.name)
zf.writestr(base_name.replace(layer.name, layer.title),
layer_file.file.read())
return serve_files(open(tmp), 'application/zip',
'%s_download.zip' % layer_title)
return HttpResponseServerError()
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
def run_git_http(request, obj, path):
"""Git HTTP backend execution wrapper."""
# Find Git HTTP backend
git_http_backend = find_git_http_backend()
if git_http_backend is None:
return HttpResponseServerError('git-http-backend not found')
# Invoke Git HTTP backend
query = request.META.get('QUERY_STRING', '')
process_env = {
'REQUEST_METHOD': request.method,
'PATH_TRANSLATED': os.path.join(obj.full_path, path),
'GIT_HTTP_EXPORT_ALL': '1',
'CONTENT_TYPE': request.META.get('CONTENT_TYPE', ''),
'QUERY_STRING': query,
'HTTP_CONTENT_ENCODING': request.META.get('HTTP_CONTENT_ENCODING', ''),
}
process = subprocess.Popen(
[git_http_backend],
env=process_env,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
output, output_err = process.communicate(request.body)
retcode = process.poll()
# Log error
if output_err:
try:
raise Exception('Git http backend error: {}'.format(
force_text(output_err).splitlines()[0]
))
except Exception as error:
report_error(error, request)
# Handle failure
if retcode:
return HttpResponseServerError(output_err)
headers, content = output.split(b'\r\n\r\n', 1)
message = message_from_string(headers.decode('utf-8'))
# Handle status in response
if 'status' in message:
return HttpResponse(
status=int(message['status'].split()[0])
)
# Send content
response = HttpResponse(
content_type=message['content-type']
)
response.write(content)
return response
def matrix_load(request, project, component):
"""Backend for matrix view of all strings."""
obj = get_component(request, project, component)
try:
offset = int(request.GET.get("offset", ""))
except ValueError:
return HttpResponseServerError("Missing offset")
language_codes = request.GET.get("lang")
if not language_codes or offset is None:
return HttpResponseServerError("Missing lang")
# Can not use filter to keep ordering
translations = [
get_object_or_404(obj.translation_set, language__code=lang)
for lang in language_codes.split(",")
]
data = []
source_units = obj.source_translation.unit_set.order()[offset : offset + 20]
source_ids = [unit.pk for unit in source_units]
translated_units = [
{
unit.source_unit_id: unit
for unit in translation.unit_set.order().filter(source_unit__in=source_ids)
}
for translation in translations
]
for unit in source_units:
units = []
# Avoid need to fetch source unit again
unit.source_unit = unit
for translation in translated_units:
if unit.pk in translation:
# Avoid need to fetch source unit again
translation[unit.pk].source_unit = unit
units.append(translation[unit.pk])
else:
units.append(None)
data.append((unit, units))
return render(
request,
"matrix-table.html",
{
"object": obj,
"data": data,
"last": translations[0].unit_set.count() <= offset + 20,
},
)
def run_git_http(request, obj, path):
"""Git HTTP backend execution wrapper."""
# Find Git HTTP backend
git_http_backend = find_git_http_backend()
if git_http_backend is None:
return HttpResponseServerError("git-http-backend not found")
# Invoke Git HTTP backend
query = request.META.get("QUERY_STRING", "")
process_env = {
"REQUEST_METHOD": request.method,
"PATH_TRANSLATED": os.path.join(obj.full_path, path),
"GIT_HTTP_EXPORT_ALL": "1",
"CONTENT_TYPE": request.META.get("CONTENT_TYPE", ""),
"QUERY_STRING": query,
"HTTP_CONTENT_ENCODING": request.META.get("HTTP_CONTENT_ENCODING", ""),
}
process = subprocess.Popen(
[git_http_backend],
env=process_env,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
output, output_err = process.communicate(request.body)
retcode = process.poll()
# Log error
if output_err:
try:
raise Exception(
"Git http backend error: {}".format(
force_str(output_err).splitlines()[0]
)
)
except Exception:
report_error(cause="Git backend failure")
# Handle failure
if retcode:
return HttpResponseServerError(output_err)
headers, content = output.split(b"\r\n\r\n", 1)
message = message_from_string(headers.decode())
# Handle status in response
if "status" in message:
return HttpResponse(status=int(message["status"].split()[0]))
# Send content
response = HttpResponse(content_type=message["content-type"])
response.write(content)
return response
def csw_ajax(request, *args, **kwargs):
if request.method == 'GET':
csw_url = request.session['csw_url']
user = request.session['user']
password = request.session['password']
keywords = request.session['keywords']
keywords_query = [fes.PropertyIsLike(
'csw:AnyText', '%%%s%%' % keywords)]
if not csw_url:
return HttpResponseServerError()
try:
csw = CatalogueServiceWeb(
csw_url,
username=user,
password=password)
result = csw.identification.type
if result == 'CSW':
offset = int(request.GET['offset'])
per_page = int(request.GET['perPage'])
csw.getrecords2(
typenames='gmd:MD_Metadata',
esn='full',
outputschema='http://www.isotc211.org/2005/gmd',
constraints=keywords_query,
startposition=offset,
maxrecords=per_page)
result = []
for key in csw.records:
rec = csw.records[key]
res = {}
if isinstance(rec, MD_Metadata):
res['id'] = rec.identifier
res['title'] = rec.identification.title
res['inasafe_keywords'] = rec.identification.\
supplementalinformation
if res['inasafe_keywords']:
res['inasafe_layer'] = (
'<inasafe_keywords/>' in
res['inasafe_keywords'])
result.append(res)
json_result = {
'records': result,
'queryRecordCount': csw.results['matches'],
'totalRecordCount': csw.results['matches']
}
return JsonResponse(json_result, safe=False)
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
return HttpResponseServerError()
def payment_paid(request, payment_id: int):
try:
payment_info = PaymentInfo.objects.get(id=payment_id)
except ObjectDoesNotExist:
return HttpResponseServerError("not payment_info with id=%s" % payment_id)
if payment_info.paymentStatus != PaymentStatus.PAYING.value:
return HttpResponseServerError("payment status with id=%s is %s" % payment_id, payment_info.paymentStatus)
# TODO return items to warehouse
payment_info.paymentStatus = PaymentStatus.COMPLETED
payment_info.save()
return JsonResponse(
payment_info.to_dict()
)
def saml_metadata(request):
if "social_core.backends.saml.SAMLAuth" not in settings.AUTHENTICATION_BACKENDS:
raise Http404
# Generate configuration
settings.SOCIAL_AUTH_SAML_SP_ENTITY_ID = get_site_url(
reverse("social:saml-metadata"))
settings.SOCIAL_AUTH_SAML_ORG_INFO = {
"en-US": {
"name": "weblate",
"displayname": settings.SITE_TITLE,
"url": get_site_url("/"),
}
}
admin_contact = {
"givenName": settings.ADMINS[0][0],
"emailAddress": settings.ADMINS[0][1],
}
settings.SOCIAL_AUTH_SAML_TECHNICAL_CONTACT = admin_contact
settings.SOCIAL_AUTH_SAML_SUPPORT_CONTACT = admin_contact
# Generate metadata
complete_url = reverse("social:complete", args=("saml", ))
saml_backend = social_django.utils.load_backend(load_strategy(request),
"saml", complete_url)
metadata, errors = saml_backend.generate_metadata_xml()
# Handle errors
if errors:
report_error(level="error",
cause="SAML metadata",
extra_data={"errors": errors})
return HttpResponseServerError(content=", ".join(errors))
return HttpResponse(content=metadata, content_type="text/xml")
def get(self, *args, **kwargs):
request = self.request
if 'error' in request.GET:
return HttpResponseServerError(request.GET['error'])
if 'code' not in request.GET and 'state' not in request.GET:
return HttpResponseBadRequest()
if 'oidc_state' not in request.session \
or request.GET['state'] != request.session['oidc_state']:
# Missing or incorrect state; login again.
return HttpResponseRedirect(reverse('keycloak_login'))
nonce = Nonce.objects.get(state=request.GET['state'])
user = authenticate(request=request,
code=request.GET['code'],
redirect_uri=nonce.redirect_uri)
RemoteUserModel = get_remote_user_model()
if isinstance(user, RemoteUserModel):
remote_user_login(request, user)
else:
login(request, user)
nonce.delete()
return HttpResponseRedirect(nonce.next_path or '/')
def layer_panel(request, bbox=None, **kwargs):
if request.method != 'GET':
return HttpResponseBadRequest()
try:
# both authorized_objects and sections are obtained from decorator
authorized_objects = kwargs['authorized_objects']
sections = kwargs['sections']
form = AnalysisCreationForm(
user=request.user,
exposure_layer=retrieve_layers(
'exposure', bbox=bbox,
authorized_objects=authorized_objects)[0],
hazard_layer=retrieve_layers(
'hazard', bbox=bbox, authorized_objects=authorized_objects)[0],
impact_functions=Analysis.impact_function_list())
context = {
'sections': sections,
'form': form,
'user': request.user,
}
return render(request, "geosafe/analysis/options_panel.html", context)
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
def flood_event_features(request, event_id):
try:
flood = Flood.objects.get(event_id=event_id)
# build feature layer
features = []
for b in flood.flooded_boundaries.filter(boundary_alias__osm_level=8):
event_data = b.flood_event.get(flood=flood)
if event_data.hazard_data > 0:
feat = {
'id': b.upstream_id,
'type': 'Feature',
'geometry': json.loads(b.geometry.geojson),
'properties': {
'event_id': flood.event_id,
'time': flood.time,
'name': b.name,
'parent_name': b.parent.name,
'hazard_data': event_data.hazard_data
}
}
features.append(feat)
feature_collection = {
'type': 'FeatureCollection',
'features': features
}
return JsonResponse(feature_collection)
except BaseException:
return HttpResponseServerError()
def post(self, request):
api_settings = APISettings.get_solo()
# API disabled.
if not api_settings.allow:
return HttpResponseNotAllowed(permitted_methods=['POST'], content=_('API is disabled'))
# Auth key mismatch.
if request.META.get('HTTP_X_AUTHKEY') != api_settings.auth_key:
return HttpResponseForbidden(content=_('Invalid auth key'))
post_form = DsmrReadingForm(request.POST)
# Data omitted.
if not post_form.is_valid():
return HttpResponseBadRequest(_('Invalid data'))
try:
dsmr_reading = dsmr_datalogger.services.telegram_to_reading(data=post_form.cleaned_data['telegram'])
except:
dsmr_reading = None
# Data invalid.
if not dsmr_reading:
return HttpResponseServerError(content=_('Failed to parse telegram'))
return HttpResponse()
def layer_archive(request, layer_id):
"""request to get layer's zipped archive"""
if request.method != 'GET':
return HttpResponseBadRequest()
if not layer_id:
return HttpResponseBadRequest()
try:
layer = Layer.objects.get(id=layer_id)
tmp = tempfile.mktemp()
with ZipFile(tmp, mode='w') as zf:
for layer_file in layer.upload_session.layerfile_set.all():
base_name = os.path.basename(layer_file.file.name)
zf.writestr(base_name, layer_file.file.read())
base_file, __ = layer.get_base_file()
base_file_name, __ = os.path.splitext(
os.path.basename(base_file.file.path))
with open(tmp) as f:
response = HttpResponse(f.read(), content_type='application/zip')
response['Content-Disposition'] = (
'attachment; filename="{filename}.zip"'.format(
filename=base_file_name))
return response
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
def layer_tiles(request):
"""Ajax request to get layer's url to show in the map.
"""
if request.method != 'GET':
return HttpResponseBadRequest()
layer_id = request.GET.get('layer_id')
if not layer_id:
return HttpResponseBadRequest()
try:
layer = Layer.objects.get(id=layer_id)
context = {
'layer_tiles_url': layer.get_tiles_url(),
'layer_bbox_x0': float(layer.bbox_x0),
'layer_bbox_x1': float(layer.bbox_x1),
'layer_bbox_y0': float(layer.bbox_y0),
'layer_bbox_y1': float(layer.bbox_y1),
'layer_name': layer.title,
'legend_url': layer.get_legend_url()
}
return HttpResponse(json.dumps(context),
content_type="application/json")
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
def impact_function_filter(request):
"""Ajax Request for filtered available IF
"""
if request.method != 'GET':
return HttpResponseBadRequest()
exposure_id = request.GET.get('exposure_id')
hazard_id = request.GET.get('hazard_id')
if not (exposure_id and hazard_id):
return HttpResponse(json.dumps([]), content_type="application/json")
try:
hazard_layer = Layer.objects.get(id=hazard_id)
exposure_layer = Layer.objects.get(id=exposure_id)
hazard_url = get_layer_path(hazard_layer)
exposure_url = get_layer_path(exposure_layer)
async_result = filter_impact_function.delay(hazard_url, exposure_url)
impact_functions = async_result.get()
return HttpResponse(json.dumps(impact_functions),
content_type="application/json")
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
def get(self, request, *args, **kwargs):
if 'error' in request.GET:
return HttpResponseServerError(self.request.GET['error'])
if 'code' not in self.request.GET and 'state' not in self.request.GET:
return HttpResponseBadRequest(content='Code or State is empty')
if self.request.GET['state'] != self.request.session['openid_state']:
return HttpResponseBadRequest(content='State invalid')
nonce = cache.get(self.request.GET['state'])
if not nonce:
return HttpResponseBadRequest(content='State failure')
user = authenticate(
request=self.request,
code=self.request.GET['code'],
redirect_uri=nonce.redirect_uri
)
cache.delete(str(nonce.state))
if not user:
return HttpResponseBadRequest(content='Authenticate user failed')
login(self.request, user)
post_openid_login_success.send(
sender=self.__class__, user=user, request=self.request
)
return HttpResponseRedirect(nonce.next_path or '/')
def wfs_proxy(request, *args, **kwargs):
if request.method == 'GET':
endpoint = request.GET['endpoint']
typename = request.GET['typename']
user = request.session['user']
password = request.session['password']
endpoint_parsed = urlparse.urlparse(endpoint)
q_dict = {
'version': '1.0.0',
'typename': typename,
'outputFormat': 'json',
'request': 'GetFeature',
'service': 'WFS',
'srsName': 'EPSG:4326',
}
parsed_url = urlparse.ParseResult(scheme=endpoint_parsed.scheme,
netloc=endpoint_parsed.netloc,
path=endpoint_parsed.path,
params=None,
query=urllib.urlencode(q_dict),
fragment=None)
LOGGER.info('Proxy to url: %s' % parsed_url.geturl())
tmpfile = download_file(parsed_url.geturl(),
user=user,
password=password)
with open(tmpfile) as f:
return HttpResponse(f.read(), content_type='application/json')
return HttpResponseServerError()
def get(self, request, *args, **kwargs):
if 'error' in request.GET:
return HttpResponseServerError(self.request.GET['error'])
if 'code' not in self.request.GET and 'state' not in self.request.GET:
return HttpResponseBadRequest()
if self.request.GET['state'] != self.request.session['openid_state']:
return HttpResponseBadRequest()
nonce = cache.get(self.request.GET['state'])
if not nonce:
return HttpResponseBadRequest()
user = authenticate(request=self.request,
code=self.request.GET['code'],
redirect_uri=nonce.redirect_uri)
cache.delete(str(nonce.state))
if not user:
return HttpResponseBadRequest()
login(self.request, user)
data = {
'username': user.username,
'mfa': int(user.otp_enabled),
'reason': LoginLog.REASON_NOTHING,
'status': True
}
self.write_login_log(data)
return HttpResponseRedirect(nonce.next_path or '/')
def delete(self, request):
# Get the ID of the stored upload to be deleted and look it up in
# the database.
print(request)
print(request.GET)
upload_id = request.GET.get('id', None)
print(upload_id)
try:
su = StoredUpload.objects.get(upload_id=upload_id)
except StoredUpload.DoesNotExist:
return HttpResponseNotFound()
# If we found the StoredUpload record, call the django-drf-filepond
# API function delete_stored_upload to delete the record from the
# database and delete the corresponding file on the local or remote
# filesystem (delete_file=True).
try:
delete_stored_upload(su.upload_id, delete_file=True)
except Exception as e:
return HttpResponseServerError(json.dumps({
'status': 'ERROR',
'errorMsg': str(e)
}),
content_type='application/json')
return HttpResponse(json.dumps({
'status': 'OK',
'deleted': upload_id
}),
content_type='application/json')
def post(self, request):
api_settings = APISettings.get_solo()
if not api_settings.allow:
return HttpResponseNotAllowed(permitted_methods=['POST'],
content='API is disabled')
if request.META.get('HTTP_X_AUTHKEY') != api_settings.auth_key \
and request.META.get('HTTP_AUTHORIZATION') != 'Token {}'.format(api_settings.auth_key):
return HttpResponseForbidden(content='Invalid auth key')
post_form = DsmrReadingForm(request.POST)
if not post_form.is_valid():
logger.warning('API validation failed with POST data: {}'.format(
request.POST))
return HttpResponseBadRequest('Invalid data')
dsmr_reading = None
try:
dsmr_reading = dsmr_datalogger.services.telegram_to_reading(
data=post_form.cleaned_data['telegram'])
except InvalidTelegramError:
# The service called already logs the error.
pass
if not dsmr_reading:
return HttpResponseServerError(content='Failed to parse telegram')
return HttpResponse(status=201)
