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))