def meta(request, tile_key, unsecured=False):
""" Update the meta(config) of a tile(widget) """
if request.method == "POST":
if not checkAccessToken(
method="POST", request=request, unsecured=unsecured):
return HttpResponse("API KEY incorrect", status=401)
try:
value = request.POST.get("value", None)
if value is None:
return HttpResponseBadRequest("Missing data")
try:
value = json.loads(value)
except:
return HttpResponseBadRequest("Invalid Json data")
if "big_value_color" not in value or "fading_background" not in value:
return HttpResponseBadRequest("Bad data")
tilePrefix = getRedisPrefix(tile_key)
if not redis.exists(tilePrefix):
if LOG:
print(
f"{getTimeStr()}: (+) {tile_key} is not present in cache",
flush=True)
return HttpResponseBadRequest(
f"{tile_key} is not present in cache")
cachedTile = json.loads(redis.get(tilePrefix))
cachedTile['meta']['big_value_color'] = value['big_value_color']
cachedTile['meta']['fading_background'] = value[
'fading_background']
cache.set(tilePrefix, json.dumps(cachedTile))
return HttpResponse(f"{tile_key} data updated successfully.")
except Exception as e:
return HttpResponseServerError(e)
raise Http404
def push(request, unsecured=False):
""" Update the content of a tile(widget) """
if request.method == "POST":
if not checkAccessToken(
method="POST", request=request, unsecured=unsecured):
return HttpResponse("API KEY incorrect", status=401)
try:
tile_id = request.POST.get("key", None)
data = request.POST.get("data", None)
tile_template = request.POST.get("tile", None)
if not tile_id or not data or not tile_template:
return HttpResponseBadRequest(f"Missing data")
tilePrefix = getRedisPrefix(tile_id)
if not redis.exists(tilePrefix):
if LOG:
print(
f"{getTimeStr()}: (+) {tile_id} not found in cache, creating tile {tile_template}",
flush=True)
if cache.createTile(tile_id=tile_id,
value=data,
tile_template=tile_template):
return HttpResponse(
f"{tile_id} data created successfully.")
else:
return HttpResponse(
f"Internal Error {tile_id} was not created")
cachedTile = json.loads(redis.get(tilePrefix))
cachedTile['data'] = json.loads(data)
cachedTile['modified'] = getIsoTime()
cachedTile['tile_template'] = tile_template
cache.set(tilePrefix, json.dumps(cachedTile))
return HttpResponse(f"{tile_id} data updated successfully.")
except IOError as e:
return HttpResponseServerError(e)
raise Http404
def update(request,
unsecured=False
): # TODO: "it's better to ask forgiveness than permission" ;)
""" Update the meta(config) AND the content of a tile(widget) """
if request.method == "POST":
if not checkAccessToken(
method="POST", request=request, unsecured=unsecured):
return HttpResponse("API KEY incorrect", status=401)
try:
tile_id = request.POST.get("key", None)
data = request.POST.get("data", None) #Test if var is present
httpResponse = push(request)
if httpResponse.status_code != 200:
return httpResponse
try:
request.POST.get("value", None)
httpResponse = meta(request, tile_id)
if httpResponse.status_code != 200:
return httpResponse
except Exception as e:
if LOG:
print(
f"{getTimeStr()} (-) No meta value for update tile {tile_id}: {e}",
flush=True)
return HttpResponseBadRequest(
f"{tile_id} data updated successfully.")
return HttpResponse(f"{tile_id} data updated successfully.")
except Exception as e:
if LOG:
print(f"{getTimeStr()} (-) Update error: {e}", flush=True)
return HttpResponseBadRequest(f"{e}")
raise Http404
def get_tile(request, tile_key):
""" Return Json from redis for tile_key """
if not checkAccessToken(method='GET', request=request, unsecured=True):
return HttpResponse('API KEY incorrect', status=401)
redis = MyCache().redis
if redis.exists(getRedisPrefix(tile_key)):
return HttpResponse(redis.get(tile_key))
return HttpResponseBadRequest(f'{tile_key} key does not exist.')
def get_tile(request, tile_key, unsecured=False): # pragma: no cover
""" Return Json from redis for tile_key """
if not checkAccessToken(method='GET', request=request, unsecured=unsecured):
return HttpResponse('API KEY incorrect', status=401)
redis = getCache().redis
if redis.exists(tile_key):
return HttpResponse(redis.get(tile_key))
return HttpResponseBadRequest(f'{tile_key} key does not exist.')
def delete_tile(request, tile_key):
""" Delete in redis """
if not checkAccessToken(method='DELETE', request=request, unsecured=True):
return HttpResponse('API KEY incorrect', status=401)
redis = MyCache().redis
if redis.exists(getRedisPrefix(tile_key)):
redis.delete(tile_key)
return HttpResponse('Tile\'s data deleted.')
return HttpResponseBadRequest(f'{tile_key} key does not exist.')
def delete_tile(request, tile_key, unsecured=False): # pragma: no cover
""" Delete in redis """
if not checkAccessToken(method='DELETE', request=request, unsecured=unsecured):
return HttpResponse('API KEY incorrect', status=401)
redis = getCache().redis
if redis.exists(tile_key):
redis.delete(tile_key)
return HttpResponse('Tile\'s data deleted.')
return HttpResponseBadRequest(f'{tile_key} key does not exist.')
def meta_api(request, tile_key, unsecured=False): # pragma: no cover
""" Update the meta(config) of a tile(widget) """
if request.method == 'POST':
if not checkAccessToken(
method='POST', request=request, unsecured=unsecured):
return HttpResponse('API KEY incorrect', status=401)
tilePrefix = getRedisPrefix(tile_key)
if not getCache().redis.exists(tilePrefix):
return HttpResponseBadRequest(
f'{tile_key} is not present in cache')
return update_tile_meta(request, tilePrefix, tile_key)
raise Http404
def tile(request,
tile_key,
unsecured=False
): # TODO: "it's better to ask forgiveness than permission" ;)
""" Handles reading and deleting of tile's data """
if request.method == "GET":
if not checkAccessToken(
method="GET", request=request, unsecured=unsecured):
return HttpResponse("API KEY incorrect", status=401)
if redis.exists(tile_key):
return HttpResponse(redis.get(tile_key))
else:
return HttpResponseBadRequest(f"{tile_key} key does not exist.")
elif request.method == "DELETE":
if not checkAccessToken(
method="DELETE", request=request, unsecured=unsecured):
return HttpResponse("API KEY incorrect", status=401)
if redis.exists(tile_key):
redis.delete(tile_key)
return HttpResponse("Tile's data deleted.")
else:
return HttpResponseBadRequest(f"{tile_key} key does not exist.")
raise Http404
def sanity_push_api(request, unsecured):
""" Test token, all data present, correct tile_template and tile_id present in cache """
if not checkAccessToken(method='POST', request=request, unsecured=unsecured):
return False, HttpResponse('API KEY incorrect', status=401)
HttpData = request.POST
if not HttpData.get('tile_id', None) or not HttpData.get('tile_template', None) or \
not HttpData.get('data', None):
return False, HttpResponseBadRequest('Missing data')
if HttpData.get('tile_template', None) not in ALLOWED_TILES:
tile_template = HttpData.get('tile_template', None)
return False, HttpResponseBadRequest(f'tile_template: {tile_template} is unknow')
cache = getCache()
tilePrefix = getRedisPrefix(HttpData.get('tile_id', None))
if not cache.redis.exists(tilePrefix) and not DEBUG:
return False, HttpResponseBadRequest(f'tile_id: {tilePrefix} is unknow')
return True, HttpData
def update_api(request,
unsecured=False
): # TODO: "it's better to ask forgiveness than permission" ;)
""" Update the meta(config) AND the content of a tile(widget) """
if request.method == 'POST':
if not checkAccessToken(
method='POST', request=request, unsecured=unsecured):
return HttpResponse('API KEY incorrect', status=401)
tile_id = request.POST.get('tile_id', None)
data = request.POST.get('data', None) # Test if var is present
if data is None:
print('No data')
httpResponse = push_api(request)
return httpResponse if httpResponse.status_code != 200 else is_meta_present_in_request(
request, tile_id)
raise Http404
def push_api(request, unsecured=False): # pragma: no cover
""" Update the content of a tile (widget) """
if request.method == 'POST':
if not checkAccessToken(
method='POST', request=request, unsecured=unsecured):
return HttpResponse('API KEY incorrect', status=401)
HttpData = request.POST
if not HttpData.get('tile_id', None) or not HttpData.get('tile_template', None) or \
not HttpData.get('data', None):
return HttpResponseBadRequest('Missing data')
data = HttpData.get('data', None)
if 'data' in json.loads(data):
data = json.dumps(json.loads(data)['data'])
return save_tile_ToRedis(tile_id=HttpData.get('tile_id', None),
tile_template=HttpData.get(
'tile_template', None),
data=data,
meta=HttpData.get('meta', None))
raise Http404
def test_0006_checkToken(self):
request = self.fakeClient.get('')
checkAccessToken(method='GET', request=request, unsecured=True)
checkAccessToken(method='GET', request=request, unsecured=False)
def test_0104_api_checkToken(self): # TODO
""" Test token mecanism """
request = self.fakeClient.get('')
checkAccessToken(method='GET', request=request, unsecured=False)
# self.assertTrue(checkAccessToken(method='GET', request=request, unsecured=True))
self.assertTrue(True)