def get(self):
stats = request.args.getlist("stat")
metrics = request.args.getlist("metric")
from_datetime = request.args.get("fromDateTime")
to_datetime = request.args.get("toDateTime")
# Validate query params are provided
if any([
len(stats) == 0,
len(metrics) == 0,
from_datetime is None,
to_datetime is None,
]):
return abort(400)
try:
from_datetime = convert_to_datetime(from_datetime)
to_datetime = convert_to_datetime(to_datetime)
except DatetimeConversionException:
return abort(400)
stats = get_stats(stats, metrics, from_datetime, to_datetime)
output = json.dumps(stats)
resp = Response(output, status=200, mimetype='application/json')
return resp
def get(self):
stats = request.args.getlist("stat")
metrics = request.args.getlist("metric")
from_datetime = request.args.get("fromDateTime")
to_datetime = request.args.get("toDateTime")
# Validate query params are provided
if any(
[
len(stats) == 0,
len(metrics) == 0,
from_datetime is None,
to_datetime is None,
]
):
return abort(400)
try:
from_datetime = convert_to_datetime(from_datetime)
to_datetime = convert_to_datetime(to_datetime)
except DatetimeConversionException:
return abort(400)
print("stat: {}, type: {}".format(stats, type(stats)))
print("metrics: {}, type: {}".format(metrics, type(metrics)))
print("from_datetime: {}, type: {}".format(from_datetime, type(from_datetime)))
print("to_datetime: {}, type: {}".format(to_datetime, type(to_datetime)))
stats = get_stats(stats, metrics, from_datetime, to_datetime)
response = jsonify(stats)
response.status_code = 201
return response
def get(self):
stats = request.args.getlist("stat")
metrics = request.args.getlist("metric")
from_datetime = request.args.get("fromDateTime")
to_datetime = request.args.get("toDateTime")
# Validate query params are provided
if any([
len(stats) == 0,
len(metrics) == 0, from_datetime is None, to_datetime is None
]):
return create_response(
400, body={'message': 'Invalid query parameters'})
#validate query params are subsets of valid params
if not set(stats) <= stats_set or not set(metrics) <= metrics_set:
return create_response(
400, body={'message': 'Invalid stats or metrics'})
try:
from_datetime = convert_to_datetime(from_datetime)
to_datetime = convert_to_datetime(to_datetime)
except DatetimeConversionException:
return create_response(400, body={'message': 'Invalid dates'})
stats = get_stats(stats, metrics, from_datetime, to_datetime)
return jsonify(stats)
def post(self):
data = request.get_json(force=True)
timestamp = data['timestamp']
if not self.validate_data(data):
return abort(400)
try:
timestamp = convert_to_datetime(timestamp)
except DatetimeConversionException:
return abort(400)
metrics = {}
metrics['temperature'] = data['temperature']
metrics['dewPoint'] = data['dewPoint']
metrics['precipitation'] = data['precipitation']
measurement = Measurement(timestamp, metrics)
measurement_store.add_measurement(measurement)
result = {
"timestamp": self.convert_timestamp_to_z(measurement.timestamp),
"temperature": measurement.metrics['temperature'],
"dewPoint": measurement.metrics['dewPoint'],
"precipitation": measurement.metrics["precipitation"]
}
response = jsonify(result)
response.status_code = 201
response.headers[
'location'] = '/measurements/' + self.convert_timestamp_to_z(
measurement.timestamp)
return response
def post(self):
request_data = request.get_json()
#check for valid timestamp
if 'timestamp' not in request_data:
return create_response(
400, body={'message': 'Timestamp must be included'})
timestamp = request_data['timestamp']
try:
timestamp = convert_to_datetime(timestamp)
except DatetimeConversionException:
return create_response(400, body={'message': 'Invalid timestamp'})
#create dictionary of metrics if metric values are valid
metrics = {}
for metric in metric_list:
if metric in request_data:
metrics[metric] = request_data[metric]
if not is_number(metrics[metric]):
return create_response(
400, body={'message': 'Invalid metric values'})
#create and add Measurement object
add_measurement(Measurement(timestamp, metrics))
#create and return response
response = create_response(201)
format_time = get_formatted_time(timestamp)
response.location = '/measurements/' + format_time
return response
def get(self, timestamp):
try:
timestamp = convert_to_datetime(timestamp)
except DatetimeConversionException:
return abort(400)
measurement = measurement_store.get_measurement(timestamp)
if measurement != None:
result = {
"timestamp":
self.convert_timestamp_to_z(measurement.timestamp),
"temperature": measurement.metrics['temperature'],
"dewPoint": measurement.metrics['dewPoint'],
"precipitation": measurement.metrics["precipitation"]
}
response = jsonify(result)
response.status_code = 201
response.headers[
'location'] = '/measurements/' + self.convert_timestamp_to_z(
measurement.timestamp)
return response
# return jsonify(result), 200
else:
return Response(status=404)
def post(self):
# TODO:
#abort(501)
### ADDED ###
# Get data
metrics = {}
timestamp = 0
for key in request.form.keys():
if key == 'timestamp':
timestamp = request.form.get('timestamp')
# Check timestamp
if not timestamp: return abort(400)
try:
timestamp = convert_to_datetime(timestamp)
except DatetimeConversionException:
return abort(400)
else:
metrics[key] = request.form.get(key)
# Check values
if not metrics.get(key): return abort(400)
try:
float(metrics.get(key))
except ValueError:
return abort(400)
# Add measurement
measurement = Measurement(timestamp, metrics)
add_measurement(measurement)
# Return success
resp = jsonify(success=True)
resp.status_code = 201
return resp
def get(self, timestamp):
try:
timestamp = convert_to_datetime(timestamp)
except DatetimeConversionException:
return abort(400)
# TODO:
abort(501)
def add(self, measurement):
timestamp = measurement.timestamp
try:
timestamp = convert_to_datetime(timestamp)
except DatetimeConversionException:
pass
if timestamp not in self.measurements.keys():
tmp = copy.deepcopy(measurement.metrics)
self.measurements[timestamp].append(tmp)
def get_measurement(date):
"""get the right measurement for the selected timestamp
"""
for measurement in measurements:
try:
timestamp = convert_to_datetime(measurement.timestamp)
if timestamp == date:
return measurement
except DatetimeConversionException:
return abort(400)
return abort(404)
def query_measurements(start_date, end_date):
"""get a list of measurements between start_date and end_date
"""
selected_measurements = []
for measurement in measurements:
try:
timestamp = convert_to_datetime(measurement.timestamp)
if start_date <= timestamp < end_date:
selected_measurements.append(measurement)
except DatetimeConversionException:
return abort(400)
return selected_measurements
def get(self):
stats = request.args.getlist("stat")
if len(stats) == 0:
raise BadRequest("No stats were provided.")
metrics = request.args.getlist("metric")
if len(metrics) == 0:
raise BadRequest("No metrics were provided.")
from_datetime = request.args.get("fromDateTime")
if from_datetime is None:
raise BadRequest("fromDateTime was not provided.")
to_datetime = request.args.get("toDateTime")
if to_datetime is None:
raise BadRequest("toDateTime was not provided.")
try:
from_datetime = convert_to_datetime(from_datetime)
to_datetime = convert_to_datetime(to_datetime)
except DatetimeConversionException:
raise BadRequest(description="Timestamp input is invalid.")
stats = get_stats(stats, metrics, from_datetime, to_datetime)
return jsonify(stats)
def get(self):
stats = request.args.getlist("stat")
metrics = request.args.getlist("metric")
from_datetime = request.args.get("fromDateTime")
to_datetime = request.args.get("toDateTime")
# Validate query params are provided
if any([
len(stats) == 0,
len(metrics) == 0,
from_datetime is None,
to_datetime is None,
]):
return abort(400)
try:
from_datetime = convert_to_datetime(from_datetime)
to_datetime = convert_to_datetime(to_datetime)
except DatetimeConversionException:
return abort(400)
stats = get_stats(stats, metrics, from_datetime, to_datetime)
return stats
def delete(self, timestamp):
try:
timestamp = convert_to_datetime(timestamp)
except DatetimeConversionException:
return create_response(400, body={'message': 'Invalid timestamp'})
delete_result = delete_measurement(timestamp)
#create and return response
if delete_result is None:
return create_response(404,
body={'message': 'Measurement not found'})
else:
return create_response(204)
def get(self, timestamp):
try:
timestamp = convert_to_datetime(timestamp)
except DatetimeConversionException:
return abort(400)
# TODO:
#abort(501)
### ADDED ###
measurement = get_measurement(timestamp)
if not measurement: return abort(404)
ret = measurement.metrics
ret['timestamp'] = measurement.timestamp
return jsonify(ret)
def get(self, timestamp):
"""get a measurement for a specific 'timestamp'
with a status code of 200
And a response body with the timestamp and all metrics
"""
try:
timestamp = convert_to_datetime(timestamp)
except DatetimeConversionException:
return abort(400)
measurement = get_measurement(timestamp)
# add metrics and timestamp in the same list to display them together
display_measurement = measurement.metrics
display_measurement['timestamp'] = measurement.timestamp
response = jsonify(display_measurement)
response.status_code = 200
response.headers['location'] = '/measurements/' + measurement.timestamp
return response
def get(self, timestamp):
try:
timestamp = convert_to_datetime(timestamp)
except DatetimeConversionException:
return create_response(400, body={'message': 'Invalid timestamp'})
measurement = get_measurement(timestamp)
#create and return response
if measurement is None:
return create_response(404,
body={'message': 'Measurement not found'})
else:
format_time = get_formatted_time(measurement.timestamp)
body = {
"timestamp": format_time,
"temperature": measurement.get_metric('temperature'),
"dewPoint": measurement.get_metric('dewPoint'),
"precipitation": measurement.get_metric('precipitation')
}
return create_response(200, body=body)
def get(self, timestamp):
print("received get request for {}".format(timestamp))
try:
timestamp = convert_to_datetime(timestamp)
except DatetimeConversionException:
return abort(400)
measurement = get_measurement(timestamp)
print("received response {}".format(measurement))
if 'timestamp' not in measurement:
abort(404, "information not available")
try:
measurement['timestamp'] = convert_to_string(
measurement['timestamp'])
except DatetimeConversionException as dce:
print("error converting datetime object to string")
abort(501)
response = jsonify(measurement)
response.status_code = 201
return response
def post(self):
if not request.is_json:
abort(400, "please send request in json format")
request_data_dic = request.json
if 'timestamp' not in request_data_dic:
abort(400, "timestamp field can be empty")
try:
timestamp_str = request_data_dic.pop('timestamp')
timestamp = convert_to_datetime(timestamp_str)
except DatetimeConversionException as dce:
print("Error: {}".format(dce))
abort(400, "improper timestamp format")
except Exception as e:
print("improper timestamp {}".format(e))
abort(400, "invalid timestamp")
metrics = {}
for metric, value in request_data_dic.items():
try:
print("adding {} and {}".format(metric, value))
metrics[metric] = float(value)
except ValueError as e:
print("value error parsing metric value {}".format(e))
abort(400, "illegal metric value")
except Exception as e:
print("error parsing metric value {}".format(e))
abort(400, "illegal request")
add_measurement(Measurement(timestamp, metrics))
response = jsonify()
response.status_code = 201
response.headers['location'] = '/measurements/{}'.format(timestamp_str)
response.autocorrect_location_header = False
return response
def get(self, timestamp):
try:
timestamp = convert_to_datetime(timestamp)
except DatetimeConversionException:
abort(400)
return get_measurement(timestamp, collected.measurements)
def add_measurement(measurement):
dbstore = db.get_db()
date_str = measurement["timestamp"]
date = convert_to_datetime(date_str)
metrics = {k: v for k, v in measurement.items() if k != "timestamp"}
dbstore[date] = Measurement(date_str, metrics)
def parse_timestamp(timestamp):
try:
timestamp = convert_to_datetime(timestamp)
except DatetimeConversionException:
raise BadRequest(description = "Timestamp input is invalid: {}".format(timestamp))
return timestamp
