def post(self, request):
# 1. 接收请求体的非表单数据 body
json_dict = json.loads(request.body.decode())
title = json_dict.get('title')
receiver = json_dict.get('receiver')
province_id = json_dict.get('province_id')
city_id = json_dict.get('city_id')
district_id = json_dict.get('district_id')
place = json_dict.get('place')
mobile = json_dict.get('mobile')
tel = json_dict.get('tel')
email = json_dict.get('email')
# 2. 校验
if all([
title, receiver, province_id, city_id, district_id, place,
mobile
]) is False:
return http.HttpResponseForbidden('缺少必传参数')
if not re.match(r'^1[3-9]\d{9}$', mobile):
return http.HttpResponseForbidden('手机号格式有误')
if tel: # 座机号传了再校验,如果没传什么都不做
if not re.match(
r'^(0[0-9]{2,3}-)?([2-9][0-9]{6,7})+(-[0-9]{1,4})?$', tel):
return http.HttpResponseForbidden('参数tel有误')
if email:
if not re.match(
r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$',
email):
return http.HttpResponseForbidden('参数email有误')
user = request.user
# 3. 新增
try:
address = Address(user=user,
title=title,
receiver=receiver,
province_id=province_id,
city_id=city_id,
district_id=district_id,
detail_address=place,
mobile=mobile,
phone=tel,
email=email)
address.save()
except DatabaseError as e:
logger.error(e)
return http.HttpResponseServerError('存储收货地址失败')
# 判断当前用户有没有默认收货地址,如果没有,就将当前新增的地址设置为用户的默认地址
if user.default_address is None:
user.default_address = address
user.save()
# 4. 响应
# 将新增的address模型对象转换成字典
address_dict = {
'id': address.id,
'title': address.title,
'receiver': address.receiver,
'province_id': address.province_id,
'province': address.province.name,
'city_id': address.city_id,
'city': address.city.name,
'district_id': address.district_id,
'district': address.district.name,
'place': address.detail_address,
'mobile': address.mobile,
'tel': address.phone,
'email': address.email
}
return http.JsonResponse({
'code': RETCODE.OK,
'errmsg': 'OK',
'address': address_dict
})
def response(self):
for arg in self.args:
if isinstance(arg, http.HttpResponse):
return arg
else:
return http.HttpResponseServerError()
def _wrapped(request, *a, **kw):
try:
status = 200
headers = {}
ret = f(request, *a, **kw)
if isinstance(ret, tuple):
if len(ret) == 3:
ret, headers, status = ret
else:
ret, headers = ret
# Some errors are not exceptions. :\
if isinstance(ret, http.HttpResponseNotAllowed):
blob = _dump_json({
'code': -1,
'timestamp': int(time() * 1000),
'error': 405,
'message': 'HTTP method not allowed.'
})
# debugging information
logger.error('Internal Server Error: %s',
request.path,
exc_info=True,
extra={
'code': -1,
'timestamp': int(time() * 1000),
'status_code': 405,
'request': request,
})
return http.HttpResponse(blob,
status=405,
content_type=JSON)
# Allow HttpResponses to go straight through.
if isinstance(ret, http.HttpResponse):
return ret
data = {
'code': 0,
'timestamp': int(time() * 1000),
'message': 'Success',
'data': ret
}
data.update(headers)
blob = _dump_json(data)
print(_dump_json(data, utf8=False)[:100])
assert (type(status) is int)
response = http.HttpResponse(blob,
status=status,
content_type=content_type)
for k in headers:
response[k] = headers[k]
return response
except http.Http404 as e:
traceback.print_exc()
blob = _dump_json({
'code': -1,
'timestamp': int(time() * 1000),
'error': 404,
'message': six.text_type(e),
})
logger.error('not found: %s',
request.path,
extra={
'code': -1,
'timestamp': int(time() * 1000),
'status_code': 404,
'request': request,
})
return http.HttpResponseNotFound(blob, content_type=JSON)
except PermissionDenied as e:
traceback.print_exc()
logger.error('Forbidden (Permission denied): %s',
request.path,
extra={
'code': -1,
'timestamp': int(time() * 1000),
'status_code': 403,
'request': request,
})
blob = _dump_json({
'code': -1,
'timestamp': int(time() * 1000),
'error': 403,
'message': six.text_type(e),
})
return http.HttpResponseForbidden(blob, content_type=JSON)
except BlockException as e:
traceback.print_exc()
blob = _dump_json({
'code': e.code,
'timestamp': int(time() * 1000),
'error': 400,
'message': six.text_type(e),
})
# Generate the usual 500 error email with stack trace and full
# debugging information
logger.error('Internal Server Error: %s',
request.path,
exc_info=True,
extra={
'code': -1,
'timestamp': int(time() * 1000),
'status_code': 400,
'request': request,
})
return http.HttpResponseBadRequest(blob, content_type=JSON)
except Exception as e:
traceback.print_exc()
exc_data = {
'code': -1,
'timestamp': int(time() * 1000),
'error': 500,
'message': 'An error occurred',
}
if settings.DEBUG:
exc_data['message'] = six.text_type(e)
exc_data['traceback'] = traceback.format_exc()
blob = _dump_json(exc_data)
# Generate the usual 500 error email with stack trace and full
# debugging information
logger.error('Internal Server Error: %s',
request.path,
exc_info=True,
extra={
'code': -1,
'timestamp': int(time() * 1000),
'status_code': 500,
'request': request,
})
# Here we lie a little bit. Because we swallow the exception,
# the BaseHandler doesn't get to send this signal. It sets the
# sender argument to self.__class__, in case the BaseHandler
# is subclassed.
got_request_exception.send(sender=BaseHandler, request=request)
return http.HttpResponseServerError(blob, content_type=JSON)
def dispatch(self, request: 'ExtendedHttpRequest', *args, **kwargs):
"""
Processes the REST request and routes it wherever it needs to be routed
"""
# Remove session from request, so response middleware do nothing with this
del request.session
# Now we extract method and possible variables from path
path: typing.List[str] = kwargs['arguments'].split('/')
del kwargs['arguments']
# Transverse service nodes, so we can locate class processing this path
service = Dispatcher.services
full_path_lst: typing.List[str] = []
# Guess content type from content type header (post) or ".xxx" to method
content_type: str = request.META.get('CONTENT_TYPE', 'json')
while path:
# .json, .xml, .anything will break path recursion
if path[0].find('.') != -1:
content_type = path[0].split('.')[1]
clean_path = path[0].split('.')[0]
if not clean_path: # Skip empty path elements, so /x/y == /x////y for example (due to some bugs detected on some clients)
path = path[1:]
continue
if clean_path in service:
service = service[clean_path]
full_path_lst.append(path[0])
path = path[1:]
else:
break
full_path = '/'.join(full_path_lst)
logger.debug("REST request: %s (%s)", full_path, content_type)
# Here, service points to the path
cls: typing.Optional[typing.Type[Handler]] = service['']
if cls is None:
return http.HttpResponseNotFound('Method not found', content_type="text/plain")
processor = processors.available_processors_ext_dict.get(content_type, processors.default_processor)(request)
# Obtain method to be invoked
http_method: str = request.method.lower()
# Path here has "remaining" path, that is, method part has been removed
args = tuple(path)
handler = None
try:
handler = cls(request, full_path, http_method, processor.processParameters(), *args, **kwargs)
operation: typing.Callable[[], typing.Any] = getattr(handler, http_method)
except processors.ParametersException as e:
logger.debug('Path: %s', full_path)
logger.debug('Error: %s', e)
return http.HttpResponseServerError('Invalid parameters invoking {0}: {1}'.format(full_path, e), content_type="text/plain")
except AttributeError:
allowedMethods = []
for n in ['get', 'post', 'put', 'delete']:
if hasattr(handler, n):
allowedMethods.append(n)
return http.HttpResponseNotAllowed(allowedMethods, content_type="text/plain")
except AccessDenied:
return http.HttpResponseForbidden('access denied', content_type="text/plain")
except Exception:
logger.exception('error accessing attribute')
logger.debug('Getting attribute %s for %s', http_method, full_path)
return http.HttpResponseServerError('Unexcepected error', content_type="text/plain")
# Invokes the handler's operation, add headers to response and returns
try:
response = operation()
if not handler.raw: # Raw handlers will return an HttpResponse Object
response = processor.getResponse(response)
# Set response headers
for k, val in handler.headers().items():
response[k] = val
return response
except RequestError as e:
return http.HttpResponseBadRequest(str(e), content_type="text/plain")
except ResponseError as e:
return http.HttpResponseServerError(str(e), content_type="text/plain")
except NotSupportedError as e:
return http.HttpResponseBadRequest(str(e), content_type="text/plain")
except AccessDenied as e:
return http.HttpResponseForbidden(str(e), content_type="text/plain")
except NotFound as e:
return http.HttpResponseNotFound(str(e), content_type="text/plain")
except HandlerError as e:
return http.HttpResponseBadRequest(str(e), content_type="text/plain")
except Exception as e:
logger.exception('Error processing request')
return http.HttpResponseServerError(str(e), content_type="text/plain")
def error500(request, template_name='500.html'):
t = template.loader.get_template(template_name)
context = template.Context({
'STATIC_URL': settings.STATIC_URL,
})
return http.HttpResponseServerError(t.render(context))
def user_info(request):
"""/user_info/..."""
op = request.REQUEST.get("op", None)
if op == "get_user_info":
return get_user_info(request)
return http.HttpResponseServerError("op=" + str(op))
def _wrapped(request, *a, **kw):
try:
status = 200
headers = {}
ret = f(request, *a, **kw)
if isinstance(ret, tuple):
if len(ret) == 3:
ret, status, headers = ret
else:
ret, status = ret
# Some errors are not exceptions. :\
if isinstance(ret, http.HttpResponseNotAllowed):
blob = json.dumps({
'error': 405,
'message': 'HTTP method not allowed.'
})
return http.HttpResponse(blob,
status=405,
content_type=JSON)
blob = json.dumps(ret)
response = http.HttpResponse(blob,
status=status,
content_type=content_type)
for k in headers:
response[k] = headers[k]
return response
except http.Http404 as e:
blob = json.dumps({
'error': 404,
'message': unicode(e),
})
logger.warning('Not found: %s',
request.path,
extra={
'status_code': 404,
'request': request,
})
return http.HttpResponseNotFound(blob, content_type=JSON)
except PermissionDenied as e:
logger.warning('Forbidden (Permission denied): %s',
request.path,
extra={
'status_code': 403,
'request': request,
})
blob = json.dumps({
'error': 403,
'message': unicode(e),
})
return http.HttpResponseForbidden(blob, content_type=JSON)
except BadRequest as e:
blob = json.dumps({
'error': 400,
'message': unicode(e),
})
return http.HttpResponseBadRequest(blob, content_type=JSON)
except Exception as e:
blob = json.dumps({
'error': 500,
'message': unicode(e),
})
logger.exception(unicode(e))
# Here we lie a little bit. Because we swallow the exception,
# the BaseHandler doesn't get to send this signal. It sets the
# sender argument to self.__class__, in case the BaseHandler
# is subclassed.
got_request_exception.send(sender=BaseHandler, request=request)
return http.HttpResponseServerError(blob, content_type=JSON)
def _wrapped(request, *a, **kw):
try:
status = 200
headers = {}
ret = f(request, *a, **kw)
if isinstance(ret, tuple):
if len(ret) == 3:
ret, status, headers = ret
else:
ret, status = ret
# Some errors are not exceptions. :\
if isinstance(ret, http.HttpResponseNotAllowed):
blob = _dump_json({
'error': 405,
'message': 'HTTP method not allowed.'
})
return http.HttpResponse(
blob, status=405, content_type=JSON)
# Allow HttpResponses to go straight through.
if isinstance(ret, http.HttpResponse):
return ret
blob = _dump_json(ret)
response = http.HttpResponse(blob, status=status,
content_type=content_type)
for k in headers:
response[k] = headers[k]
return response
except http.Http404 as e:
blob = _dump_json({
'error': 404,
'message': unicode(e),
})
logger.warning('Not found: %s', request.path,
extra={
'status_code': 404,
'request': request,
})
return http.HttpResponseNotFound(blob, content_type=JSON)
except PermissionDenied as e:
logger.warning(
'Forbidden (Permission denied): %s', request.path,
extra={
'status_code': 403,
'request': request,
})
blob = _dump_json({
'error': 403,
'message': unicode(e),
})
return http.HttpResponseForbidden(blob, content_type=JSON)
except BadRequest as e:
blob = _dump_json({
'error': 400,
'message': unicode(e),
})
return http.HttpResponseBadRequest(blob, content_type=JSON)
except Exception as e:
if settings.DEBUG:
exc_text = unicode(e)
else:
exc_text = 'An error occurred'
blob = _dump_json({
'error': 500,
'message': exc_text,
})
# Generate the usual 500 error email with stack trace and full
# debugging information
logger.error('Internal Server Error: %s', request.path,
exc_info=True,
extra={
'status_code': 500,
'request': request
}
)
# Here we lie a little bit. Because we swallow the exception,
# the BaseHandler doesn't get to send this signal. It sets the
# sender argument to self.__class__, in case the BaseHandler
# is subclassed.
got_request_exception.send(sender=BaseHandler, request=request)
return http.HttpResponseServerError(blob, content_type=JSON)
def get(self, response, *args, **kwargs):
return http.HttpResponseServerError()
def render_failure(self, failure: 'CaseError', **kwargs) -> http.HttpResponse:
Logger.warning(__name__, str(failure))
if failure.failure in (ReservationErrors.missed_house, ReservationErrors.missed_reservation):
raise http.Http404(failure.error)
return http.HttpResponseServerError()
def _wrapped(request, *args, **kwargs):
try:
ret = f(request, *args, **kwargs)
# Some errors are not exceptions
if isinstance(ret, http.HttpResponseNotAllowed):
return http.HttpResponse(json.dumps(
_make_error(_('HTTP method not allowed.'))),
status=405,
content_type=JSON)
if isinstance(ret, http.HttpResponseBadRequest):
return http.HttpResponse(json.dumps(
_make_error(_('Bad Request'))),
status=400,
content_type=JSON)
# Allow other HttpResponses through
if isinstance(ret, http.HttpResponse):
return ret
# Functions without return values default to a dict which just contains {success: true}
if ret is None:
ret = {}
if include_success and 'success' not in ret:
ret['success'] = True
content = json.dumps(ret)
return http.HttpResponse(content,
status=200,
content_type=JSON)
except http.Http404 as e:
logger.warning('Not found: %s',
request.path,
extra={
'status_code': 404,
'request': request,
})
return http.HttpResponseNotFound(json.dumps(_make_error(
str(e))),
content_type=JSON)
except PermissionDenied as e:
logger.warning('Forbidden (Permission denied): %s',
request.path,
extra={
'status_code': 403,
'request': request,
})
return http.HttpResponseForbidden(json.dumps(
_make_error(str(e))),
content_type=JSON)
except BadRequest as e:
return http.HttpResponseBadRequest(json.dumps(
_make_error(str(e))),
content_type=JSON)
except ValidationError as e:
# Validation errors are raised for errors such as invalid file names.
# We return HTTP 400s in these cases, and send back a comma separated string of errors.
# (although generally there will only be one error)
return http.HttpResponseBadRequest(json.dumps(
_make_error(", ".join(e.messages))),
content_type=JSON)
except Exception as e:
data = _make_error(_('An error has occurred'))
if settings.DEBUG or isinstance(e, InternalServerError):
data['error'] = str(e)
if settings.DEBUG:
data['traceback'] = traceback.format_exc()
content = json.dumps(data)
# Generate the usual 500 error email with stack trace and full
# debugging information
logger.error('Internal Server Error: %s',
request.path,
exc_info=True,
extra={
'status_code': 500,
'request': request
})
# Here we lie a little bit. Because we swallow the exception,
# the BaseHandler doesn't get to send this signal. It sets the
# sender argument to self.__class__, in case the BaseHandler
# is subclassed.
got_request_exception.send(sender=BaseHandler, request=request)
return http.HttpResponseServerError(content, content_type=JSON)
def __call__(self, environ, start_response):
"""
Hijack the main loop from the original thread and listen on events on the Redis
and the Websocket filedescriptors.
"""
user_connection = None
#TODO: also log ip
logger.info("Got a websocket connection",
extra={"environment": environ})
try:
self.assure_protocol_requirements(environ)
request = WSGIRequest(environ)
session_key = request.COOKIES.get(settings.SESSION_COOKIE_NAME,
None)
websocket = self.upgrade_websocket(environ, start_response)
user_connection = UserConnection(request, session_key,
self.get_event(), websocket)
# Every user gets auto-subscribed to the global stream. This is where we broadcast sitewide messages
user_connection.subscribe("global-events")
user_connection.websocket_file_descriptor = user_connection.websocket.get_file_descriptor(
)
user_connection.subscription_file_descriptor = user_connection.subscription.get_file_descriptor(
)
listening_fds = [
user_connection.websocket_file_descriptor,
user_connection.subscription_file_descriptor
]
# TODO: if this is a resubscription, we should allow some catch-up mechanism
while user_connection.connected:
ready_file_descriptors = self.select(
listening_fds, [], [],
settings.WEBSOCKET_HEARTBEAT_INTERVAL)[0]
user_connection.process_file_descriptors(
ready_file_descriptors)
except WebSocketError as excpt:
logger.warning("WebSocketError: {}".format(excpt),
exc_info=sys.exc_info())
response = http.HttpResponse(status=1001,
content="Websocket Closed")
except UpgradeRequiredError as excpt:
logger.info("Websocket upgrade required")
response = http.HttpResponseBadRequest(
status=426, content="Websocket upgrade required")
except HandshakeError as excpt:
logger.warning('HandshakeError: {}'.format(excpt),
exc_info=sys.exc_info())
response = http.HttpResponseBadRequest(content="Handshake error")
except PermissionDenied as excpt:
logger.warning('PermissionDenied: {}'.format(excpt),
exc_info=sys.exc_info())
response = http.HttpResponseForbidden(content="Permission denied!")
except Exception as excpt:
logger.error('Other Exception: {}'.format(excpt),
exc_info=sys.exc_info())
response = http.HttpResponseServerError(content="It's broken!")
else:
response = http.HttpResponse()
finally:
if user_connection:
user_connection.close()
return response
def post(self, request, *args, **kwargs):
info = msgpack.loads(request.body, raw=False)
project_name = kwargs.get('username')
beamline_name = kwargs.get('beamline')
try:
project = Project.objects.get(username__exact=project_name)
except Project.DoesNotExist:
raise http.Http404("Project does not exist.")
try:
beamline = Beamline.objects.get(acronym=beamline_name)
except:
raise http.Http404("Beamline does not exist")
# Download key
try:
key = make_secure_path(info.get('directory'))
except ValueError:
return http.HttpResponseServerError("Unable to create SecurePath")
session = beamline.active_session()
sample = project.samples.filter(pk=info.get('sample_id')).first()
data = Data.objects.filter(pk=info.get('id')).first()
details = {
'session': (session and session.project == project) and session
or None,
'project': project,
'beamline': beamline,
'url': key,
'sample': sample,
'group': sample and sample.group or None,
}
base_fields = [
'energy', 'frames', 'file_name', 'exposure_time', 'attenuation',
'name', 'beam_size'
]
details.update({
f: info.get(f in TRANSFORMS and TRANSFORMS[f] or f)
for f in base_fields
})
details.update(kind=DataType.objects.get_by_natural_key(info['type']))
num_frames = 1
if info.get('frames'):
num_frames = len(parse_frames(info['frames']))
details.update(num_frames=num_frames)
# Set start and end time for dataset
end_time = timezone.now(
) if 'end_time' not in info else dateparse.parse_datetime(
info['end_time'])
start_time = (
end_time - timedelta(seconds=(num_frames * info['exposure_time']))
) if 'start_time' not in info else dateparse.parse_datetime(
info['start_time'])
details.update(start_time=start_time, end_time=end_time)
for k in [
'sample_id', 'group', 'port', 'frames', 'energy', 'filename',
'exposure', 'attenuation', 'container', 'name', 'directory',
'type', 'id'
]:
if k in info:
info.pop(k)
details['meta_data'] = info
if data:
Data.objects.filter(pk=data.pk).update(**details)
else:
data, created = Data.objects.get_or_create(**details)
ActivityLog.objects.log_activity(
request, data, ActivityLog.TYPE.CREATE,
"{} uploaded from {}".format(data.kind.name, beamline.acronym))
return JsonResponse({'id': data.pk})
def error500(request, template_name='500.html'):
#TODO: if user is admin include debug info
t = loader.get_template(template_name)
return http.HttpResponseServerError(t.render(RequestContext(request, {
'project_name': settings.PROJECT_TITLE})))
def http_500(self):
return http.HttpResponseServerError()
def server_error(request):
template = loader.get_template('error/default.html')
model = ErrorViewModel(status=500, exception='Server Error')
return http.HttpResponseServerError(template.render(Context(model)))
def event_hook_handler(
request, # type: d_http.HttpRequest
): # type: (...) -> d_http.HttpResponse
if not SLACK_VERIFICATION_TOKEN:
LOGGER.critical(
"EMOJIWATCH['slack_verification_token'] setting is missing")
return d_http.HttpResponseServerError()
slack_retry_num = request.META.get('HTTP_X_SLACK_RETRY_NUM', 0)
slack_retry_reason = request.META.get('HTTP_X_SLACK_RETRY_REASON', None)
if slack_retry_num:
LOGGER.info(gettext("Slack retry attempt %s ('%s')"), slack_retry_num,
slack_retry_reason)
content_type = request.META.get('HTTP_CONTENT_TYPE', 'application/json')
if content_type != 'application/json' \
or request.encoding not in {None, 'utf-8', 'UTF-8', 'csUTF8'}:
return d_http.HttpResponse(status_code=415)
try:
payload_data = json.loads(
request.body.decode('utf-8')) # type: typing.Dict
except (JSONDecodeError, UnicodeDecodeError):
LOGGER.info(gettext('unable to parse JSON from request body'))
truncate_len = 1024
half_truncate_len = truncate_len >> 1
if len(request.body) > truncate_len:
LOGGER.debug(
'%r', request.body[:half_truncate_len] + b'<...>' +
request.body[-half_truncate_len:])
else:
LOGGER.debug('%r', request.body)
return d_http.HttpResponseBadRequest()
try:
try:
verification_token = payload_data['token']
except (KeyError, TypeError):
verification_token = None
LOGGER.info(
gettext(_UNRECOGNIZED_JSON_BODY_ERR + " (missing 'token')")) # pylint: disable=logging-not-lazy
if not verification_token \
or verification_token != SLACK_VERIFICATION_TOKEN:
raise RequestPayloadValidationError(
message=gettext('bad verification token'),
response=d_http.HttpResponseForbidden(),
)
try:
call_type = payload_data['type']
except KeyError:
raise RequestPayloadValidationError(
message=gettext(_UNRECOGNIZED_JSON_BODY_ERR +
" (missing 'type')"), )
if call_type == 'url_verification':
try:
challenge = payload_data['challenge']
except KeyError:
raise RequestPayloadValidationError(
message=gettext(_UNRECOGNIZED_JSON_BODY_ERR +
" (missing 'challenge')"), )
if not isinstance(challenge, str) \
or len(challenge) > _CHALLENGE_MAX_LEN:
raise RequestPayloadValidationError(
message=gettext(_UNRECOGNIZED_JSON_BODY_ERR +
' (unrecognized challenge)'), )
return d_http.HttpResponse(challenge, content_type='text/plain')
if call_type != 'event_callback':
raise RequestPayloadValidationError(
message=gettext('unrecognized call type'), )
try:
event = payload_data.get('event', {})
event_type = event['type']
event_subtype = event['subtype']
team_id = payload_data['team_id']
except (AttributeError, KeyError, TypeError):
raise RequestPayloadValidationError()
if not isinstance(event_type, str) \
or len(event_type) > _FIELD_MAX_LEN \
or event_type != 'emoji_changed':
raise RequestPayloadValidationError(
message=gettext(_UNRECOGNIZED_JSON_BODY_ERR +
' (unrecognized event type)'), )
try:
if not isinstance(event_subtype, str) \
or len(event_subtype) > _FIELD_MAX_LEN:
raise ValueError
subhandler = _SUB_HANDLERS_BY_SUBTYPE[event_subtype]
except (KeyError, ValueError):
raise RequestPayloadValidationError(
message=gettext(_UNRECOGNIZED_JSON_BODY_ERR +
' (unrecognized event subtype)'), )
if not isinstance(team_id, str) \
or len(team_id) > TEAM_ID_MAX_LEN \
or not re.search(TEAM_ID_RE, team_id):
raise RequestPayloadValidationError(
message=gettext(_UNRECOGNIZED_JSON_BODY_ERR +
' (unrecognized team_id)'), )
team = SlackWorkspaceEmojiWatcher.objects.filter(
team_id=team_id).first()
if team is None:
raise RequestPayloadValidationError(
message=gettext('no such team ({})').format(team_id), )
try:
# By this point we're confident that event is a dict
subhandler(team, event)
except slacker.Error as exc:
if exc.args == ('invalid_auth', ):
raise RequestPayloadValidationError(
message=gettext('call to Slack API failed auth'),
response=d_http.HttpResponseForbidden(),
)
# Log, but otherwise ignore errors from our callbacks to Slack's
# API
LOGGER.info(gettext('falled call to Slack'))
LOGGER.debug(_SHRUG, exc_info=True)
except RequestPayloadValidationError as exc:
if exc.message:
LOGGER.info(exc.message)
LOGGER.debug('%r', payload_data)
return exc.response
return d_http.HttpResponse()
def server_error(request):
"""Make MEDIA_URL available to the 500 template."""
t = loader.get_template('500.html')
return http.HttpResponseServerError(t.render(Context({
'MEDIA_URL': settings.MEDIA_URL,
})))
def handler(self):
return http.HttpResponseServerError(self, self.error_string)
def ajax_get_state(request, **kwargs):
formdata = request.REQUEST.copy()
try:
if formdata.has_key("country"):
country_field = 'country'
elif formdata.has_key("ship_country"):
country_field = 'ship_country'
else:
raise AjaxGetStateException("No country specified")
form = ContactInfoForm(data=formdata)
country_data = formdata.get(country_field)
try:
country_obj = form.fields[country_field].clean(country_data)
except:
raise AjaxGetStateException("Invalid country specified")
areas = area_choices_for_country(country_obj, ugettext)
context = RequestContext(request, {
'areas': areas,
})
return render_to_response('contact/_state_choices.html',
context_instance=context)
except AjaxGetStateException, e:
log.error("ajax_get_state aborting: %s" % e.message)
return http.HttpResponseServerError()
})
return http.HttpResponseNotFound(blob, content_type=JSON)
except PermissionDenied, e:
blob = json.dumps({
'success': False,
'error': 403,
'message': str(e),
})
return http.HttpResponseForbidden(blob, content_type=JSON)
except Exception, e:
blob = json.dumps({
'success': False,
'error': 500,
'message': str(e),
})
return http.HttpResponseServerError(blob, content_type=JSON)
return _wrapped
def cors_enabled(origin, methods=['GET']):
"""A simple decorator to enable CORS."""
def decorator(f):
@wraps(f)
def decorated_func(request, *args, **kwargs):
if request.method == 'OPTIONS':
# preflight
if ('HTTP_ACCESS_CONTROL_REQUEST_METHOD' in request.META and
'HTTP_ACCESS_CONTROL_REQUEST_HEADERS' in request.META):
response = http.HttpResponse()
def get(self, request, sku_id):
"""提供商品详情页"""
# 接收和校验参数
try:
# 查询sku
sku = SKU.objects.get(id=sku_id)
except SKU.DoesNotExist:
# return http.HttpResponseNotFound('sku_id 不存在')
return render(request, '404.html')
# 查询商品分类
categories = get_categories()
# 查询面包屑导航
breadcrumb = get_breadcrumb(sku.category)
# 构建当前商品的规格键
sku_specs = sku.specs.order_by('spec_id')
sku_key = []
for spec in sku_specs:
sku_key.append(spec.option.id)
# 获取当前商品的所有SKU
skus = sku.spu.sku_set.all()
# 构建不同规格参数（选项）的sku字典
spec_sku_map = {}
for s in skus:
# 获取sku的规格参数
s_specs = s.specs.order_by('spec_id')
# 用于形成规格参数-sku字典的键
key = []
for spec in s_specs:
key.append(spec.option.id)
# key [8, 12]
# 向规格参数-sku字典添加记录
# spec_sku_map { ('颜色的id', '内存的id'): sku_id}
spec_sku_map[tuple(key)] = s.id
# { (8, 12): 4 , (9, 11): 5 }
# 获取当前商品的规格信息
goods_specs = sku.spu.specs.order_by('id')
# 若当前sku的规格信息不完整，则不再继续
if len(sku_key) < len(goods_specs):
return http.HttpResponseServerError('数据错误')
# sku_key : [ '当前sku的颜色的id', '当前sku的内存的id']
# spec_sku_map {('颜色的id', '内存的id'): sku_id}
for index, spec in enumerate(goods_specs):
# 复制当前sku的规格键
# key = sku_key[:]
key = copy.deepcopy(sku_key)
# key [8， 11]
# [ '当前sku的颜色的id', '当前sku的内存的id']
# 该规格的选项
spec_options = spec.options.all()
for option in spec_options:
# 在规格参数sku字典中查找符合当前规格的sku
# [ '当前sku的颜色的id', '当前sku的内存的id']
key[index] = option.id
# option.sku_id =
# spec_sku_map {('颜色的id', '内存的id'): sku_id}
option.sku_id = spec_sku_map.get(tuple(key))
spec.spec_options = spec_options
# 构造上下文
context = {
'categories': categories,
'breadcrumb': breadcrumb,
'sku': sku,
'specs': goods_specs,
'sku_id': sku.id,
}
return render(request, 'detail.html', context)
def _paypal(request):
def _log_error_with_data(msg, request):
"""Log a message along with some of the POST info from PayPal."""
id = random.randint(0, 99999999)
msg = "[%s] %s (dumping data)" % (id, msg)
paypal_log.error(msg)
logme = {'txn_id': request.POST.get('txn_id'),
'txn_type': request.POST.get('txn_type'),
'payer_email': request.POST.get('payer_email'),
'receiver_email': request.POST.get('receiver_email'),
'payment_status': request.POST.get('payment_status'),
'payment_type': request.POST.get('payment_type'),
'mc_gross': request.POST.get('mc_gross'),
'item_number': request.POST.get('item_number'),
}
paypal_log.error("[%s] PayPal Data: %s" % (id, logme))
if request.method != 'POST':
return http.HttpResponseNotAllowed(['POST'])
if not request.META['CONTENT_LENGTH']:
post = {}
raw = ""
else:
# Copying request.POST to avoid this issue:
# http://code.djangoproject.com/ticket/12522
post = request.POST.copy()
raw = request.raw_post_data
# Check that the request is valid and coming from PayPal.
data = '%s&%s' % ('cmd=_notify-validate', raw)
paypal_response = urllib2.urlopen(settings.PAYPAL_CGI_URL,
data, 20).readline()
if paypal_response != 'VERIFIED':
msg = ("Expecting 'VERIFIED' from PayPal, got '%s'. "
"Failing." % paypal_response)
_log_error_with_data(msg, request)
return http.HttpResponseForbidden('Invalid confirmation')
if post.get('txn_type', '').startswith('subscr_'):
SubscriptionEvent.objects.create(post_data=php.serialize(post))
return http.HttpResponse('Success!')
# List of (old, new) codes so we can transpose the data for
# embedded payments.
for old, new in [('payment_status', 'status'),
('item_number', 'tracking_id'),
('txn_id', 'tracking_id')]:
if old not in post and new in post:
post[old] = post[new]
# We only care about completed transactions.
if post.get('payment_status', '').lower() != 'completed':
return http.HttpResponse('Payment not completed')
# Make sure transaction has not yet been processed.
if (Contribution.objects
.filter(transaction_id=post['txn_id']).count()) > 0:
return http.HttpResponse('Transaction already processed')
# Fetch and update the contribution - item_number is the uuid we created.
try:
c = Contribution.objects.get(uuid=post['item_number'])
except Contribution.DoesNotExist:
key = "%s%s:%s" % (settings.CACHE_PREFIX, 'contrib',
post['item_number'])
count = cache.get(key, 0) + 1
paypal_log.warning('Contribution (uuid=%s) not found for IPN request '
'#%s.' % (post['item_number'], count))
if count > 10:
msg = ("Paypal sent a transaction that we don't know "
"about and we're giving up on it.")
_log_error_with_data(msg, request)
cache.delete(key)
return http.HttpResponse('Transaction not found; skipping.')
cache.set(key, count, 1209600) # This is 2 weeks.
return http.HttpResponseServerError('Contribution not found')
c.transaction_id = post['txn_id']
# Embedded payments does not send an mc_gross.
if 'mc_gross' in post:
c.amount = post['mc_gross']
c.uuid = None
c.post_data = php.serialize(post)
c.save()
# Send thankyou email.
try:
c.mail_thankyou(request)
except ContributionError as e:
# A failed thankyou email is not a show stopper, but is good to know.
paypal_log.error('Thankyou note email failed with error: %s' % e)
return http.HttpResponse('Success!')
def __call__(self, environ, start_response):
"""
Hijack the main loop from the original thread and listen on events on the Redis
and the Websocket filedescriptors.
"""
websocket = None
subscriber = self.Subscriber(self._redis_connection)
try:
self.assure_protocol_requirements(environ)
request = WSGIRequest(environ)
if callable(private_settings.WS4REDIS_PROCESS_REQUEST):
private_settings.WS4REDIS_PROCESS_REQUEST(request)
else:
self.process_request(request)
channels, echo_message = self.process_subscriptions(request)
if callable(private_settings.WS4REDIS_ALLOWED_CHANNELS):
channels = list(
private_settings.WS4REDIS_ALLOWED_CHANNELS(
request, channels))
websocket = self.upgrade_websocket(environ, start_response)
logger.debug('Subscribed to channels: {0}'.format(
', '.join(channels)))
subscriber.set_pubsub_channels(request, channels)
websocket_fd = websocket.get_file_descriptor()
listening_fds = [websocket_fd]
redis_fd = subscriber.get_file_descriptor()
if redis_fd:
listening_fds.append(redis_fd)
subscriber.send_persited_messages(websocket)
recvmsg = None
while websocket and not websocket.closed:
ready = self.select(listening_fds, [], [], 4.0)[0]
if not ready:
# flush empty socket
websocket.flush()
for fd in ready:
if fd == websocket_fd:
recvmsg = RedisMessage(websocket.receive())
if recvmsg:
subscriber.publish_message(recvmsg)
elif fd == redis_fd:
sendmsg = RedisMessage(subscriber.parse_response())
if sendmsg and (echo_message or sendmsg != recvmsg):
websocket.send(sendmsg)
else:
logger.error('Invalid file descriptor: {0}'.format(fd))
# Check again that the websocket is closed before sending the heartbeat,
# because the websocket can closed previously in the loop.
if private_settings.WS4REDIS_HEARTBEAT and not websocket.closed:
websocket.send(private_settings.WS4REDIS_HEARTBEAT)
except WebSocketError as excpt:
logger.warning('WebSocketError: {}'.format(excpt),
exc_info=sys.exc_info())
response = http.HttpResponse(status=1001,
content='Websocket Closed')
except UpgradeRequiredError as excpt:
logger.info('Websocket upgrade required')
response = http.HttpResponseBadRequest(status=426, content=excpt)
except HandshakeError as excpt:
logger.warning('HandshakeError: {}'.format(excpt),
exc_info=sys.exc_info())
response = http.HttpResponseBadRequest(content=excpt)
except PermissionDenied as excpt:
logger.warning('PermissionDenied: {}'.format(excpt),
exc_info=sys.exc_info())
response = http.HttpResponseForbidden(content=excpt)
except Exception as excpt:
logger.error('Other Exception: {}'.format(excpt),
exc_info=sys.exc_info())
response = http.HttpResponseServerError(content=excpt)
else:
response = http.HttpResponse()
finally:
subscriber.release()
if websocket:
websocket.close(code=1001, message='Websocket Closed')
else:
logger.warning('Starting late response on websocket')
status_text = http_client.responses.get(
response.status_code, 'UNKNOWN STATUS CODE')
status = '{0} {1}'.format(response.status_code, status_text)
headers = response._headers.values()
if six.PY3:
headers = list(headers)
start_response(force_str(status), headers)
logger.info(
'Finish non-websocket response with status code: {}'.
format(response.status_code))
return response
def __call__(self, environ, start_response):
""" Hijack the main loop from the original thread and listen on events on Redis and Websockets"""
websocket = None
subscriber = self.Subscriber(self._redis_connection)
try:
self.assure_protocol_requirements(environ)
request = WSGIRequest(environ)
self.process_request(request)
channels, echo_message = self.process_subscriptions(request)
if callable(private_settings.WS4REDIS_ALLOWED_CHANNELS):
channels = list(
private_settings.WS4REDIS_ALLOWED_CHANNELS(
request, channels))
websocket = self.upgrade_websocket(environ, start_response)
logger.debug('Subscribed to channels: {0}'.format(
', '.join(channels)))
subscriber.set_pubsub_channels(request, channels)
websocket_fd = websocket.get_file_descriptor()
listening_fds = [websocket_fd]
redis_fd = subscriber.get_file_descriptor()
if redis_fd:
listening_fds.append(redis_fd)
subscriber.send_persited_messages(websocket)
recvmsg = None
while websocket and not websocket.closed:
ready = self.select(listening_fds, [], [], 4.0)[0]
if not ready:
# flush empty socket
websocket.flush()
for fd in ready:
if fd == websocket_fd:
recvmsg = RedisMessage(websocket.receive())
if recvmsg:
subscriber.publish_message(recvmsg)
elif fd == redis_fd:
sendmsg = RedisMessage(subscriber.parse_response())
if sendmsg and (echo_message or sendmsg != recvmsg):
websocket.send(sendmsg)
else:
logger.error('Invalid file descriptor: {0}'.format(fd))
if private_settings.WS4REDIS_HEARTBEAT:
websocket.send(private_settings.WS4REDIS_HEARTBEAT)
except WebSocketError as excpt:
logger.warning('WebSocketError: ', exc_info=sys.exc_info())
response = http.HttpResponse(status=1001,
content='Websocket Closed')
except UpgradeRequiredError as excpt:
logger.info('Websocket upgrade required')
response = http.HttpResponseBadRequest(status=426, content=excpt)
except HandshakeError as excpt:
logger.warning('HandshakeError: ', exc_info=sys.exc_info())
response = http.HttpResponseBadRequest(content=excpt)
except PermissionDenied as excpt:
logger.warning('PermissionDenied: ', exc_info=sys.exc_info())
response = http.HttpResponseForbidden(content=excpt)
except Exception as excpt:
logger.error('Other Exception: ', exc_info=sys.exc_info())
response = http.HttpResponseServerError(content=excpt)
else:
response = http.HttpResponse()
if websocket:
websocket.close(code=1001, message='Websocket Closed')
#Kai Peng - We need to close Redis Subscriptions to prevent unbound memory consumption upon websocket closing
if subscriber:
subscriber.unsubscribe_pubsub_channels()
#Kai Peng
if hasattr(start_response,
'im_self') and not start_response.im_self.headers_sent:
logger.warning('Staring late response on websocket')
status_text = STATUS_CODE_TEXT.get(response.status_code,
'UNKNOWN STATUS CODE')
status = '{0} {1}'.format(response.status_code, status_text)
start_response(force_str(status), response._headers.values())
logger.info('Finish long living response with status code: '.format(
response.status_code))
return response
def handler500(request, template_name='500.html'):
t = loader.get_template(template_name)
return http.HttpResponseServerError(t.render(RequestContext(request)))
def custom_500(request):
"""Custom 500 error handler."""
return http.HttpResponseServerError(render(request, '500.html'))
def render_failure(self, failure: CaseError,
**kwargs) -> http.HttpResponse:
return http.HttpResponseServerError()
def server_500_error(request, template_name='500.html'):
t = loader.get_template(template_name) # You need to create a 500.html template.
return http.HttpResponseServerError(t.render(Context({
'MEDIA_URL': settings.MEDIA_URL
})))
def dispatch(self, request, **kwargs):
'''
Processes the REST request and routes it wherever it needs to be routed
'''
logger.debug('Language in dispatcher: {0}'.format(request.LANGUAGE_CODE))
from uds.REST import processors
# Remove session, so response middleware do nothing with this
del request.session
# Now we extract method and possible variables from path
path = kwargs['arguments'].split('/')
del kwargs['arguments']
# Transverse service nodes too look for path
service = Dispatcher.services
full_path = []
content_type = None
cls = None
while len(path) > 0:
# .json, .xml, ... will break path recursion
if path[0].find('.') != -1:
content_type = path[0].split('.')[1]
clean_path = path[0].split('.')[0]
if clean_path in service:
service = service[clean_path]
full_path.append(path[0])
path = path[1:]
else:
break
full_path = '/'.join(full_path)
logger.debug("REST request: {} ({})".format(full_path, content_type))
# Here, service points to the path
cls = service['']
if cls is None:
return http.HttpResponseNotFound('method not found')
# Guess content type from content type header (post) or ".xxx" to method
try:
processor = processors.available_processors_ext_dict[content_type](request)
except Exception:
processor = processors.available_processors_mime_dict.get(request.META.get('CONTENT_TYPE', 'json'), processors.default_processor)(request)
# Obtain method to be invoked
http_method = request.method.lower()
args = path
try:
handler = cls(request, full_path, http_method, processor.processParameters(), *args, **kwargs)
operation = getattr(handler, http_method)
except processors.ParametersException as e:
logger.debug('Path: {0}'.format(full_path))
logger.debug('Error: {0}'.format(e))
return http.HttpResponseServerError('Invalid parameters invoking {0}: {1}'.format(full_path, e))
except AttributeError:
allowedMethods = []
for n in ['get', 'post', 'put', 'delete']:
if hasattr(handler, n):
allowedMethods.append(n)
return http.HttpResponseNotAllowed(allowedMethods)
except AccessDenied:
return http.HttpResponseForbidden('access denied')
except Exception:
logger.exception('error accessing attribute')
logger.debug('Getting attribute {0} for {1}'.format(http_method, full_path))
return http.HttpResponseServerError('Unexcepected error')
# Invokes the handler's operation, add headers to response and returns
try:
start = time.time()
response = operation()
logger.debug('Execution time for method: {0}'.format(time.time() - start))
if not handler.raw: # Raw handlers will return an HttpResponse Object
start = time.time()
response = processor.getResponse(response)
logger.debug('Execution time for encoding: {0}'.format(time.time() - start))
for k, val in six.iteritems(handler.headers()):
response[k] = val
return response
except RequestError as e:
return http.HttpResponseBadRequest(six.text_type(e))
except ResponseError as e:
return http.HttpResponseServerError(six.text_type(e))
except NotSupportedError as e:
return http.HttpResponseBadRequest(six.text_type(e))
except AccessDenied as e:
return http.HttpResponseForbidden(six.text_type(e))
except NotFound as e:
return http.HttpResponseNotFound(six.text_type(e))
except HandlerError as e:
return http.HttpResponseBadRequest(six.text_type(e))
except Exception as e:
logger.exception('Error processing request')
return http.HttpResponseServerError(six.text_type(e))
