def comments(request, page=1):
perPage = 20
slice_start = perPage * int(page) - perPage
slice_end = perPage * int(page)
comments = Comments.objects.filter(is_removed=False).order_by('-posted')
amount = len(comments)
rowsRange = int(math.ceil(amount / float(perPage))) # amount of rows
comments = comments[slice_start:slice_end]
amount_this_page = len(comments)
if amount_this_page == 0 and int(page) != 1:
return HttpResponseRedirect("/comments/")
last_comment_id_seen = request.COOKIES.get('last_comment_id_seen',
comments[0].id)
template = loader.get_template('index.html')
template_args = {
'content': 'comments.html',
'request': request,
'title': ' - Comments',
'comments': comments,
'amount': amount,
'amount_this_page': amount_this_page,
'range': [i + 1 for i in range(rowsRange)],
'page': int(page),
'last_comment_id_seen': int(last_comment_id_seen),
}
response = StreamingHttpResponse(template.render(template_args, request))
if int(page) == 1:
response.set_cookie('last_comment_id_seen',
comments[0].id,
max_age=4320000)
return response
def load_course_tab(request, slug):
course = get_object_or_404(Course, slug=slug)
user = get_object_or_404(jUser, id=request.user.id)
page = request.GET.get("page")
if page is None or page not in AVAILABLE_COURSE_PAGES:
page = AVAILABLE_COURSE_PAGES[1]
context = {
"current_tab": page,
"STATIC_URL": settings.STATIC_URL,
"user_auth": user
}
context.update(course_page_context(request, course, page))
context.update(csrf(request))
sidebar_content = render_to_string(
"objects/course/sidebar_tab_content.html", context)
main_content = render_to_string("objects/course/course_tab_content.html",
context)
data = {"status": "OK", "sidebar": sidebar_content, "main": main_content}
response = StreamingHttpResponse(json.dumps(data))
if context.get('activities'):
print "setting cookie"
response.set_cookie("oldest_activity_id",
str(context['activities'][-1]['activity'].id),
path="/")
return response
def comments(request, page=1):
perPage = 20
slice_start = perPage*int(page)-perPage
slice_end = perPage*int(page)
comments = Comments.objects.filter(is_removed=False).order_by('-posted')
amount = len(comments)
rowsRange = int(math.ceil(amount/float(perPage))) # amount of rows
comments = comments[slice_start:slice_end]
amount_this_page = len(comments)
if amount_this_page == 0 and int(page) != 1:
return HttpResponseRedirect("/comments/")
last_comment_id_seen = request.COOKIES.get('last_comment_id_seen', comments[0].id)
template = loader.get_template('index.html')
template_args = {
'content': 'comments.html',
'request': request,
'title': ' - Comments',
'comments': comments,
'amount': amount,
'amount_this_page': amount_this_page,
'range': [i+1 for i in range(rowsRange)],
'page': int(page),
'last_comment_id_seen': int(last_comment_id_seen),
}
response = StreamingHttpResponse(template.render(template_args, request))
if int(page) == 1:
response.set_cookie('last_comment_id_seen', comments[0].id, max_age=4320000)
return response
def generate_response(filepath, content_type, filename=None):
filename = filename or os.path.basename(filepath)
response = StreamingHttpResponse(export_iterator(filepath), content_type=content_type)
response['Content-Length'] = default_storage.size(filepath)
response['Content-Disposition'] = "attachment; filename=%s" % filename
response.set_cookie(key='fileDownload', value="true")
response.set_cookie(key='path', value="/")
return response
def generate_response(filepath, content_type, filename=None):
filename = filename or os.path.basename(filepath)
response = StreamingHttpResponse(export_iterator(filepath),
content_type=content_type)
response['Content-Length'] = default_storage.size(filepath)
response['Content-Disposition'] = "attachment; filename=%s" % filename
response.set_cookie(key='fileDownload', value="true")
response.set_cookie(key='path', value="/")
return response
def get_django_response(proxy_response, strict_cookies=False):
"""This method is used to create an appropriate response based on the
Content-Length of the proxy_response. If the content is bigger than
MIN_STREAMING_LENGTH, which is found on utils.py,
than django.http.StreamingHttpResponse will be created,
else a django.http.HTTPResponse will be created instead
:param proxy_response: An Instance of urllib3.response.HTTPResponse that
will create an appropriate response
:param strict_cookies: Whether to only accept RFC-compliant cookies
:returns: Returns an appropriate response based on the proxy_response
content-length
"""
status = proxy_response.status
headers = proxy_response.headers
logger.debug('Proxy response headers: %s', headers)
content_type = headers.get('Content-Type')
logger.debug('Content-Type: %s', content_type)
if should_stream(proxy_response):
logger.info('Content-Length is bigger than %s', DEFAULT_AMT)
response = StreamingHttpResponse(proxy_response.stream(DEFAULT_AMT),
status=status,
content_type=content_type)
else:
content = proxy_response.data or b''
response = HttpResponse(content,
status=status,
content_type=content_type)
logger.info('Normalizing response headers')
set_response_headers(response, headers)
logger.debug('Response headers: %s', getattr(response, '_headers'))
cookies = proxy_response.headers.getlist('set-cookie')
logger.info('Checking for invalid cookies')
for cookie_string in cookies:
cookie_dict = cookie_from_string(cookie_string,
strict_cookies=strict_cookies)
# if cookie is invalid cookie_dict will be None
if cookie_dict:
response.set_cookie(**cookie_dict)
logger.debug('Response cookies: %s', response.cookies)
return response
def get_django_response(proxy_response, strict_cookies=False):
"""This method is used to create an appropriate response based on the
Content-Length of the proxy_response. If the content is bigger than
MIN_STREAMING_LENGTH, which is found on utils.py,
than django.http.StreamingHttpResponse will be created,
else a django.http.HTTPResponse will be created instead
:param proxy_response: An Instance of urllib3.response.HTTPResponse that
will create an appropriate response
:param strict_cookies: Whether to only accept RFC-compliant cookies
:returns: Returns an appropriate response based on the proxy_response
content-length
"""
status = proxy_response.status
headers = proxy_response.headers
logger.debug('Proxy response headers: %s', headers)
content_type = headers.get('Content-Type')
logger.debug('Content-Type: %s', content_type)
if should_stream(proxy_response):
logger.info('Content-Length is bigger than %s', DEFAULT_AMT)
response = StreamingHttpResponse(proxy_response.stream(DEFAULT_AMT),
status=status,
content_type=content_type)
else:
content = proxy_response.data or b''
response = HttpResponse(content, status=status,
content_type=content_type)
logger.info('Normalizing response headers')
set_response_headers(response, headers)
logger.debug('Response headers: %s', getattr(response, '_headers'))
cookies = proxy_response.headers.getlist('set-cookie')
logger.info('Checking for invalid cookies')
for cookie_string in cookies:
cookie_dict = cookie_from_string(cookie_string,
strict_cookies=strict_cookies)
# if cookie is invalid cookie_dict will be None
if cookie_dict:
response.set_cookie(**cookie_dict)
logger.debug('Response cookies: %s', response.cookies)
return response
def get_django_response(proxy_response):
"""This method is used to create an appropriate response based on the
Content-Length of the proxy_response. If the content is bigger than
MIN_STREAMING_LENGTH, which is found on utils.py,
than django.http.StreamingHttpResponse will be created,
else a django.http.HTTPResponse will be created instead
:param proxy_response: An Instance of urllib3.response.HTTPResponse that
will create an appropriate response
:returns: Returns an appropriate response based on the proxy_response
content-length
"""
status = proxy_response.status
headers = proxy_response.headers
logger.debug('Proxy response headers: %s', headers)
content_type = headers.get('Content-Type')
logger.debug('Content-Type: %s', content_type)
if should_stream(proxy_response):
logger.info('Content-Length is bigger than %s', DEFAULT_AMT)
response = StreamingHttpResponse(proxy_response.stream(DEFAULT_AMT),
status=status,
content_type=content_type)
else:
content = proxy_response.data or b''
response = HttpResponse(content, status=status,
content_type=content_type)
logger.info("Normalizing headers that aren't in IGNORE_HEADERS")
for header, value in headers.items():
if header.lower() not in IGNORE_HEADERS:
response[header.title()] = value
logger.debug('Response headers: %s', getattr(response, '_headers'))
cookies = proxy_response.headers.getlist('set-cookie')
logger.info('Checking for invalid cookies')
for cookie_string in cookies:
cookie_dict = cookie_from_string(cookie_string)
# if cookie is invalid cookie_dict will be None
if cookie_dict:
response.set_cookie(**cookie_dict)
logger.debug('Response cookies: %s', response.cookies)
return response
def load_course_activities(request, slug):
course = get_object_or_404(Course, slug=slug)
user = request.user.juser
activities = course_activities(request, course)
if len(activities) == 0:
return HttpResponse(json.dumps({'status': "OK", 'html': ""}))
context = {"activities": activities, "user_auth": user}
context.update(csrf(request))
html = render_to_string('objects/dashboard/activity_timeline.html',
context)
data = {'status': "OK", 'html': html}
response = StreamingHttpResponse(json.dumps(data))
if activities:
response.set_cookie("oldest_activity_id",
str(activities[-1]['activity'].id),
path="/")
return response
def _render_response(self,
status_code: int,
headers: ty.Mapping[str, ty.Any],
cookies: ty.Iterable[Cookie],
instance: ty.Any,
args: ViewArgs,
kwargs: ViewKwargs,
content_type: ty.Optional[str] = None,
content_length: ty.Optional[int] = None,
content: ty.Any = t.Undefined,
content_kind: ContentKind = ContentKind.UNDEFINED,
**context: ty.Any) -> HttpResponse:
if content_kind == ContentKind.STREAMING:
response = StreamingHttpResponse(streaming_content=content,
content_type=content_type,
status=status_code)
elif content_kind == ContentKind.MEDIA:
response = HttpResponse(content=content,
content_type=content_type,
status=status_code)
else:
response = HttpResponse(content_type=content_type,
status=status_code)
for name, value in headers.items():
response[name] = value
if content_length is not None:
response['content-length'] = str(content_length)
for cookie in cookies:
response.set_cookie(cookie.name,
value=cookie.value,
max_age=cookie.max_age,
expires=cookie.expires,
path=cookie.path,
domain=cookie.domain,
secure=cookie.secure,
httponly=cookie.http_only,
samesite=cookie.same_site)
return response
def load_profile_activities(request, username):
user = get_object_or_404(jUser, username=username)
current_user = get_object_or_404(jUser, id=request.user.id)
activities = profile_activities(request, user, current_user)
if len(activities) == 0:
return HttpResponse(json.dumps({'status': "OK", 'html': ""}))
context = {"activities": activities, "user_auth": request.user.juser}
html = render_to_string('objects/dashboard/activity_timeline.html',
context)
data = {'status': "OK", 'html': html}
response = StreamingHttpResponse(json.dumps(data))
if activities:
response.set_cookie("oldest_activity_id",
str(activities[-1]['activity'].id),
path="/")
return response
def zip_view(request):
# get archive root
root = settings.ARCHIVE_ROOT
# get name for archive
archive_name = 'pyobsdata-' + datetime.datetime.now().strftime('%Y%m%d')
# create zip file
zip_file = zipstream.ZipFile()
# add files
for frame_id in request.POST.getlist('frame_ids[]'):
# get frame
frame, filename = _frame(frame_id)
# add file to zip
zip_file.write(filename, arcname=os.path.join(archive_name, os.path.basename(filename)))
# create and return response
response = StreamingHttpResponse(zip_file, content_type='application/zip')
response.set_cookie('fileDownload', 'true', path='/')
response['Content-Disposition'] = 'attachment; filename={}'.format(archive_name + '.zip')
return response
def do_request(self, request, url, method):
url = iri_to_uri(url)
request_data = {
"method": method,
"url": url,
"data": None,
"headers": {},
"cookies": Cookie.SimpleCookie(),
"user": request.user,
"original-request": request,
}
# Request creation
proto, host, cgi, param, query = urlparse.urlparse(url)[:5]
# Extract headers from META
if 'HTTP_TRANSFER_ENCODING' in request.META:
return build_error_response(request, 500, "Wirecloud doesn't support requests using Transfer-Encodings")
for header in request.META.items():
header_name = header[0].lower()
if header_name == 'content_type' and header[1]:
request_data['headers']["content-type"] = header[1]
elif header_name == 'content_length' and header[1]:
# Only take into account request body if the request has a
# Content-Length header (we don't support chunked requests)
request_data['data'] = request
# It's better not propagate the Content-Length header as
# request processors may change final data length. In addition
# to this, the requests modules ignores the Content-Length
# header and tries to obtain data length directly from the
# data parameter. Therefore, providing this value in the len
# attribute seems to be the best option
request_data['data'].len = int(header[1])
elif header_name == 'cookie' or header_name == 'http_cookie':
cookie_parser = Cookie.SimpleCookie(str(header[1]))
del cookie_parser[settings.SESSION_COOKIE_NAME]
if settings.CSRF_COOKIE_NAME in cookie_parser:
del cookie_parser[settings.CSRF_COOKIE_NAME]
request_data['cookies'].update(cookie_parser)
elif self.http_headerRE.match(header_name) and not header_name in self.blacklisted_http_headers:
fixed_name = header_name.replace("http_", "", 1).replace('_', '-')
request_data['headers'][fixed_name] = header[1]
# Build the Via header
protocolVersion = self.protocolRE.match(request.META['SERVER_PROTOCOL'])
if protocolVersion is not None:
protocolVersion = protocolVersion.group(1)
else:
protocolVersion = '1.1'
via_header = "%s %s (Wirecloud-python-Proxy/1.1)" % (protocolVersion, get_current_domain(request))
if 'via' in request_data['headers']:
request_data['headers']['via'] += ', ' + via_header
else:
request_data['headers']['via'] = via_header
# XFF headers
if 'x-forwarded-for' in request_data['headers']:
request_data['headers']['x-forwarded-for'] += ', ' + request.META['REMOTE_ADDR']
else:
request_data['headers']['x-forwarded-for'] = request.META['REMOTE_ADDR']
request_data['headers']['x-forwarded-host'] = host
if 'x-forwarded-server' in request_data['headers']:
del request_data['headers']['x-forwarded-server']
# Pass proxy processors to the new request
try:
for processor in get_request_proxy_processors():
processor.process_request(request_data)
except ValidationError as e:
return e.get_response()
# Cookies
cookie_header_content = ', '.join([cookie_parser[key].OutputString() for key in request_data['cookies']])
if cookie_header_content != '':
request_data['headers']['Cookie'] = cookie_header_content
# Open the request
try:
res = requests.request(request_data['method'], request_data['url'], headers=request_data['headers'], data=request_data['data'], stream=True)
except requests.exceptions.HTTPError:
return HttpResponse(status=504)
except requests.exceptions.ConnectionError:
return HttpResponse(status=502)
# Build a Django response
response = StreamingHttpResponse(res.raw.stream(4096, decode_content=False))
# Set status code to the response
response.status_code = res.status_code
# Add all the headers received from the response
for header in res.headers:
header_lower = header.lower()
if header_lower == 'set-cookie':
for cookie in res.cookies:
response.set_cookie(cookie.name, value=cookie.value, expires=cookie.expires, path=cookie.path)
elif header_lower == 'via':
via_header = via_header + ', ' + res.headers[header]
elif is_valid_response_header(header_lower):
response[header] = res.headers[header]
# Pass proxy processors to the response
for processor in get_response_proxy_processors():
response = processor.process_response(request_data, response)
response['Via'] = via_header
return response
def do_request(self, request, url, method, request_data):
url = iri_to_uri(url)
request_data.update({
"method": method,
"url": url,
"original-request": request,
})
request_data.setdefault("data", None)
request_data.setdefault("headers", {})
request_data.setdefault("cookies", SimpleCookie())
request_data.setdefault("user", request.user)
# Request creation
proto, host, cgi, param, query = urlparse(url)[:5]
# Build the Via header
protocolVersion = self.protocolRE.match(request.META['SERVER_PROTOCOL'])
if protocolVersion is not None:
protocolVersion = protocolVersion.group(1)
else:
protocolVersion = '1.1'
via_header = "%s %s (Wirecloud-python-Proxy/1.1)" % (protocolVersion, get_current_domain(request))
if 'via' in request_data['headers']:
request_data['headers']['via'] += ', ' + via_header
else:
request_data['headers']['via'] = via_header
# XFF headers
if 'x-forwarded-for' in request_data['headers']:
request_data['headers']['x-forwarded-for'] += ', ' + request.META['REMOTE_ADDR']
else:
request_data['headers']['x-forwarded-for'] = request.META['REMOTE_ADDR']
# Pass proxy processors to the new request
try:
for processor in get_request_proxy_processors():
processor.process_request(request_data)
except ValidationError as e:
return e.get_response(request)
# Cookies
cookie_header_content = ', '.join([request_data['cookies'][key].OutputString() for key in request_data['cookies']])
if cookie_header_content != '':
request_data['headers']['Cookie'] = cookie_header_content
# Seems that Django or WSGI provides default values for the
# Content-Length and Content-Type headers, so we are not able to detect
# if the request provided them :(
if str(request_data['headers'].get('content-length', '0')).strip() == '0':
request_data['data'] = None
if 'content-type' in request_data['headers']:
del request_data['headers']['content-type']
# Open the request
try:
res = requests.request(request_data['method'], request_data['url'], headers=request_data['headers'], data=request_data['data'], stream=True, verify=getattr(settings, 'WIRECLOUD_HTTPS_VERIFY', True))
except requests.exceptions.Timeout as e:
return build_error_response(request, 504, _('Gateway Timeout'), details=six.text_type(e))
except requests.exceptions.SSLError as e:
return build_error_response(request, 502, _('SSL Error'), details=six.text_type(e))
except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError, requests.exceptions.TooManyRedirects) as e:
return build_error_response(request, 504, _('Connection Error'), details=six.text_type(e))
# Build a Django response
response = StreamingHttpResponse(res.raw.stream(4096, decode_content=False), status=res.status_code, reason=res.reason)
# Add all the headers received from the response
for header in res.headers:
header_lower = header.lower()
if header_lower == 'set-cookie':
for cookie in res.cookies:
response.set_cookie(cookie.name, value=cookie.value, expires=cookie.expires, path=cookie.path)
elif header_lower == 'via':
via_header = via_header + ', ' + res.headers[header]
elif is_valid_response_header(header_lower):
response[header] = res.headers[header]
# Pass proxy processors to the response
for processor in get_response_proxy_processors():
response = processor.process_response(request_data, response)
response['Via'] = via_header
return response
def do_request(self, request, url, method, workspace):
url = iri_to_uri(url)
request_data = {
"method": method,
"url": url,
"data": None,
"headers": {},
"cookies": SimpleCookie(),
"user": request.user,
"workspace": workspace,
"original-request": request,
}
# Request creation
proto, host, cgi, param, query = urlparse(url)[:5]
# Extract headers from META
if 'HTTP_TRANSFER_ENCODING' in request.META:
return build_error_response(request, 500, "Wirecloud doesn't support requests using Transfer-Encodings")
for header in request.META.items():
header_name = header[0].lower()
if header_name == 'content_type' and header[1]:
request_data['headers']["content-type"] = header[1]
elif header_name == 'content_length' and header[1]:
# Only take into account request body if the request has a
# Content-Length header (we don't support chunked requests)
request_data['data'] = request
request_data['headers']['content-length'] = header[1]
request_data['data'].len = int(header[1])
elif header_name == 'cookie' or header_name == 'http_cookie':
cookie_parser = SimpleCookie(str(header[1]))
del cookie_parser[str(settings.SESSION_COOKIE_NAME)]
if str(settings.CSRF_COOKIE_NAME) in cookie_parser:
del cookie_parser[str(settings.CSRF_COOKIE_NAME)]
request_data['cookies'].update(cookie_parser)
elif self.http_headerRE.match(header_name) and not header_name in self.blacklisted_http_headers:
fixed_name = header_name.replace("http_", "", 1).replace('_', '-')
request_data['headers'][fixed_name] = header[1]
# Build the Via header
protocolVersion = self.protocolRE.match(request.META['SERVER_PROTOCOL'])
if protocolVersion is not None:
protocolVersion = protocolVersion.group(1)
else:
protocolVersion = '1.1'
via_header = "%s %s (Wirecloud-python-Proxy/1.1)" % (protocolVersion, get_current_domain(request))
if 'via' in request_data['headers']:
request_data['headers']['via'] += ', ' + via_header
else:
request_data['headers']['via'] = via_header
# XFF headers
if 'x-forwarded-for' in request_data['headers']:
request_data['headers']['x-forwarded-for'] += ', ' + request.META['REMOTE_ADDR']
else:
request_data['headers']['x-forwarded-for'] = request.META['REMOTE_ADDR']
request_data['headers']['x-forwarded-host'] = host
if 'x-forwarded-server' in request_data['headers']:
del request_data['headers']['x-forwarded-server']
# Pass proxy processors to the new request
try:
for processor in get_request_proxy_processors():
processor.process_request(request_data)
except ValidationError as e:
return e.get_response(request)
# Cookies
cookie_header_content = ', '.join([cookie_parser[key].OutputString() for key in request_data['cookies']])
if cookie_header_content != '':
request_data['headers']['Cookie'] = cookie_header_content
# Open the request
try:
res = requests.request(request_data['method'], request_data['url'], headers=request_data['headers'], data=request_data['data'], stream=True, verify=getattr(settings, 'WIRECLOUD_HTTPS_VERIFY', True))
except requests.exceptions.Timeout as e:
return build_error_response(request, 504, _('Gateway Timeout'), details=six.text_type(e))
except requests.exceptions.SSLError as e:
return build_error_response(request, 502, _('SSL Error'), details=six.text_type(e))
except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError, requests.exceptions.TooManyRedirects) as e:
return build_error_response(request, 504, _('Connection Error'), details=six.text_type(e))
# Build a Django response
response = StreamingHttpResponse(res.raw.stream(4096, decode_content=False), status=res.status_code)
if 'reason_phrase' in response: # pragma: no cover
# Currently only django 1.6+ supports custom reason phrases
response.reason_phrase = res.reason_phrase
# Add all the headers received from the response
for header in res.headers:
header_lower = header.lower()
if header_lower == 'set-cookie':
for cookie in res.cookies:
response.set_cookie(cookie.name, value=cookie.value, expires=cookie.expires, path=cookie.path)
elif header_lower == 'via':
via_header = via_header + ', ' + res.headers[header]
elif is_valid_response_header(header_lower):
response[header] = res.headers[header]
# Pass proxy processors to the response
for processor in get_response_proxy_processors():
response = processor.process_response(request_data, response)
response['Via'] = via_header
return response
def do_request(self, request, url, method, request_data):
url = iri_to_uri(url)
request_data.update({
"method": method,
"url": url,
"original-request": request,
})
request_data.setdefault("data", None)
request_data.setdefault("headers", {})
request_data.setdefault("cookies", SimpleCookie())
request_data.setdefault("user", request.user)
# Request creation
proto, host, cgi, param, query = urlparse(url)[:5]
# Build the Via header
protocolVersion = self.protocolRE.match(
request.META['SERVER_PROTOCOL'])
if protocolVersion is not None:
protocolVersion = protocolVersion.group(1)
else:
protocolVersion = '1.1'
via_header = "%s %s (Wirecloud-python-Proxy/1.1)" % (
protocolVersion, get_current_domain(request))
if 'via' in request_data['headers']:
request_data['headers']['via'] += ', ' + via_header
else:
request_data['headers']['via'] = via_header
# XFF headers
if 'x-forwarded-for' in request_data['headers']:
request_data['headers'][
'x-forwarded-for'] += ', ' + request.META['REMOTE_ADDR']
else:
request_data['headers']['x-forwarded-for'] = request.META[
'REMOTE_ADDR']
# Pass proxy processors to the new request
try:
for processor in get_request_proxy_processors():
processor.process_request(request_data)
except ValidationError as e:
return e.get_response(request)
# Cookies
cookie_header_content = ', '.join([
request_data['cookies'][key].OutputString()
for key in request_data['cookies']
])
if cookie_header_content != '':
request_data['headers']['Cookie'] = cookie_header_content
# Seems that Django or WSGI provides default values for the
# Content-Length and Content-Type headers, so we are not able to detect
# if the request provided them :(
if str(request_data['headers'].get('content-length',
'0')).strip() == '0':
request_data['data'] = None
if 'content-type' in request_data['headers']:
del request_data['headers']['content-type']
# Open the request
try:
res = requests.request(request_data['method'],
request_data['url'],
headers=request_data['headers'],
data=request_data['data'],
stream=True,
verify=getattr(settings,
'WIRECLOUD_HTTPS_VERIFY',
True))
except requests.exceptions.Timeout as e:
return build_error_response(request,
504,
_('Gateway Timeout'),
details=str(e))
except requests.exceptions.SSLError as e:
return build_error_response(request,
502,
_('SSL Error'),
details=str(e))
except (requests.exceptions.ConnectionError,
requests.exceptions.HTTPError,
requests.exceptions.TooManyRedirects) as e:
return build_error_response(request,
504,
_('Connection Error'),
details=str(e))
# Build a Django response
response = StreamingHttpResponse(res.raw.stream(4096,
decode_content=False),
status=res.status_code,
reason=res.reason)
# Add all the headers received from the response
for header in res.headers:
header_lower = header.lower()
if header_lower == 'set-cookie':
for cookie in res.cookies:
response.set_cookie(cookie.name,
value=cookie.value,
expires=cookie.expires,
path=cookie.path)
elif header_lower == 'via':
via_header = via_header + ', ' + res.headers[header]
elif is_valid_response_header(header_lower):
response[header] = res.headers[header]
# Pass proxy processors to the response
for processor in get_response_proxy_processors():
response = processor.process_response(request_data, response)
response['Via'] = via_header
return response
def post(self, request, *args, **kwargs):
vol = self.object = self.get_object()
# don't do anything if user is not logged in
if self.request.user.is_anonymous():
response = render(request, self.template_name, self.get_context_data())
response.status_code = 400 # bad request
return response
# get posted form data and use that to generate the export
export_form = self.get_form()
if export_form.is_valid():
cleaned_data = export_form.cleaned_data
# if github export is requested, make sure user has a
# github account available to use for access
if cleaned_data['github']:
try:
github.GithubApi.github_account(self.request.user)
except github.GithubAccountNotFound:
return self.render(request, error=self.github_account_msg)
# check that oauth token has sufficient permission
# to do needed export steps
gh = github.GithubApi.connect_as_user(self.request.user)
# note: repo would also work here, but currently asking for public_repo
if 'public_repo' not in gh.oauth_scopes():
return self.render(request, error=self.github_scope_msg)
else:
return self.render(request)
# determine which annotations should be loaded
if cleaned_data['annotations'] == 'user':
# annotations *by* this user
# (NOT all annotations the user can view)
annotations = vol.annotations().filter(user=request.user)
elif cleaned_data['annotations'].startswith('group:'):
# all annotations visible to a group this user belongs to
group_id = cleaned_data['annotations'][len('group:'):]
# NOTE: object not found error should not occur here,
# because only valid group ids should be valid choices
group = AnnotationGroup.objects.get(pk=group_id)
annotations = vol.annotations().visible_to_group(group)
# generate annotated tei
tei = annotate.annotated_tei(vol.generate_volume_tei(),
annotations)
# check form data to see if github repo is requested
if cleaned_data['github']:
try:
repo_url, ghpages_url = export.website_gitrepo(request.user,
cleaned_data['github_repo'], vol, tei,
page_one=cleaned_data['page_one'])
logger.info('Exported %s to GitHub repo %s for user %s',
vol.pid, repo_url, request.user.username)
# NOTE: maybe use a separate template here?
return self.render(request, repo_url=repo_url,
ghpages_url=ghpages_url, github_export=True)
except export.GithubExportException as err:
response = self.render(request, error='Export failed: %s' % err)
response.status_code = 400 # maybe?
return response
else:
# non github export: download zipfile
try:
webzipfile = export.website_zip(vol, tei,
page_one=cleaned_data['page_one'])
logger.info('Exported %s as jekyll zipfile for user %s',
vol.pid, request.user.username)
response = StreamingHttpResponse(FileWrapper(webzipfile, 8192),
content_type='application/zip')
response['Content-Disposition'] = 'attachment; filename="%s_annotated_jeyll_site.zip"' % \
(vol.noid)
response['Content-Length'] = os.path.getsize(webzipfile.name)
except export.ExportException as err:
# display error to user and redisplay the form
response = self.render(request, error='Export failed. %s' % err)
response.status_code = 500
# set a cookie to indicate download is complete, that can be
# used by javascript to hide a 'generating' indicator
completion_cookie_name = request.POST.get('completion-cookie',
'%s-web-export' % vol.noid)
response.set_cookie(completion_cookie_name, 'complete', max_age=10)
return response
def do_request(self, request, url, method, workspace):
url = iri_to_uri(url)
request_data = {
"method": method,
"url": url,
"data": None,
"headers": {},
"cookies": SimpleCookie(),
"user": request.user,
"workspace": workspace,
"original-request": request,
}
# Request creation
proto, host, cgi, param, query = urlparse(url)[:5]
# Extract headers from META
if 'HTTP_TRANSFER_ENCODING' in request.META:
return build_error_response(
request, 422,
"Wirecloud doesn't support requests using the Transfer-Encoding header"
)
for header in request.META.items():
header_name = header[0].lower()
if header_name == 'content_type' and header[1]:
request_data['headers']["content-type"] = header[1]
elif header_name == 'content_length' and header[1]:
# Only take into account request body if the request has a
# Content-Length header (we don't support chunked requests)
request_data['data'] = request
request_data['headers']['content-length'] = header[1]
request_data['data'].len = int(header[1])
elif header_name == 'cookie' or header_name == 'http_cookie':
cookie_parser = SimpleCookie(str(header[1]))
del cookie_parser[str(settings.SESSION_COOKIE_NAME)]
if str(settings.CSRF_COOKIE_NAME) in cookie_parser:
del cookie_parser[str(settings.CSRF_COOKIE_NAME)]
request_data['cookies'].update(cookie_parser)
elif self.http_headerRE.match(
header_name
) and not header_name in self.blacklisted_http_headers:
fixed_name = header_name.replace("http_", "",
1).replace('_', '-')
request_data['headers'][fixed_name] = header[1]
# Build the Via header
protocolVersion = self.protocolRE.match(
request.META['SERVER_PROTOCOL'])
if protocolVersion is not None:
protocolVersion = protocolVersion.group(1)
else:
protocolVersion = '1.1'
via_header = "%s %s (Wirecloud-python-Proxy/1.1)" % (
protocolVersion, get_current_domain(request))
if 'via' in request_data['headers']:
request_data['headers']['via'] += ', ' + via_header
else:
request_data['headers']['via'] = via_header
# XFF headers
if 'x-forwarded-for' in request_data['headers']:
request_data['headers'][
'x-forwarded-for'] += ', ' + request.META['REMOTE_ADDR']
else:
request_data['headers']['x-forwarded-for'] = request.META[
'REMOTE_ADDR']
request_data['headers']['x-forwarded-host'] = host
if 'x-forwarded-server' in request_data['headers']:
del request_data['headers']['x-forwarded-server']
# Pass proxy processors to the new request
try:
for processor in get_request_proxy_processors():
processor.process_request(request_data)
except ValidationError as e:
return e.get_response(request)
# Cookies
cookie_header_content = ', '.join([
cookie_parser[key].OutputString()
for key in request_data['cookies']
])
if cookie_header_content != '':
request_data['headers']['Cookie'] = cookie_header_content
# Open the request
try:
res = requests.request(request_data['method'],
request_data['url'],
headers=request_data['headers'],
data=request_data['data'],
stream=True,
verify=getattr(settings,
'WIRECLOUD_HTTPS_VERIFY',
True))
except requests.exceptions.Timeout as e:
return build_error_response(request,
504,
_('Gateway Timeout'),
details=six.text_type(e))
except requests.exceptions.SSLError as e:
return build_error_response(request,
502,
_('SSL Error'),
details=six.text_type(e))
except (requests.exceptions.ConnectionError,
requests.exceptions.HTTPError,
requests.exceptions.TooManyRedirects) as e:
return build_error_response(request,
504,
_('Connection Error'),
details=six.text_type(e))
# Build a Django response
response = StreamingHttpResponse(res.raw.stream(4096,
decode_content=False),
status=res.status_code)
if 'reason_phrase' in response: # pragma: no cover
# Currently only django 1.6+ supports custom reason phrases
response.reason_phrase = res.reason_phrase
# Add all the headers received from the response
for header in res.headers:
header_lower = header.lower()
if header_lower == 'set-cookie':
for cookie in res.cookies:
response.set_cookie(cookie.name,
value=cookie.value,
expires=cookie.expires,
path=cookie.path)
elif header_lower == 'via':
via_header = via_header + ', ' + res.headers[header]
elif is_valid_response_header(header_lower):
response[header] = res.headers[header]
# Pass proxy processors to the response
for processor in get_response_proxy_processors():
response = processor.process_response(request_data, response)
response['Via'] = via_header
return response
def index(request):
initSettingsStatus()
if not request.user.is_authenticated:
return redirect('login')
if (not Settings.objects.filter(setting="tiempoMaximo")):
s = Settings(setting="tiempoMaximo", value="60")
s.save()
if (not Settings.objects.filter(setting="tiempoConsulta")):
s = Settings(setting="tiempoConsulta", value="30")
s.save()
if (not Settings.objects.filter(setting="tiempoLlega")):
s = Settings(setting="tiempoLlega", value="30")
s.save()
post = request.POST
cookies = request.COOKIES
if (cookies and 'tiempoMaximo' in cookies):
maxT = cookies.get("tiempoMaximo")
else:
maxT = Settings.objects.get(setting="tiempoMaximo").value
if (cookies and 'tiempoConsulta' in cookies):
consT = cookies.get("tiempoConsulta")
else:
consT = Settings.objects.get(setting="tiempoConsulta").value
if (cookies and "tiempoLlega" in cookies):
tiempoL = cookies.get("tiempoLlega")
else:
tiempoL = Settings.objects.get(setting="tiempoLlega").value
if (post):
tiempoMax = post.get("tiempoTransporte", None)
tiempoCons = post.get("tiempoConsulta", None)
tiempoLlega = post.get("tiempoLlega", None)
radioCargado = post.get("optionsRadios", None)
radioMatrix = radioCargado
if (radioCargado):
if (radioCargado == "option1"):
lineas = load.cargarMutualistas(request)
elif (radioCargado == "option2"):
lineas = load.cargarIndividuoAnclas(request)
elif (radioMatrix == "option3"):
lineas = load.cargarTiempos(1, request)
elif (radioMatrix == "option4"):
lineas = load.cargarTiempos(0, request)
elif (radioMatrix == "option5"):
lineas = load.cargarCentroPediatras(request)
elif (radioMatrix == "option6"): # omnibus
lineas = load.cargarTiemposBus(request)
elif (radioMatrix == "option7"):
lineas = load.cargarTiposTransporte(request)
elif (radioMatrix == 'option10'):
lineas = load.loadShapes(request, 1)
elif (radioMatrix == 'option11'):
lineas = load.loadShapes(request, 2)
elif (radioMatrix == 'option12'):
lineas = load.loadShapes(request, 0)
if lineas is not None:
pseudo_buffer = utils.Echo()
writer = csv.writer(pseudo_buffer)
response = StreamingHttpResponse(
(writer.writerow(row) for row in lineas),
content_type="text/csv")
response[
'Content-Disposition'] = 'attachment; filename="errores.csv"'
return response
if (tiempoMax):
maxT = tiempoMax
if (tiempoCons):
consT = tiempoCons
if (tiempoLlega):
tiempoL = tiempoLlega
ejecutarForm = EjecutarForm()
ejecutarHelper = EjecutarHelper()
simularForm = SimularForm()
simularHelper = SimularHelper()
username = request.user.username
try:
statusAuto = int(Settings.objects.get(setting='shapeAutoStatus').value)
except:
statusAuto = -1
try:
statusCaminando = int(
Settings.objects.get(setting='shapeCaminandoStatus').value)
except:
statusCaminando = -1
try:
statusBus = int(Settings.objects.get(setting='shapeBusStatus').value)
except:
statusBus = -1
statuses = {
0:
int(Settings.objects.get(setting='statusMatrizAuto').value),
1:
int(Settings.objects.get(setting='statusMatrizCaminando').value),
2:
int(Settings.objects.get(setting='statusMatrizBus').value),
3:
int(Settings.objects.get(setting='statusMatrizIndividuo').value),
4:
int(Settings.objects.get(setting='statusMatrizCentro').value),
5:
int(
Settings.objects.get(
setting='statusMatrizIndividuoTiempoCentro').value),
6:
TipoTransporte.objects.count(),
7:
Prestador.objects.count(),
10:
statusAuto,
12:
statusCaminando,
11:
statusBus,
8:
int(request.session.get('calculationStatus', -1))
}
context = {
'tiempoMaximo': maxT,
'tiempoConsulta': consT,
"tiempoLlega": tiempoL,
'simularForm': simularForm,
'simularHelper': simularHelper,
'ejecutarForm': ejecutarForm,
'ejecutarHelper': ejecutarHelper,
'username': username,
'statuses': statuses
}
response = render(request, 'app/index.html', context)
response.set_cookie(key='tiempoMaximo', value=maxT)
response.set_cookie(key='tiempoConsulta', value=consT)
response.set_cookie(key='tiempoLlega', value=tiempoL)
return response
