def dispatch(self, request):
"""
:type request: wechat_django.models.request.WeChatMessageRequest
"""
if not request.wechat.app.interactable():
return response.HttpResponseNotFound()
log = MessageHandler.handlerlog(request)
try:
self._verify(request)
resp = super(Handler, self).dispatch(request)
if not isinstance(resp, response.HttpResponseNotFound):
log(logging.DEBUG, "receive a message")
return resp
except MultiValueDictKeyError:
log(logging.WARNING, "bad request args", exc_info=True)
return response.HttpResponseBadRequest()
except BadMessageRequest:
log(logging.WARNING, "bad request", exc_info=True)
return response.HttpResponseBadRequest()
except InvalidSignatureException:
log(logging.WARNING, "invalid signature", exc_info=True)
return response.HttpResponseBadRequest()
except xmltodict.expat.ExpatError:
log(logging.WARNING, "deserialize message failed", exc_info=True)
return response.HttpResponseBadRequest()
except MessageHandleError:
log(logging.WARNING, "handle message failed", exc_info=True)
return ""
except:
log(logging.ERROR, "an unexcepted error occurred", exc_info=True)
return ""
def predict(request):
from pss_recognition.recognition.model_holder import ModelHolder
from pss_recognition.recognition.recognition import transform_x, get
import tensorflow as tf
import numpy as np
import json
if request.method == 'POST':
form = UploadFileForm(request.POST, request.FILES)
if form.is_valid():
model = ModelHolder.get_model()
label_to_name = json.loads(
open('models/latest_label_to_name.json').read())
handle_uploaded_file(request.FILES['picture'])
with tf.device('/CPU:0'):
transformed, _ = transform_x(np.asarray([get('image.jpg')]),
np.asarray([0]))
prediction = model.predict(transformed)
label = np.argmax(prediction)
probability = np.max(prediction)
return response.JsonResponse({
'name': label_to_name[str(label)],
'probability': str(probability)
})
return response.HttpResponseBadRequest()
def correct_url(request, object_id):
"""修正请求url"""
resolved_url = resolve(request.path_info)
url_name = resolved_url.url_name
url_kwargs = resolved_url.kwargs
if object_id:
# 对于只有object_id没有app_id的 重定向到有app_id的url
modeladmin = view.__self__
try:
obj = modeladmin.model.objects.get(pk=object_id)
except modeladmin.model.DoesNotExist:
return response.HttpResponseBadRequest()
url_kwargs.update(wechat_app_id=obj.app_id, object_id=object_id)
return response.HttpResponseRedirect(reverse("admin:" + url_name,
kwargs=url_kwargs),
status=307)
else:
# 对于没有app_id的listview请求 优先取referrer的app_id
referrer = request.META.get("HTTP_REFERER", "")
path_info = urlparse(referrer).path
try:
app_id = resolve(path_info).kwargs["wechat_app_id"]
except (KeyError, Resolver404):
return response.HttpResponseNotFound()
url_kwargs.update(wechat_app_id=app_id)
resp = response.HttpResponseRedirect(
reverse("admin:" + url_name, kwargs=url_kwargs))
resp.status_code = 307
return resp
def base_request(self,
request: Request,
request_schema: Schema,
response_schema: Schema,
logic_method: Callable[[object, Optional[str]], object],
is_paging: Optional[bool] = False,
code=None):
request_obj, request_errors = self._request_schema(
request, request_schema, code)
if request_errors:
return response.HttpResponseBadRequest(json.dumps(request_errors))
response_data, response_errors = self._response_schema(
request, request_obj, response_schema, logic_method, is_paging)
if response_errors:
if isinstance(response_errors, (str, dict)):
return Response(response_errors,
status.HTTP_500_INTERNAL_SERVER_ERROR)
else:
return response_errors
if request.method == 'POST':
return Response(response_data, status.HTTP_201_CREATED)
elif request.method == 'DELETE':
return Response({}, status.HTTP_204_NO_CONTENT)
else:
return Response(response_data, status.HTTP_200_OK)
def log_stream(request):
if not request.is_ajax():
return response.HttpResponseBadRequest(
"Only Ajax requests are accepted.")
if request.method != 'POST':
return response.HttpResponseNotAllowed(request.method)
search_str = request.POST.get("search")
aggregates = []
if search_str != "":
aggregates.append({"$match": {"$text": {"$search": search_str}}})
last_requests = log_records.aggregate(aggregates + [{
"$sort": {
"time": -1
}
}, {
"$limit": 100
}, {
"$project": {
"_id": 0
}
}])
data = {"last_requests": list(last_requests)}
return response.JsonResponse(data)
def post(self, *args, **kwargs):
if not self.request.is_ajax():
return response.HttpResponseBadRequest()
return JsonResponse({
'data':
ContentType.objects.get(pk=self.kwargs['content_type_id']).
model_class().get_posts_with_comments(self.request.user)
})
def shorten(request):
try:
url = json.loads(str(request.body, encoding='utf-8'))['url']
val(url)
obj = URL.objects.get_or_create(original_link=url)
except:
return response.HttpResponseBadRequest()
return response.JsonResponse({
"short_link": request.build_absolute_uri(reverse("open", args=(obj[0].slug,))),
"original_link": obj[0].original_link
}) #status=201 if obj[1] else 200
def request_month(request):
if not request.is_ajax():
return response.HttpResponseBadRequest(
"Only Ajax requests are accepted.")
if request.method != 'POST':
return response.HttpResponseNotAllowed(request.method)
year = request.POST.get("year")
month = request.POST.get("month")
return response.JsonResponse(requests_month_bar(year=year, month=month))
def delete(self, request, *args, **kwargs):
self.object = self.get_object()
user = self.object.user
if user == self.request.user or self.request.user.is_superuser:
try:
self.object.delete()
send_notification('delete', request.user.id,
self.object.__dict__)
except CommentTreeException as e:
return response.HttpResponseBadRequest(e.message)
else:
raise PermissionDenied
messages.success(self.request, _('Comment has been deleted'))
return HttpResponseRedirect(self.request.META.get('HTTP_REFERER'))
def decorated_func(request, *args, **kwargs):
app_id = kwargs.pop("wechat_app_id", None)
object_id = kwargs.get("object_id", None)
if not app_id:
resolved_url = resolve(request.path_info)
url_name = resolved_url.url_name
url_kwargs = resolved_url.kwargs
if object_id:
# 对于只有object_id没有app_id的 重定向到有app_id的url
modeladmin = view.__self__
try:
obj = modeladmin.model.objects.get(pk=object_id)
except modeladmin.model.DoesNotExist:
return response.HttpResponseBadRequest()
url_kwargs.update(wechat_app_id=obj.app_id,
object_id=object_id)
return response.HttpResponseRedirect(
reverse("admin:" + url_name, kwargs=url_kwargs))
else:
# 对于没有app_id的listview请求 优先取referrer的app_id
referrer = request.META.get("HTTP_REFERER", "")
path_info = urlparse(referrer).path
try:
app_id = resolve(path_info).kwargs["wechat_app_id"]
except (KeyError, Resolver404):
return response.HttpResponseNotFound()
url_kwargs.update(wechat_app_id=app_id)
resp = response.HttpResponseRedirect(
reverse("admin:" + url_name, kwargs=url_kwargs))
resp.status_code = 307
return resp
extra_context = kwargs.pop("extra_context", None) or {}
try:
app = site.wechat_site.app_queryset.get(id=app_id)
except WeChatApp.DoesNotExist:
return response.HttpResponseNotFound()
# 附上app
request.app = app
request.app_id = app_id
# 增加模板context
extra_context.update(wechat_app=app, wechat_app_id=app_id)
kwargs["extra_context"] = extra_context
return view(request, *args, **kwargs)
def get_langs_php(request, format='json'):
if format == 'jsonp' and 'callback' not in request.GET:
return response.HttpResponseBadRequest()
lang_to_name = {
"en": "English",
"de": "Deutsch",
"dk": "Dansk",
"es": "Español",
"fa": "فارسی",
"fr": "Français",
"it": "Italiano",
"pl": "Polskie",
"pt": "Português",
"sv": "Svenska"
}
languages = TranslatedFormat.objects.values_list('language', flat=True).distinct()
if format in ('json', 'jsonp'):
content_type = 'application/json'
ret = {"languages": []}
for language in languages:
ret["languages"].append({
"key": language,
"name": lang_to_name.get(language, ''),
"default": True if language == 'en' else False
})
ret = json.dumps(ret)
if format == 'jsonp':
ret = request.GET.get('callback') + '(' + ret + ')'
else:
content_type = 'application/xml'
ret = "<languages>"
for language in languages:
ret += '\n <language key="{}"{}>{}</language>'.format(
language,
' default="1"' if language == 'en' else "",
lang_to_name.get(language, '')
)
ret += "\n</languages>"
return response.HttpResponse(ret, content_type=content_type)
def verify_invitation_code(request):
"""Check if the phone verify code is right"""
if len(request.body) > 0:
dic = eval(request.body)
code = str(dic.get('invitation_code'))
content = ''
try:
result = chakra.invcode_check(request, code)
if not result:
content = _("Wrong Code")
else:
if (result['status'] != INVCODE_STATUS[0]):
content = _('Wrong Code')
else:
content = "True"
return HttpResponse(content, content_type="application/json")
except HTTPNotFound:
content = _("Wrong Code")
return HttpResponse(content, content_type="application/json")
except:
return response.HttpResponseServerError(content)
return response.HttpResponseBadRequest("invitation code is null")
def _response_schema(self,
request,
request_obj,
response_schema,
logic_method,
is_paging=False):
try:
if is_paging:
path = self._parse_path(request)
response_obj = logic_method(request_obj, path)
else:
response_obj = logic_method(request_obj)
except RequestParameterException as e:
return {}, response.HttpResponseBadRequest(content=e)
except ResourceNotFoundException as e:
return {}, response.HttpResponseNotFound(content=e)
except ForbiddenException as e:
return {}, response.HttpResponseForbidden(content=e)
except ConflictException as e:
return {}, response.HttpResponse(content=e,
status=status.HTTP_409_CONFLICT)
return response_schema.dump(response_obj)
def get_langs_php(request, format='json'):
if format == 'jsonp' and 'callback' not in request.GET:
return response.HttpResponseBadRequest()
if format in ('json', 'jsonp'):
content_type = 'application/json'
ret = json.dumps(
{"languages": [{
"key": "en",
"name": "English",
"default": True
}]})
if format == 'jsonp':
ret = request.GET.get('callback') + '(' + ret + ')'
else:
content_type = 'application/xml'
ret = textwrap.dedent("""
<languages>
<language key="en" default="1">English</language>
</languages>
""")
return response.HttpResponse(ret, content_type=content_type)
def semantic_query(request, format='json'):
switcher = request.GET.get('switcher')
if format not in ('csv', 'json', 'xml', 'jsonp', 'kml', 'poi'):
return response.HttpResponseBadRequest()
if not switcher:
return response.HttpResponseBadRequest()
if switcher not in valid_switcher_params:
return response.HttpResponseBadRequest()
if format in ('kml', 'poi') and switcher != 'GetSearchResults':
return response.HttpResponseBadRequest()
if format != 'csv' and switcher == 'GetNAWSDump':
return response.HttpResponseBadRequest()
if format == 'jsonp' and 'callback' not in request.GET:
return response.HttpResponseBadRequest()
params = request.GET.copy()
ret = None
if format == 'json':
content_type = 'application/json'
elif format == 'jsonp':
content_type = 'text/javascript'
elif format in ('csv', 'poi'):
content_type = 'text/csv'
elif format in ('xml', 'kml'):
content_type = 'application/xml'
language = params.get('lang_enum', default='en')
if switcher == 'GetSearchResults':
if format in ('kml', 'poi') and 'data_field_key' in params:
# Invalid parameter for kml and poi, as they always returns the same fields.
params.pop('data_field_key')
meetings = get_search_results(params)
retrieve_formats(language)
data_field_keys = extract_specific_keys_param(params)
if format in ('json', 'jsonp', 'xml'):
if 'get_used_formats' in params or 'get_formats_only' in params:
formats = TranslatedFormat.objects.filter(language=language, format__id__in=meetings.values('formats'))
formats = formats.select_related('format', 'format__root_server')
if format in ('json', 'jsonp'):
if 'get_used_formats' in params or 'get_formats_only' in params:
if 'get_formats_only' in params:
ret = models_to_json(formats, format_field_map, parent_keys='formats')
else:
ret = models_to_json(
(meetings, formats),
(meeting_field_map, format_field_map),
related_models_filter_function=(None, None),
parent_keys=('meetings', 'formats'),
return_attrs=(data_field_keys, None)
)
else:
ret = models_to_json(
meetings,
meeting_field_map,
related_models_filter_function=None,
return_attrs=data_field_keys
)
else:
xmlns = '{}://{}'.format(request.scheme, request.get_host())
if 'get_used_formats' in params or 'get_formats_only' in params:
if 'get_formats_only' in params:
ret = models_to_xml(formats, format_field_map, 'formats', xmlns=xmlns, schema_name='GetFormats')
else:
ret = models_to_xml(
meetings, meeting_field_map, 'meetings',
related_models_filter_function=None,
xmlns=xmlns,
schema_name=switcher,
sub_models=formats,
sub_models_field_map=format_field_map,
sub_models_element_name='formats'
)
else:
ret = models_to_xml(
meetings, meeting_field_map, 'meetings',
related_models_filter_function=None,
xmlns=xmlns, schema_name=switcher
)
elif format == 'kml':
meetings = apply_kml_annotations(meetings)
ret = models_to_xml(meetings, meeting_kml_field_map, 'kml.Document',
model_name='Placemark', show_sequence_index=False)
elif format == 'poi':
meetings = meetings.order_by('weekday')
meetings = apply_kml_annotations(meetings)
ret = models_to_csv(meetings, meeting_poi_field_map)
elif format == 'csv':
ret = models_to_csv(meetings, meeting_field_map, data_field_keys)
else:
xml_schema_name = None
if switcher == 'GetNAWSDump':
sb_id = params.get('sb_id', None)
if not sb_id:
return response.HttpResponseBadRequest()
sb_ids = [sb for sb in get_child_service_bodies([sb_id])]
qs = Meeting.objects.filter(deleted=False, published=True)
qs = qs.filter(service_body_id__in=sb_ids, service_body__world_id__isnull=False)
qs = qs.exclude(service_body__world_id='')
qs = qs.select_related('meetinginfo', 'service_body', 'root_server')
qs = qs.prefetch_related('formats', 'formats__translatedformats')
qs_union = Meeting.objects.filter(Q(deleted=True) | Q(published=False))
qs_union = qs_union.filter(service_body_id__in=sb_ids, service_body__world_id__isnull=False)
qs_union = qs_union.exclude(service_body__world_id='')
qs_union = qs_union.select_related('meetinginfo', 'service_body', 'root_server')
qs_union = qs_union.prefetch_related('formats', 'formats__translatedformats')
models = qs.union(qs_union, all=True)
field_map = naws_dump_field_map
elif switcher == 'GetFormats':
models = get_formats(params)
field_map = format_field_map
xml_node_name = 'formats'
xml_schema_name = switcher
elif switcher == 'GetServiceBodies':
models = get_service_bodies(params)
field_map = service_bodies_field_map
xml_node_name = 'serviceBodies'
elif switcher == 'GetFieldKeys':
models = [{'key': k, 'description': d} for k, d in field_keys_with_descriptions.items()]
field_map = {'key': ('key',), 'description': ('description',)}
xml_node_name = 'fields'
elif switcher == 'GetFieldValues':
meeting_key = params.get('meeting_key')
if meeting_key in field_keys:
models = get_field_values(params)
field_map = {meeting_key: (meeting_field_map.get(meeting_key)[0],), 'ids': ('ids',)}
xml_node_name = 'fields'
else:
return response.HttpResponseBadRequest()
elif switcher == 'GetServerInfo':
models = [{
'version': '5.0.0',
'versionInt': '5000000',
'langs': 'en',
'nativeLang': 'en',
'centerLongitude': -118.563659,
'centerLatitude': 34.235918,
'centerZoom': 6,
'available_keys': ','.join(field_keys),
'changesPerMeeting': '0',
'google_api_key': settings.GOOGLE_MAPS_API_KEY,
}]
field_map = server_info_field_map
xml_node_name = 'serverInfo'
if format in ('json', 'jsonp'):
ret = models_to_json(models, field_map)
elif format == 'csv':
ret = models_to_csv(models, field_map)
elif format == 'xml':
xmlns = '{}://{}'.format(request.scheme, request.get_host())
ret = models_to_xml(models, field_map, xml_node_name, xmlns=xmlns, schema_name=xml_schema_name)
if format == 'jsonp':
return JSONPStreamingHttpResponse(ret, content_type=content_type, callback=params.get('callback'))
r = response.StreamingHttpResponse(ret, content_type=content_type)
if format == 'poi':
r['Content-Disposition'] = 'attachment; filename="SearchResultsPOI.csv"'
elif format == 'kml':
r['Content-Disposition'] = 'attachment; filename="SearchResults.kml"'
elif format == 'csv' and switcher == 'GetNAWSDump':
r['Content-Disposition'] = 'attachment; filename="BMLT.csv"'
return r
def handler400(request, *args, **kwargs):
return response.HttpResponseBadRequest()
def dispatch(self, request, *args, **kwargs):
if request.method == 'POST' and not request.is_ajax():
return response.HttpResponseBadRequest()
return super().dispatch(request, *args, **kwargs)
