113 changes: 96 additions & 17 deletions geonode/tests/utils.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -23,6 +23,8 @@
import os
import copy
import json
import base64
import pickle
import urllib
import urllib2
import logging
Expand All @@ -37,6 +39,8 @@
from django.db.models import signals
from django.core.urlresolvers import reverse
from django.core.management import call_command
from django.contrib.auth import get_user_model
from django.test.client import Client as DjangoTestClient

from geonode.maps.models import Layer
from geonode.geoserver.helpers import set_attributes
Expand All @@ -51,29 +55,74 @@ def upload_step(step=None):
return step


class Client(object):
class Client(DjangoTestClient):

"""client for making http requests"""

def __init__(self, url, user, passwd):
def __init__(self, url, user, passwd, *args, **kwargs):
super(Client, self).__init__(*args)

self.url = url
self.user = user
self.passwd = passwd
self.csrf_token = None
self.response_cookies = None
self.opener = self._init_url_opener()
self.u, _ = get_user_model().objects.get_or_create(username=self.user)
self.u.is_active = True
self.u.email = 'admin@geonode.org'
self.u.set_password(self.passwd)
self.u.save()

def _init_url_opener(self):
self.cookies = urllib2.HTTPCookieProcessor()
opener = register_openers()
opener.add_handler(self.cookies) # Add cookie handler
return opener

def _login(self, user, backend=None):
from importlib import import_module
from django.http import HttpRequest
from django.contrib.auth import login
engine = import_module(settings.SESSION_ENGINE)

# Create a fake request to store login details.
request = HttpRequest()

request.session = engine.SessionStore()
login(request, user, backend)

# Save the session values.
request.session.save()
return request

def make_request(self, path, data=None,
ajax=False, debug=True):
ajax=False, debug=True, force_login=False):
url = path if path.startswith("http") else self.url + path
if ajax:
url += '&ajax=true' if '?' in url else '?ajax=true'
url += '&force_ajax=true' if '?' in url else '?force_ajax=true'
request = None
# Create a fake request to store login details.
_request = None
_session_id = None
if force_login:
session_cookie = settings.SESSION_COOKIE_NAME
for cookie in self.cookies.cookiejar:
if cookie.name == session_cookie:
_session_id = cookie.value
self.response_cookies += "; %s=%s" % (session_cookie, _session_id)
# _request = self.force_login(self.u)

# # Save the session values.
# _request.session.save()
# logger.info(_request.session)

# # Set the cookie to represent the session.
# logger.info(" -- session %s == %s " % (cookie.value, _request.session.session_key))
# cookie.value = _request.session.session_key
# cookie.expires = None
# self.cookies.cookiejar.set_cookie(cookie)

if data:
items = []
# wrap post parameters
Expand All @@ -82,16 +131,28 @@ def make_request(self, path, data=None,
# add file
items.append(MultipartParam.from_file(name, value.name))
else:
if name == 'csrfmiddlewaretoken' and _request and _request.META['CSRF_COOKIE']:
value = _request.META['CSRF_COOKIE']
self.csrf_token = value
for cookie in self.cookies.cookiejar:
if cookie.name == 'csrftoken':
cookie.value = value
self.cookies.cookiejar.set_cookie(cookie)
items.append(MultipartParam(name, value))
logger.debug(" MultipartParam: %s / %s: " % (name, value))
datagen, headers = multipart_encode(items)
request = urllib2.Request(url, datagen, headers)
else:
request = urllib2.Request(url=url)

if self.csrf_token:
request.add_header('X-CSRFToken', self.csrf_token)
if self.response_cookies:
request.add_header('cookie', self.response_cookies)
if ajax:
request.add_header('X_REQUESTED_WITH', 'XMLHttpRequest')

try:
# return urllib2.urlopen(request)
return self.opener.open(request)
except urllib2.HTTPError as ex:
if not debug:
Expand All @@ -104,31 +165,48 @@ def make_request(self, path, data=None,
def get(self, path, debug=True):
return self.make_request(path, debug=debug)

def force_login(self, user, backend=None):
def get_backend():
from django.contrib.auth import load_backend
for backend_path in settings.AUTHENTICATION_BACKENDS:
backend = load_backend(backend_path)
if hasattr(backend, 'get_user'):
return backend_path
if backend is None:
backend = get_backend()
user.backend = backend
return self._login(user, backend)

def login(self):
""" Method to login the GeoNode site"""
from django.contrib.auth import authenticate
assert authenticate(username=self.user, password=self.passwd)

self.csrf_token = self.get_csrf_token()
params = {'csrfmiddlewaretoken': self.csrf_token,
'username': self.user,
'login': self.user,
'next': '/',
'password': self.passwd}
self.make_request(
response = self.make_request(
reverse('account_login'),
data=params
)
self.csrf_token = self.get_csrf_token()
self.response_cookies = response.headers.get('Set-Cookie')

def upload_file(self, _file):
""" function that uploads a file, or a collection of files, to
the GeoNode"""
if not self.csrf_token:
self.login()
spatial_files = ("dbf_file", "shx_file", "prj_file")

base, ext = os.path.splitext(_file)
params = {
# make public since wms client doesn't do authentication
'permissions': '{ "users": {"AnonymousUser": ["view_resourcebase"]} , "groups":{}}',
'csrfmiddlewaretoken': self.csrf_token
'csrfmiddlewaretoken': self.csrf_token,
'time': 'true',
'charset': 'UTF-8'
}

# deal with shapefiles
Expand All @@ -140,21 +218,25 @@ def upload_file(self, _file):
# allow for that
if os.path.exists(file_path):
params[spatial_file] = open(file_path, 'rb')
elif ext.lower() == '.tif':
file_path = base + ext
params['tif_file'] = open(file_path, 'rb')

base_file = open(_file, 'rb')
params['base_file'] = base_file
resp = self.make_request(
upload_step(),
data=params,
ajax=True)
ajax=True,
force_login=True)
data = resp.read()
try:
return resp, json.loads(data)
except ValueError:
# raise ValueError(
# 'probably not json, status %s' %
# resp.getcode(),
# data)
logger.exception(ValueError(
'probably not json, status %s' %
resp.getcode(),
data))
return resp, data

def get_html(self, path, debug=True):
Expand Down Expand Up @@ -204,7 +286,6 @@ def get_web_page(url, username=None, password=None, login_url=None):

with contextlib.closing(opener.open(login_url, encoded_params)) as f:
f.read()

elif username is not None:
# Login using basic auth

Expand Down Expand Up @@ -297,8 +378,6 @@ def test_set_attributes_creates_attributes(self):


if has_notifications:
import pickle
import base64
from pinax.notifications.tests import get_backend_id
from pinax.notifications.engine import send_all
from pinax.notifications.models import NoticeQueueBatch
Expand Down
194 changes: 130 additions & 64 deletions geonode/upload/tests/integration.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,17 +27,19 @@
@todo only test_time seems to work correctly with database backend test settings
"""

from geonode.tests.base import GeoNodeBaseTestSupport
from geonode.tests.base import GeoNodeLiveTestSupport

import os.path
from django.conf import settings
from django.db import connections

from geonode.maps.models import Map
from geonode.layers.models import Layer
from geonode.upload.models import Upload
from geonode.people.models import Profile
from geonode.documents.models import Document

from geonode.base.models import Link
from geonode.catalogue import get_catalogue
from geonode.tests.utils import upload_step, Client
from geonode.upload.utils import _ALLOW_TIME_STEP
from geonode.geoserver.helpers import ogc_server_settings, cascading_delete
Expand All @@ -56,6 +58,7 @@
import time
import json
import urllib
import urllib2
import logging
import tempfile
import unittest
Expand All @@ -67,6 +70,20 @@
GEOSERVER_URL = ogc_server_settings.LOCATION
GEOSERVER_USER, GEOSERVER_PASSWD = ogc_server_settings.credentials

DB_HOST = settings.DATABASES['default']['HOST']
DB_PORT = settings.DATABASES['default']['PORT']
DB_NAME = settings.DATABASES['default']['NAME']
DB_USER = settings.DATABASES['default']['USER']
DB_PASSWORD = settings.DATABASES['default']['PASSWORD']
DATASTORE_URL = 'postgis://{}:{}@{}:{}/{}'.format(
DB_USER,
DB_PASSWORD,
DB_HOST,
DB_PORT,
DB_NAME
)
postgis_db = dj_database_url.parse(DATASTORE_URL, conn_max_age=5)

logging.getLogger('south').setLevel(logging.WARNING)
logger = logging.getLogger(__name__)

Expand Down Expand Up @@ -100,9 +117,9 @@ def get_wms(version='1.1.1', type_name=None, username=None, password=None):
return WebMapService(url)


class UploaderBase(GeoNodeBaseTestSupport):
class UploaderBase(GeoNodeLiveTestSupport):

settings_overrides = []
type = 'layer'

@classmethod
def setUpClass(cls):
Expand All @@ -114,8 +131,6 @@ def tearDownClass(cls):
os.unlink('integration_settings.py')

def setUp(self):
# super(UploaderBase, self).setUp()

# await startup
cl = Client(
GEONODE_URL, GEONODE_USER, GEONODE_PASSWD
Expand All @@ -135,37 +150,32 @@ def setUp(self):
GEOSERVER_URL + 'rest', GEOSERVER_USER, GEOSERVER_PASSWD
)

settings.DATABASES['default']['NAME'] = DB_NAME

connections['default'].settings_dict['ATOMIC_REQUESTS'] = False
connections['default'].connect()

self._tempfiles = []
# createlayer must use postgis as a datastore
# set temporary settings to use a postgis datastore
DB_HOST = settings.DATABASES['default']['HOST']
DB_PORT = settings.DATABASES['default']['PORT']
DB_NAME = settings.DATABASES['default']['NAME']
DB_USER = settings.DATABASES['default']['USER']
DB_PASSWORD = settings.DATABASES['default']['PASSWORD']
settings.DATASTORE_URL = 'postgis://{}:{}@{}:{}/{}'.format(
DB_USER,
DB_PASSWORD,
DB_HOST,
DB_PORT,
DB_NAME
)
postgis_db = dj_database_url.parse(
settings.DATASTORE_URL, conn_max_age=600)
settings.DATABASES['datastore'] = postgis_db
settings.OGC_SERVER['default']['DATASTORE'] = 'datastore'

def _post_teardown(self):
pass

def tearDown(self):
# super(UploaderBase, self).tearDown()
connections.databases['default']['ATOMIC_REQUESTS'] = False

map(os.unlink, self._tempfiles)
# move to original settings
settings.OGC_SERVER['default']['DATASTORE'] = ''
del settings.DATABASES['datastore']

# Cleanup
Upload.objects.all().delete()
Layer.objects.all().delete()
Map.objects.all().delete()
Document.objects.all().delete()

if settings.OGC_SERVER['default'].get(
"GEOFENCE_SECURITY_ENABLED", False):
from geonode.security.utils import purge_geofence_all
purge_geofence_all()

def check_layer_geonode_page(self, path):
""" Check that the final layer page render's correctly after
an layer is uploaded """
Expand Down Expand Up @@ -263,13 +273,8 @@ def finish_upload(
if not is_raster and not skip_srs:
self.assertTrue(upload_step('srs') in current_step)
# if all is good, the srs step will redirect to the final page
resp = self.client.get(current_step)

content = json.loads(resp.read())
if not content.get('url') and content.get(
'redirect_to',
current_step) == upload_step('final'):
resp = self.client.get(content.get('redirect_to'))
final_step = current_step.replace('srs', 'final')
resp = self.client.make_request(final_step)
else:
self.assertTrue(upload_step('final') in current_step)
resp = self.client.get(current_step)
Expand Down Expand Up @@ -297,13 +302,13 @@ def check_upload_model(self, original_name):
upload = None
try:
upload = Upload.objects.filter(name=str(original_name)).last()
# Making sure the Upload object is present on the DB and
# the import session is COMPLETE
if upload:
self.assertTrue(upload.complete)
except Upload.DoesNotExist:
self.fail('expected to find Upload object for %s' % original_name)

# Making sure the Upload object is present on the DB and
# the import session is COMPLETE
self.assertTrue(upload.complete)

def check_layer_complete(self, layer_page, original_name):
'''check everything to verify the layer is complete'''
self.check_layer_geonode_page(layer_page)
Expand All @@ -326,13 +331,12 @@ def check_layer_complete(self, layer_page, original_name):
caps_found = True
except BaseException:
pass
if caps_found:
self.check_layer_geoserver_rest(layer_name)
self.check_upload_model(layer_name)
else:
if not caps_found:
logger.warning(
"Could not recognize Layer %s on GeoServer WMS" %
"Could not recognize Layer %s on GeoServer WMS Capa" %
original_name)
self.check_layer_geoserver_rest(layer_name)
self.check_upload_model(layer_name)

def check_invalid_projection(self, layer_name, resp, data):
""" Makes sure that we got the correct response from an layer
Expand Down Expand Up @@ -414,22 +418,86 @@ def make_csv(self, *rows):


class TestUpload(UploaderBase):
settings_overrides = []

def test_shp_upload(self):
""" Tests if a vector layer can be upload to a running GeoNode GeoServer"""
""" Tests if a vector layer can be uploaded to a running GeoNode/GeoServer"""
layer_name = 'san_andres_y_providencia_water'
fname = os.path.join(
GOOD_DATA,
'vector',
'san_andres_y_providencia_water.shp')
self.upload_file(fname, self.complete_upload,
check_name='san_andres_y_providencia_water')

test_layer = Layer.objects.all().first()
if test_layer:
layer_attributes = test_layer.attributes
self.assertIsNotNone(layer_attributes)
self.assertTrue(layer_attributes.count() > 0)
'%s.shp' % layer_name)
self.upload_file(fname,
self.complete_upload,
check_name='%s' % layer_name)

test_layer = Layer.objects.using('default').get(name='%s' % layer_name)
layer_attributes = test_layer.attributes
self.assertIsNotNone(layer_attributes)
self.assertTrue(layer_attributes.count() > 0)

# Links
_def_link_types = ['original', 'metadata']
_links = Link.objects.filter(link_type__in=_def_link_types)
# Check 'original' and 'metadata' links exist
self.assertIsNotNone(
_links,
"No 'original' and 'metadata' links have been found"
)
self.assertTrue(
_links.count() > 0,
"No 'original' and 'metadata' links have been found"
)
# Check original links in csw_anytext
_post_migrate_links_orig = Link.objects.filter(
resource=test_layer.resourcebase_ptr,
resource_id=test_layer.resourcebase_ptr.id,
link_type='original'
)
self.assertTrue(
_post_migrate_links_orig.count() > 0,
"No 'original' links has been found for the layer '{}'".format(
test_layer.alternate
)
)
for _link_orig in _post_migrate_links_orig:
self.assertIn(
_link_orig.url,
test_layer.csw_anytext,
"The link URL {0} is not present in the 'csw_anytext' attribute of the layer '{1}'".format(
_link_orig.url,
test_layer.alternate
)
)
# Check catalogue
catalogue = get_catalogue()
record = catalogue.get_record(test_layer.uuid)
self.assertIsNotNone(record)
self.assertTrue(
hasattr(record, 'links'),
"No records have been found in the catalogue for the resource '{}'".format(
test_layer.alternate
)
)
# Check 'metadata' links for each record
for mime, name, metadata_url in record.links['metadata']:
try:
_post_migrate_link_meta = Link.objects.get(
resource=test_layer.resourcebase_ptr,
url=metadata_url,
name=name,
extension='xml',
mime=mime,
link_type='metadata'
)
except Link.DoesNotExist:
_post_migrate_link_meta = None
self.assertIsNotNone(
_post_migrate_link_meta,
"No '{}' links have been found in the catalogue for the resource '{}'".format(
name,
test_layer.alternate
)
)

def test_raster_upload(self):
""" Tests if a raster layer can be upload to a running GeoNode GeoServer"""
Expand All @@ -438,10 +506,9 @@ def test_raster_upload(self):
check_name='relief_san_andres')

test_layer = Layer.objects.all().first()
if test_layer:
layer_attributes = test_layer.attributes
self.assertIsNotNone(layer_attributes)
self.assertTrue(layer_attributes.count() > 0)
layer_attributes = test_layer.attributes
self.assertIsNotNone(layer_attributes)
self.assertTrue(layer_attributes.count() > 0)

def test_zipped_upload(self):
"""Test uploading a zipped shapefile"""
Expand Down Expand Up @@ -506,8 +573,8 @@ def test_extension_not_implemented(self):
if unsupported_path.endswith('.pyc'):
unsupported_path = unsupported_path.rstrip('c')

# with self.assertRaises(HTTPError):
self.client.upload_file(unsupported_path)
with self.assertRaises(urllib2.HTTPError):
self.client.upload_file(unsupported_path)

def test_csv(self):
'''make sure a csv upload fails gracefully/normally when not activated'''
Expand All @@ -526,8 +593,6 @@ def test_csv(self):
'Vector datastore not enabled')
class TestUploadDBDataStore(UploaderBase):

settings_overrides = []

def test_csv(self):
"""Override the baseclass test and verify a correct CSV upload"""

Expand All @@ -546,8 +611,9 @@ def test_csv(self):
csrfmiddlewaretoken=self.client.get_csrf_token())
resp = self.client.make_request(csv_step, form_data)
content = json.loads(resp.read())
logger.info(content)
self.assertEquals(resp.code, 200)
self.assertTrue(upload_step('srs') in content['redirect_to'])
self.assertEquals(content['status'], 'incomplete')

def test_time(self):
"""Verify that uploading time based shapefile works properly"""
Expand Down
12 changes: 8 additions & 4 deletions geonode/upload/tests/test_settings.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -58,6 +58,11 @@
_middleware.remove('geonode.security.middleware.SessionControlMiddleware')
MIDDLEWARE_CLASSES = tuple(_middleware)

# Django 1.11 ParallelTestSuite
TEST_RUNNER = 'geonode.tests.suite.runner.GeoNodeBaseSuiteDiscoverRunner'
TEST_RUNNER_KEEPDB = os.environ.get('TEST_RUNNER_KEEPDB', 1)
TEST_RUNNER_PARALLEL = os.environ.get('TEST_RUNNER_PARALLEL', 1)

# Backend
DATABASES = {
'default': {
Expand All @@ -70,10 +75,9 @@
'CONN_MAX_AGE': 5,
'CONN_TOUT': 5,
'OPTIONS': {
'connect_timeout': 5,
'connect_timeout': 5
}
},
# vector datastore for uploads
'datastore': {
'ENGINE': 'django.contrib.gis.db.backends.postgis',
'NAME': 'upload_test',
Expand All @@ -84,7 +88,7 @@
'CONN_MAX_AGE': 5,
'CONN_TOUT': 5,
'OPTIONS': {
'connect_timeout': 5,
'connect_timeout': 5
}
}
}
Expand Down Expand Up @@ -191,7 +195,7 @@
MONITORING_SERVICE_NAME = os.getenv("MONITORING_SERVICE_NAME", 'local-geonode')

# how long monitoring data should be stored
MONITORING_DATA_TTL = timedelta(days=int(os.getenv("MONITORING_DATA_TTL", 365)))
MONITORING_DATA_TTL = timedelta(days=int(os.getenv("MONITORING_DATA_TTL", 7)))

# this will disable csrf check for notification config views,
# use with caution - for dev purpose only
Expand Down
31 changes: 17 additions & 14 deletions geonode/upload/utils.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -282,14 +282,17 @@ def _advance_step(req, upload_session):


def next_step_response(req, upload_session, force_ajax=True):
_force_ajax = '&force_ajax=true' if force_ajax and 'force_ajax' not in req.GET else ''
import_session = upload_session.import_session
# if the current step is the view POST for this step, advance one
if req.method == 'POST':
if upload_session.completed_step:
_advance_step(req, upload_session)
else:
upload_session.completed_step = 'save'

next = get_next_step(upload_session)

if next == 'error':
return json_response(
{'status': 'error',
Expand All @@ -302,17 +305,17 @@ def next_step_response(req, upload_session, force_ajax=True):
if next == 'check':
# @TODO we skip time steps for coverages currently
store_type = import_session.tasks[0].target.store_type
if store_type == 'coverageStore':
if store_type == 'coverageStore' or _force_ajax:
upload_session.completed_step = 'check'
return next_step_response(req, upload_session, force_ajax)
return next_step_response(req, upload_session, force_ajax=True)
if next == 'check' and force_ajax:
url = reverse('data_upload') + "?id=%s" % import_session.id
url = reverse('data_upload') + "?id=%s" % (import_session.id)
return json_response(
{'url': url,
'status': 'incomplete',
'success': True,
'id': import_session.id,
'redirect_to': settings.SITEURL + 'upload/check' + "?id=%s" % import_session.id,
'redirect_to': settings.SITEURL + 'upload/check' + "?id=%s%s" % (import_session.id, _force_ajax),
}
)

Expand All @@ -331,46 +334,46 @@ def next_step_response(req, upload_session, force_ajax=True):
upload_session.completed_step = 'time'
return next_step_response(req, upload_session, force_ajax)
if next == 'time' and force_ajax:
url = reverse('data_upload') + "?id=%s" % import_session.id
url = reverse('data_upload') + "?id=%s" % (import_session.id)
return json_response(
{'url': url,
'status': 'incomplete',
'success': True,
'id': import_session.id,
'redirect_to': settings.SITEURL + 'upload/time' + "?id=%s" % import_session.id,
'redirect_to': settings.SITEURL + 'upload/time' + "?id=%s%s" % (import_session.id, _force_ajax),
}
)

if next == 'mosaic' and force_ajax:
url = reverse('data_upload') + "?id=%s" % import_session.id
url = reverse('data_upload') + "?id=%s" % (import_session.id)
return json_response(
{'url': url,
'status': 'incomplete',
'success': True,
'id': import_session.id,
'redirect_to': settings.SITEURL + 'upload/mosaic' + "?id=%s" % import_session.id,
'redirect_to': settings.SITEURL + 'upload/mosaic' + "?id=%s%s" % (import_session.id, _force_ajax),
}
)

if next == 'srs' and force_ajax:
url = reverse('data_upload') + "?id=%s" % import_session.id
url = reverse('data_upload') + "?id=%s" % (import_session.id)
return json_response(
{'url': url,
'status': 'incomplete',
'success': True,
'id': import_session.id,
'redirect_to': settings.SITEURL + 'upload/srs' + "?id=%s" % import_session.id,
'redirect_to': settings.SITEURL + 'upload/srs' + "?id=%s%s" % (import_session.id, _force_ajax),
}
)

if next == 'csv' and force_ajax:
url = reverse('data_upload') + "?id=%s" % import_session.id
url = reverse('data_upload') + "?id=%s" % (import_session.id)
return json_response(
{'url': url,
'status': 'incomplete',
'success': True,
'id': import_session.id,
'redirect_to': settings.SITEURL + 'upload/csv' + "?id=%s" % import_session.id,
'redirect_to': settings.SITEURL + 'upload/csv' + "?id=%s%s" % (import_session.id, _force_ajax),
}
)

Expand All @@ -387,9 +390,9 @@ def next_step_response(req, upload_session, force_ajax=True):
force_ajax=force_ajax)
session_id = None
if 'id' in req.GET:
session_id = "?id=%s" % req.GET['id']
session_id = "?id=%s" % (req.GET['id'])
elif import_session and import_session.id:
session_id = "?id=%s" % import_session.id
session_id = "?id=%s" % (import_session.id)

if req.is_ajax() or force_ajax:
content_type = 'text/html' if not req.is_ajax() else None
Expand Down
24 changes: 8 additions & 16 deletions geonode/upload/views.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -165,12 +165,12 @@ def save_step_view(req, session):
form = LayerUploadForm(req.POST, req.FILES)
if form.is_valid():
tempdir = tempfile.mkdtemp(dir=settings.FILE_UPLOAD_TEMP_DIR)
logger.info("valid_extensions: {}".format(form.cleaned_data["valid_extensions"]))
logger.debug("valid_extensions: {}".format(form.cleaned_data["valid_extensions"]))
relevant_files = _select_relevant_files(
form.cleaned_data["valid_extensions"],
req.FILES.itervalues()
)
logger.info("relevant_files: {}".format(relevant_files))
logger.debug("relevant_files: {}".format(relevant_files))
_write_uploaded_files_to_disk(tempdir, relevant_files)
base_file = os.path.join(tempdir, form.cleaned_data["base_file"].name)
name, ext = os.path.splitext(os.path.basename(base_file))
Expand All @@ -182,7 +182,7 @@ def save_step_view(req, session):
scan_hint=scan_hint,
charset=form.cleaned_data["charset"]
)
logger.info("spatial_files: {}".format(spatial_files))
logger.debug("spatial_files: {}".format(spatial_files))
import_session = save_step(
req.user,
name,
Expand Down Expand Up @@ -232,10 +232,6 @@ def save_step_view(req, session):
user=req.user
)
Upload.objects.update_from_session(upload_session)
req.session[str(upload_session.import_session.id)] = upload_session
req.session.modified = True
_log('saved session : %s',
req.session[str(upload_session.import_session.id)])
return next_step_response(req, upload_session, force_ajax=True)
else:
errors = []
Expand Down Expand Up @@ -594,10 +590,11 @@ def final_step_view(req, upload_session):

return _json_response
except LayerNotReady:
force_ajax = '&force_ajax=true' if 'force_ajax' in req.GET and req.GET['force_ajax'] == 'true' else ''
return json_response({'status': 'pending',
'success': True,
'id': req.GET['id'],
'redirect_to': '/upload/final' + "?id=%s" % req.GET['id']})
'redirect_to': '/upload/final' + "?id=%s%s" % (req.GET['id'], force_ajax)})
else:
# url = reverse('layer_browse') + '?limit={}'.format(settings.CLIENT_RESULTS_LIMIT)
url = "upload/layer_upload_invalid.html"
Expand Down Expand Up @@ -627,6 +624,9 @@ def final_step_view(req, upload_session):
@login_required
def view(req, step):
"""Main uploader view"""
from django.contrib import auth
if not auth.get_user(req).is_authenticated():
return error_response(req, errors=["Not Authorized"])
upload_session = None
upload_id = req.GET.get('id', None)

Expand All @@ -639,8 +639,6 @@ def view(req, step):
user=req.user)
session = upload_obj.get_session()
if session:
req.session[upload_id] = session
req.session.modified = True
return next_step_response(req, session)
step = 'save'

Expand Down Expand Up @@ -691,12 +689,6 @@ def view(req, step):
req.session.modified = True
except BaseException:
pass
else:
try:
req.session[upload_id] = upload_session
req.session.modified = True
except BaseException:
traceback.print_exc()
else:
upload_session = _get_upload_session(req)
if upload_session:
Expand Down