def sign_gsv_url(request):
"""
Sign a request URL with a URL signing secret.
Parameters
----------
request : HttpRequest
A basic HTTP 'POST' request with a json in payload with a
field gsv_unsigned_url with the url to be signed.
E.g.
{
"gsv_unsigned_url": "https://maps.googleapis.com/maps/api/streetview?size=640..."
}
Returns
-------
HttpResponse with the signed request URL.
"""
#write_to_log(f'sign_gsv_url')
jsonData = request.data
#write_to_log(json.dumps(jsonData))
input_url = jsonData['gsv_unsigned_url']
secret = settings_secret.GSV_SIGNING_SECRET
if request.user.is_authenticated:
try:
if request.user.profile.use_alternative_gsv_signing_secret:
secret = request.user.profile.gsv_url_signing_secret
except AttributeError as e:
write_to_log(f'Error: {e}')
if not input_url:
raise Exception("input_url is required")
if not secret:
return HttpResponse(input_url)
url = urlparse(input_url)
# We only need to sign the path+query part of the string
url_to_sign = url.path + "?" + url.query
# Decode the private key into its binary format
# We need to decode the URL-encoded private key
decoded_key = base64.urlsafe_b64decode(secret)
# Create a signature using the private key and the URL-encoded
# string using HMAC SHA1. This signature will be binary.
signature = hmac.new(decoded_key, url_to_sign.encode('utf-8'), hashlib.sha1)
# Encode the binary signature into base64 for use within a URL
encoded_signature = base64.urlsafe_b64encode(signature.digest())
original_url = url.scheme + "://" + url.netloc + url.path + "?" + url.query
# Return signed URL
return HttpResponse(original_url + "&signature=" + encoded_signature.decode('utf-8'))
def loadsession(request):
"""
End-point to load an user session with its regions,
layers and images.
If user is signed in then returns or the
requested sessionId (if it belongs to the signed in user otherwise
returns a forbidden message) if the user is not signed in or none
sessionId is requested then returns the current session.
Parameters
----------
request : HttpRequest
An HTTP 'POST' request with a sessionId or empty.
Returns
-------
HttpResponse with a session, forbidden message or empty
"""
if request.user.is_authenticated:
try:
sessionId = request.data.get('sessionId')
if sessionId is None:
sessionData = request.session.get('sessionData')
if sessionData:
return JsonResponse(sessionData, safe=False)
write_to_log("loadsession: sessionData loaded!")
else:
write_to_log("loadsession: no sessionData")
return HttpResponse(status=200)
session = Session.objects.get(id=sessionId)
if not isUserSession(request.user, session):
if request.session.get('sessionId') is not None:
del request.session['sessionId']
return forbiddenUserSessionHttpResponse()
write_to_log(
f"loadsession request.session['sessionId']: {request.session.get('sessionId')}"
)
write_to_log(f"loadsession sessionId: {sessionId}")
request.session['sessionId'] = sessionId
write_to_log(f"{session.uimodelJSON}")
#request.session['sessionData'] = ast.literal_eval(session.uimodelJSON)
request.session['sessionData'] = session.uimodelJSON
#print(request.session['sessionData'])
#return JsonResponse(ast.literal_eval(session.uimodelJSON))
return JsonResponse(session.uimodelJSON, safe=False)
except Session.DoesNotExist:
sessionData = request.session.get('sessionData')
if sessionData:
return JsonResponse(sessionData, safe=False)
else:
return HttpResponse(status=200)
pass
else:
sessionData = request.session.get('sessionData')
if sessionData:
return JsonResponse(sessionData)
else:
return HttpResponse(status=200)
def home(request):
"""
End-point for the home page.
Parameters
----------
request : HttpRequest
A basic HTTP request.
Returns
-------
none
"""
htmlfile = 'home.html'
local_vars = {'sample_key': 'sample_data'}
local_vars['public_gsv_key'] = settings_secret.GSV_KEY
if request.user.is_authenticated:
try:
# Note that the signing url key must be used exclusively
# at the backend, thus it should never be sent to the
# front-end.
masked_gsv_api_key = request.user.profile.gsv_api_key[:4] + "*****"
local_vars['gsv_api_key'] = request.user.profile.gsv_api_key
local_vars['masked_gsv_api_key'] = masked_gsv_api_key
local_vars['use_alternative_gsv_api_key'] = \
request.user.profile.use_alternative_gsv_api_key
local_vars['use_alternative_gsv_signing_secret'] = \
request.user.profile.use_alternative_gsv_signing_secret
except AttributeError as e:
write_to_log(f'Error: {e}')
return render(request, htmlfile, __merge_two_dicts(__TEMPLATE_GLOBAL_VARS, local_vars))
def _imageURLBuilderForGeoImage(geoImage: GeoImage, size: Size=None, key: str=None):
write_to_log(f'_imageURLBuilderForGeoImage')
if size is None: size = Size(640, 640)
if key is None: key = GoogleStreetViewProvider._key
return GoogleStreetViewProvider._imageURLBuilder(
size,
geoImage.id,
geoImage.heading,
geoImage.pitch,
GoogleStreetViewProvider._key)
def _getStreets(regions: FeatureCollection) -> MultiLineString:
"""Collect a set of Ways (from OSM) and convert them to a MultiLineString"""
overpassQueryUrl = OSMMiner._createCollectStreetsQuery(regions)
OSMMiner._lock.acquire()
#write_to_log("Rate limit %d, current queries: %d \n" % (OSMMiner._rateLimit, OSMMiner._currentQueries))
write_to_log(f'OSMMiner._OSMServerURL: {OSMMiner._OSMServerURL}')
#write_to_log(f'overpassQueryUrl: {overpassQueryUrl}')
while OSMMiner._currentQueries >= OSMMiner._rateLimit:
time.sleep(1)
OSMMiner._waitForAvailableSlots()
OSMMiner._currentQueries += 1
##DEBUG
#print("added query: %d\n" % OSMMiner._currentQueries)
OSMMiner._lock.release()
jsonString = requests.get(overpassQueryUrl).content
OSMMiner._currentQueries -= 1
##DEBUG
#print("removed query: %d\n" % OSMMiner._currentQueries)
try:
#TODO: Treat cases in which the OSM server fails
osmResult = OSMResult.fromJsonString(jsonString)
except:
write_to_log("Error while parsing overpass message. Message sample: %s" % jsonString[:100])
raise AttributeError("Invalid jsonString")
streetSegments = {}
# Data needs to be sorted before being grouped, otherwise
# the same group may appear multiple times
data = sorted(osmResult.Ways.values(), key=lambda x: x.tags.get('name'))
g = groupby(data, lambda x: x.tags.get('name'))
for streetName, group in g:
nodesList = [x.nodes for x in group]
OSMMiner._mergeWays(nodesList)
if streetName in streetSegments:
streetSegments[streetName] = streetSegments[streetName] + nodesList
else:
streetSegments[streetName] = nodesList
featuresList = []
for streetName in streetSegments:
featuresList.append(
Feature(id=streetName,
properties={'name':streetName},
geometry=MultiLineString([LineString([
Point([osmResult.Nodes[n].lon,
osmResult.Nodes[n].lat]) for n in s])
for s in streetSegments[streetName]]))
)
return FeatureCollection(featuresList, crs=OSMMiner._crs)
def createGeoImageFromStreetViewPanoramaData(streetViewPanoramaData):
"""DEPRECATED"""
write_to_log(f'createGeoImageFromStreetViewPanoramaData')
geoImage = GeoImage()
geoImage.id = streetViewPanoramaData['location']['pano']
geoImage.location = streetViewPanoramaData['location']
geoImage.heading = streetViewPanoramaData['tiles']['centerHeading']
geoImage.pitch = streetViewPanoramaData['tiles']['originPitch']
geoImage.metadata = streetViewPanoramaData
geoImage.data = GoogleStreetViewProvider._imageURLBuilderForGeoImage(geoImage)
geoImage.dataType = "URL"
geoImage.metadata['imageURL'] = GoogleStreetViewProvider._imageURLBuilderForGeoImage(geoImage)
return geoImage
def _imageURLBuilder(size: Size, panoid: str, heading: float, pitch: float,
key: str):
write_to_log(f'_imageURLBuilder')
baseurl = "https://maps.googleapis.com/maps/api/streetview"
queryString = (f"?size={size.width}x{size.height}"
f"&pano={panoid}"
f"&heading={heading}&pitch={pitch}&key={key}")
unsigned_url = baseurl + queryString
# signed_url = GoogleStreetViewProvider.sign_url(unsigned_url)
# print(f'signed_url: {signed_url}')
# return signed_url
return unsigned_url
def createGeoImage(pano_id, location, view, data):
write_to_log(f'createGeoImageFromStreetViewPanoramaData')
geoImage = GeoImage()
geoImage.id = pano_id
geoImage.location = {"coordinates": location}
geoImage.heading = view['heading']
geoImage.pitch = view['pitch']
#geoImage.data = GoogleStreetViewProvider._imageURLBuilderForGeoImage(geoImage)
geoImage.dataType = "data:image/jpeg;base64"
#geoImage.data = f'data:image/jpeg;base64,{data}'
geoImage.data = data
#geoImage.dataType = "URL"
geoImage.metadata['imageURL'] =\
GoogleStreetViewProvider._imageURLBuilderForGeoImage(geoImage)
return geoImage
def deletesession(request):
"""
End-point to delete a previously saved user session.
This function removes the user session from the application
level database (django_website_session table).
With the session all the information collected (i.e regions)
are removed as well.
Parameters
----------
request : HttpRequest
An HTTP 'POST' request with a JSON object
containing the sessionId of the session
to be deleted.
E.g.:
{
"sessionId": "4594-..."
}
Returns
-------
HttpResponse:
- 204 if the session is removed successfully
- 403 Forbidden if the user has not signed in.
- 404 if the sessionId does not exists in the database
"""
if request.user.is_authenticated:
jsonData = request.data
sessionId = jsonData.get('sessionId')
try:
session = Session.objects.get(id=sessionId)
if not isUserSession(request.user, session):
return forbiddenUserSessionHttpResponse()
write_to_log(
f"request.session['sessionId']: {request.session.get('sessionId')}"
)
write_to_log(f"session.id: {session.id}")
if request.session.get('sessionId') == str(session.id):
del request.session['sessionId']
del request.session['sessionData']
session.delete()
except Session.DoesNotExist:
HttpResponse(gettext("This session could not be found."),
status=404)
except Exception as e:
write_to_log(f"Unexpected error: {sys.exc_info()[0]}")
write_to_log(f"Error message: {e.args}")
else:
HttpResponse(gettext("User needs to be logged to delete a session."),
status=403)
return HttpResponse(status=204)
def sign_url(input_url=None, custom_url_sign_secret=None):
"""
Sign a request URL with a (default) URL signing secret.
Usage:
signed_url = sign_url(input_url=my_url)
signed_url = sign_url(input_url=my_url, custom_url_sign_secret=SECRET)
Args:
input_url - The URL to sign
(Optional) custom_url_sign_secret - User's URL signing secret
Returns:
The signed request URL
"""
write_to_log(f'sign_url')
if custom_url_sign_secret is not None:
secret = custom_url_sign_secret
else:
secret = settings_secret.GSV_SIGNING_SECRET
if not input_url or not secret:
raise Exception("input_url and secret are required")
#url = urlparse.urlparse(input_url)
url = urllib.parse.urlparse(input_url)
# We only need to sign the path+query part of the string
url_to_sign = url.path + "?" + url.query
# Decode the private key into its binary format
# We need to decode the URL-encoded private key
decoded_key = base64.urlsafe_b64decode(secret)
# Create a signature using the private key and the URL-encoded
# string using HMAC SHA1. This signature will be binary.
signature = hmac.new(decoded_key, url_to_sign.encode('utf8'), hashlib.sha1)
# Encode the binary signature into base64 for use within a URL
encoded_signature = base64.urlsafe_b64encode(signature.digest())
original_url = url.scheme + "://" + url.netloc + url.path + "?" + url.query
# Return signed URL
return original_url + "&signature=" + encoded_signature.decode('utf8')
def getlastsessionid(request):
"""
End-point to check the last sessionId created.
Parameters
----------
request : HttpRequest
An empty HTTP 'POST' request
Returns
-------
HttpResponse with the last sessionId created or -1
"""
sessionId = request.session.get('sessionId')
write_to_log(f"getlastsessionid - sessionId: {sessionId}")
write_to_log(f"sessionId: {sessionId}")
if sessionId is None:
return HttpResponse(status=200)
return HttpResponse(sessionId, status=200)
def newsession(request):
"""
End-point to create a new session discarding the current one.
It does not delete a saved session.
Parameters
----------
request : HttpRequest
An empty HTTP 'POST' request
Returns
-------
HttpResponse with the new sessionId
"""
write_to_log("newsession")
request.session['sessionId'] = str(uuid4())
if request.session.get('uiModelJSON') is not None:
del request.session['uiModelJSON']
if request.session.get('sessionData') is not None:
del request.session['sessionData']
#print(f"request.session['sessionId']: {request.session['sessionId']}")
return HttpResponse(request.session.get('sessionId'), status=200)
def getImageForFeature(feature: Feature) -> Feature:
"""
Receives a single Feature from a
Feature Collection of point/line or their
multi equivalents and inserts a "geoimages"
property with images for the coordinates of this
Feature.
Works in-place.
The geoimages property will have the same structure
of the geometry property.
The coordinates without a corresponding panorama will
be represented by a string "NOT FOUND" in the geoimages
correspondent position.
"""
write_to_log(f'getImageForFeature')
dbmanager = DBManager()
def ffunction(feature, clonedTree):
"""
ffunction - Feature's function
Defines how each feature (e.g. street) must be
processed.
"""
feature['properties']['geoImages'] = clonedTree
pass
def cfunction(coordinates, pointAtCoordinate=False):
"""
cfunction - Coordinates's function
Defines how each coordinate must be processed.
pointAtCoordinate: If true then the heading
will be defined to be one that points to the
coordinate rather than the frontal direction
from the camera.
"""
#Try to retrieve or collect the panorama
panorama = dbmanager.retrieve_nearest_panorama(coordinates)\
or dbmanager.collect_panorama_by_location(coordinates)
if panorama:
#Get view and consequently the stored image or its url
pano_id = panorama['pano']
if pointAtCoordinate:
originP = (panorama['location']['lng'],
panorama['location']['lat'])
destinationP = (coordinates[0], coordinates[1])
heading = calculate_initial_compass_bearing(originP, destinationP)
else:
heading = panorama['centerHeading']
pitch = panorama['originPitch']
# Optional: Just used to keep track of which views
# were already collected.
view = dbmanager.retrieve_panorama_view(
pano_id,
target_heading=heading,
heading_tolerance=10,
target_pitch=pitch,
pitch_tolerance=1
) or dbmanager.create_update_view(
pano_id,
heading,
pitch
)
#img_filename = dbmanager.image_filename_from_panorama_parameters(
# pano_id,
# heading,
# pitch
#)
#img_path = os.path.join(
# settings.PICTURES_FOLDER,
# img_filename
#)
#if os.path.exists(img_path):
local_img = dbmanager._retrieve_local_image(
pano_id,
view
)
if not local_img:
dbmanager._store_image_local(
pano_id,
view
)
local_img = dbmanager._retrieve_local_image(
pano_id,
view
)
pass
return GoogleStreetViewProvider.createGeoImage(
pano_id,
panorama['location'],
view,
local_img
).__dict__
#).toJSON()
else:
return "NOT FOUND"
pointAtCoordinate = (feature['geometry']['type'].lower() == 'multipoint')
clonedTree = ImageProvider.traverseFeature(feature, cfunction, pointAtCoordinate)
ffunction(feature, clonedTree)
return True
def get_registered_browser_channel_names(num_tries=1):
redisCon = get_default_redis_connection()
clear_inactive_browsers()
registered_browsers = redisCon.get('registered_browsers')
if registered_browsers is None:
# Try to launch a headless browser
# using the script at "scripts/launch_headless_chrome.sh"
# Besides launching the script also opens the default
# page http://localhost/gsvpanoramacollector/link_browser/default/
# where the browser is registered as available for Redis.
if num_tries > 0:
try:
subprocess.check_call('scripts/launch_headless_chrome.sh')
write_to_log("(Re)launching headless chrome:\n")
# sleep for 1 second to wait for the browser to load
time.sleep(5)
return get_registered_browser_channel_names(num_tries - 1)
except subprocess.CalledProcessError as error:
write_to_log("Error while (re)launching headless chrome:\n")
write_to_log(f"err_code: {error.returncode}\n")
write_to_log(f"cmd: {error.cmd}\n")
write_to_log(f"output: {error.stdout}\n")
write_to_log(f"err_output: {error.stderr}\n")
finally:
return None
else:
return None
else:
registered_browsers = registered_browsers.decode('ascii')
registered_browsers = registered_browsers.split(',')
return registered_browsers
def getImageForFeatureCollection(featureCollection: FeatureCollection) -> FeatureCollection:
"""
Receives a feature collection of point/line or their
multi equivalents and returns a list of GeoImage's
"""
write_to_log(f'getImageForFeatureCollection')
dbmanager = DBManager()
def ffunction(feature, clonedTree):
"""
ffunction - Feature's function
Defines how each feature (e.g. street) must be
processed.
"""
feature['properties']['geoImages'] = clonedTree
pass
def cfunction(coordinates):
"""
cfunction - Coordinates's function
Defines how each coordinate must be processed.
"""
#Try to retrieve or collect the panorama
panorama = dbmanager.retrieve_nearest_panorama(coordinates)\
or dbmanager.collect_panorama_by_location(coordinates)
if panorama:
#Get view and consequently the stored image or its url
pano_id = panorama['pano']
heading = panorama['centerHeading']
pitch = panorama['originPitch']
# Optional: Just used to keep track of which views
# were already collected.
view = dbmanager.retrieve_panorama_view(
pano_id,
target_heading=heading,
heading_tolerance=10,
target_pitch=pitch,
pitch_tolerance=1
) or dbmanager.create_update_view(
pano_id,
heading,
pitch
)
#img_filename = dbmanager.image_filename_from_panorama_parameters(
# pano_id,
# heading,
# pitch
#)
#img_path = os.path.join(
# settings.PICTURES_FOLDER,
# img_filename
#)
#if os.path.exists(img_path):
local_img = dbmanager._retrieve_local_image(
pano_id,
view
)
if not local_img:
dbmanager._store_image_local(
pano_id,
view
)
local_img = dbmanager._retrieve_local_image(
pano_id,
view
)
pass
return GoogleStreetViewProvider.createGeoImage(
pano_id,
panorama['location'],
view,
local_img
).__dict__
#).toJSON()
else:
return "NOT FOUND"
ImageProvider.traverseFeatureCollection(featureCollection, ffunction, cfunction)
return True
def processImageFromFeatureCollection(
cls, featureCollection: FeatureCollection) -> FeatureCollection:
"""Receives a feature collection of point/line or their multi equivalents and returns a list of GeoImage's"""
for feature in featureCollection['features']:
if feature['geometry']['type'] == 'MultiPolygon':
# Number of Polygons
for polygonIndex, polygon in enumerate(
feature['geometry']['coordinates']):
for lineIndex, lineString in enumerate(polygon):
for coordinateIndex in range(len(lineString)):
geoImage = feature['properties']['geoImages'][
polygonIndex][lineIndex][coordinateIndex]
if not isinstance(geoImage, dict):
continue
try:
geoImage = GeoImage.fromJSON(geoImage)
except JSONDecodeError:
print(
_('Error while parsing panorama: ') +
str(geoImage)[:100])
cls._setOutput(
geoImage, feature['properties']['geoImages']
[polygonIndex][lineIndex], coordinateIndex)
elif (feature['geometry']['type']
== 'MultiLineString') or (feature['geometry']['type']
== 'Polygon'):
for lineIndex, lineString in enumerate(
feature['geometry']['coordinates']):
for coordinateIndex in range(len(lineString)):
try:
geoImage = feature['properties']['geoImages'][
lineIndex][coordinateIndex]
if not isinstance(geoImage, dict):
continue
except Exception:
raise Exception(
f'lineIndex: {lineIndex}, coordinateIndex: {coordinateIndex}'
)
try:
geoImage = GeoImage.fromJSON(geoImage)
except JSONDecodeError:
write_to_log(
_('Error while parsing panorama: ') +
str(geoImage)[:100])
except Exception:
raise Exception(
f'lineIndex: {lineIndex}, coordinateIndex: {coordinateIndex}'
)
cls._setOutput(
geoImage,
feature['properties']['geoImages'][lineIndex],
coordinateIndex)
elif (feature['geometry']['type']
== 'LineString') or (feature['geometry']['type']
== 'MultiPoint'):
for coordinateIndex in range(
len(feature['geometry']['coordinates'])):
geoImage = feature['properties']['geoImages'][
coordinateIndex]
if not isinstance(geoImage, dict):
continue
try:
geoImage = GeoImage.fromJSON(geoImage)
except JSONDecodeError:
print(
_('Error while parsing panorama: ') +
str(geoImage)[:100])
cls._setOutput(geoImage,
feature['properties']['geoImages'],
coordinateIndex)
elif feature['geometry']['type'] == 'Point':
coordinateIndex = 0
geoImage = feature['properties']['geoImages'][coordinateIndex]
if not isinstance(geoImage, dict):
continue
try:
geoImage = GeoImage.fromJSON(geoImage)
except JSONDecodeError:
print(
_('Error while parsing panorama: ') +
str(geoImage)[:100])
cls._setOutput(geoImage, feature['properties']['geoImages'],
coordinateIndex)
return featureCollection
def _queryStringBuilderPanorama(size: Size, panoid: str, heading: float, pitch: float, key: str):
write_to_log(f'_queryStringBuilderPanorama')
return "?size=%dx%d&pano=%s&heading=%f&pitch=%f&key=%s" % (size.width,size.height, panoid, heading,pitch,key)
def _imageURLBuilder(size: Size, panoid: str, heading: float, pitch: float, key: str):
write_to_log(f'_imageURLBuilder')
unsigned_url = GoogleStreetViewProvider._baseurl + GoogleStreetViewProvider._queryStringBuilderPanorama(size, panoid, heading, pitch, key)
signed_url = GoogleStreetViewProvider.sign_url(unsigned_url)
#print(f'signed_url: {signed_url}')
return signed_url
def _queryStringBuilderLocation(size: Size, location: Point, heading: float, pitch: float, key: str):
write_to_log(f'_queryStringBuilderLocation')
return "?size=%dx%d&location=%f,%f&heading=%f&pitch=%f&key=%s"% (size.width, size.height, location['lat'], location['lon'], heading,pitch,key)
def _imageURLBuilderLocation(size: Size, location: Point, heading: float, pitch: float, key: str):
write_to_log(f'_imageURLBuilderLocation')
unsigned_url = GoogleStreetViewProvider._baseurl + GoogleStreetViewProvider._queryStringBuilderLocation(size, location, heading, pitch, key)
signed_url = GoogleStreetViewProvider.sign_url(unsigned_url)
write_to_log(f'signed_url: {signed_url}')
return signed_url
def _setOutput(cls, geoImage, featureLeaf, index):
try:
write_to_log('_setOutput')
dbmanager = DBManager()
result = dbmanager.load_processed_data_for_geoImage(
geoImage, cls.filterId)
if result:
filter_result = result[0]
geoImage.setProcessedData(cls.filterId,
'base64',
result[1],
density=filter_result['density'])
else:
if geoImage.dataType == 'data:image/jpeg;base64':
base64decoded = base64.b64decode(geoImage.data)
ndarrayImage = img_as_float(imageio.imread(base64decoded))
elif geoImage.dataType == 'URL':
ndarrayImage = img_as_float(imageio.imread(geoImage.data))
mask = mt_li_espectral(ndarrayImage)
density = np.count_nonzero(mask) / mask.size
mask = img_as_ubyte(overlay_mask(ndarrayImage, mask))
geoImage.setProcessedData(cls.filterId,
'ndarray',
mask,
density=density)
dbmanager.store_geoImage_as_view(geoImage)
featureLeaf[index] = geoImage
#dbmanager.store_geoImage_as_view(geoImage)
except HTTPError:
traceback.print_exc()
write_to_log(f"Http error - Have the quota been achieved?")
except ValueError:
traceback.print_exc()
write_to_log(f'Image bytes: {ndarrayImage[:100]}')
except Exception as e:
traceback.print_exc()
write_to_log(f"Unexpected error: {sys.exc_info()[0]}")
write_to_log(f"Error message: {e.args}")
write_to_log(f'Offending url: {geoImage.data[:300]}')
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "django_website.settings")
# This application object is used by any WSGI server configured to use this
# file. This includes Django's development server, if the WSGI_APPLICATION
# setting points here.
from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()
from django_website.LogGenerator import write_to_log
# This is needed since the apache mod_wsgi will set the current working
# directory as the root (or the user home) folders. Here the working
# directory will be INACITY root folder (the outermost 'django_website' folder)
path = Path(os.path.dirname(__file__))
os.chdir(path.parent)
write_to_log(f'Working dir: {os.getcwd()}')
print(f'Working dir: {os.getcwd()}')
write_to_log('wsgi loaded')
print('wsgi loaded')
import sys
if 'runserver' in sys.argv:
import ptvsd
try:
address = ('0.0.0.0', 3000)
ptvsd.enable_attach(address)
print('ptvsd enabled')
write_to_log('ptvsd enabled')
except Exception as e:
def savesession(request):
"""
End-point to save a session with its regions,
layers and images.
If user is signed in then the session is saved
as an user session and can be retrieved in the
user profile. If the user is not signed then
the session is saved only as a django session
and can expire (and consequently be lost).
Either way the session is always stored at the
current django session.
Parameters
----------
request : HttpRequest
An HTTP 'POST' request with the uiModelJSON object
in the payload.
Returns
-------
HttpResponse sessionId if it's present, 204 if not and
400 (bad request) if no uiModelJSON is sent in payload.
"""
if request.data is None:
return HttpResponse('No content to be saved!', status=400)
sessionName = (request.data.get('sessionName')
or request.session.get('sessionName')
or request.session.get('sessionId'))
write_to_log(
f"request.session[sessionId]: {request.session.get('sessionId')}")
write_to_log(f'sessionName: {str(sessionName)}')
if request.user.is_authenticated:
sessionId = request.session.get('sessionId')
write_to_log('uiModelJSON-sessionName:' +
str(request.data.get('sessionName')))
write_to_log(f'sessionId:{sessionId}')
if sessionId is None:
if sessionName is None:
session = Session.objects.create(user=request.user,
sessionName='',
uimodelJSON=json.dumps(
request.data))
session.save()
session.sessionName = session.id
session.save()
else:
session = Session.objects.create(user=request.user,
sessionName=sessionName,
uimodelJSON=json.dumps(
request.data))
session.save()
else:
try:
session = Session.objects.get(id=sessionId)
if not isUserSession(request.user, session):
write_to_log("isUserSession")
del request.session['sessionId']
return forbiddenUserSessionHttpResponse()
if (sessionName is not None) and (len(sessionName) > 0):
session.sessionName = sessionName
session.uimodelJSON = json.dumps(request.data)
session.save()
except Session.DoesNotExist:
session = Session.objects.create(user=request.user,
sessionName=sessionName,
uimodelJSON=json.dumps(
request.data))
session.save()
write_to_log("savesession")
write_to_log(
f"request.session['sessionId']: {request.session.get('sessionId')}"
)
request.session['sessionId'] = session.id
write_to_log(
f"request.session['sessionId']: {request.session.get('sessionId')}"
)
else:
if request.session.get('sessionId') is None:
request.session['sessionId'] = str(uuid4())
request.session['sessionData'] = request.data
if request.session.get('sessionId') is not None:
return HttpResponse(request.session['sessionId'], status=200)
else:
return HttpResponse(status=204)
def __init__(self):
write_to_log('ImageProviderManager.__init__')
self._ImageProviders = {}
for imageProviderClass in ImageProvider._subclasses:
self.registerImageProvider(imageProviderClass)
