def patch(self, id):
'''
Updates a property in the dataset.
'''
auth_header = request.headers.get('Authorization')
TokenAuthenticator(auth_header, True).authenticate()
session = Session()
prop = session.query(Property).filter(Property.id == id).first()
# Resource not found
if prop is None:
raise NotFound
lga = request.json.get('lga')
p_type = request.json.get('property_type')
r_type = request.json.get('room_type')
g_count = request.json.get('guest_count')
b_count = request.json.get('bed_count')
price = request.json.get('price')
# Empty request
if is_all_none(lga, price, p_type, g_count, b_count, r_type):
raise BadRequest
if lga is not None:
prop.lga = lga
if p_type is not None:
prop.property_type = p_type
if r_type is not None:
prop.room_type = r_type
if g_count is not None:
prop.guest_count = g_count
if b_count is not None:
prop.bed_count = b_count
if price is not None:
prop.price = price
session.commit()
# Analytics
status_code = 200
record = Recorder('property_patch', status_code)
record.recordUsage()
msg = {'message': 'Property ' + str(id) + ' updated successfully.'}
return msg, status_code
def post(self):
'''
Registers a new user
'''
# Get params
first_name = request.json.get('first_name')
last_name = request.json.get('last_name')
email = request.json['email']
password = request.json['password']
# Check email
session = Session()
if session.query(User).filter(User.email == email).first():
raise BadRequest
# Create new user
hashed_password = HashGenerator(password).generate()
new_user = User(first_name, last_name, email, hashed_password)
session.add(new_user)
session.commit()
# Put the current user id in global
g.user_id = new_user.id
# Analytics here
Recorder("register", 201).recordUsage()
response = {'message': 'Registration successful.'}
return response, 201
def post(self):
'''
Creates a new property in the dataset.
'''
auth_header = request.headers.get('Authorization')
TokenAuthenticator(auth_header, True).authenticate()
lga = request.json['lga']
p_type = request.json['property_type']
r_type = request.json['room_type']
g_count = request.json['guest_count']
b_count = request.json['bed_count']
price = request.json['price']
if is_all_none(lga, price, p_type, g_count, b_count, r_type):
raise BadRequest
new_property = Property(lga, p_type, r_type, g_count, b_count, None,
price)
session = Session()
session.add(new_property)
session.commit()
# Analytics
status_code = 201
record = Recorder('property_create', status_code)
record.recordUsage()
response = {'message': 'Property Added.'}
return response, status_code
def get(self, id):
'''
Shows detail of a property in the dataset.
'''
auth_header = request.headers.get('Authorization')
TokenAuthenticator(auth_header, True).authenticate()
session = Session()
prop = session.query(Property).filter(Property.id == id).first()
if prop is None:
raise NotFound
prop = prop.__dict__
prop.pop('_sa_instance_state', None)
# Analytics
status_code = 200
record = Recorder('property_show', status_code)
record.recordUsage()
return prop, status_code
def createAdmin():
session = Session()
password = '******'
hashed_password = HashGenerator(password).generate()
admin = User('admin','admin','*****@*****.**', hashed_password, True)
session.add(admin)
session.commit()
def put(self, id):
'''
Replaces a property in the dataset.
'''
auth_header = request.headers.get('Authorization')
TokenAuthenticator(auth_header, True).authenticate()
session = Session()
prop = session.query(Property).filter(Property.id == id).first()
# Resource not found
if prop is None:
raise NotFound
lga = request.json.get('lga')
p_type = request.json.get('property_type')
r_type = request.json.get('room_type')
g_count = request.json.get('guest_count')
b_count = request.json.get('bed_count')
price = request.json.get('price')
prop.lga = lga
prop.property_type = p_type
prop.room_type = r_type
prop.guest_count = g_count
prop.bed_count = b_count
prop.price = price
session.commit()
# Analytics
status_code = 200
record = Recorder('property_put', status_code)
record.recordUsage()
msg = {'message': 'Property ' + str(id) + ' updated successfully.'}
return msg, status_code
def delete(self, id):
'''
Deletes a property in the dataset.
'''
auth_header = request.headers.get('Authorization')
TokenAuthenticator(auth_header, True).authenticate()
session = Session()
prop = session.query(Property).filter(Property.id == id).first()
# Resource not found
if prop is None:
raise NotFound
session.delete(prop)
session.commit()
# Analytics
status_code = 200
record = Recorder('property_delete', status_code)
record.recordUsage()
msg = {'message': 'Property ' + str(id) + ' deleted successfully.'}
return msg, status_code
def find_user(self):
session = Session()
return session.query(User).filter(User.email == self.email).first()
def recordUsage(self):
session = Session()
new_usage = Usage(self.get_user_id(), request.remote_addr, self.action,
self.status_code)
session.add(new_usage)
session.commit()
def get(self):
'''
Shows list of properties in the dataset.
'''
auth_header = request.headers.get('Authorization')
TokenAuthenticator(auth_header, True).authenticate()
start = request.args.get('start', 0)
limit = request.args.get('limit', 100)
sort = str(request.args.get('sort', ''))
order = str(request.args.get('order', 'asc'))
lga = str(request.args.get('lga', ''))
p_type = str(request.args.get('property_type', ''))
r_type = str(request.args.get('room_type', ''))
g_count = request.args.get('guest_count')
b_count = request.args.get('bed_count')
property_attributes = [
'lga',
'property_type',
'room_type',
'bed_count',
'guest_count',
]
session = Session()
query = session.query(Property)
sortText = str()
if not sort:
sortText = 'properties.id' + " " + order
else:
if sort not in property_attributes:
raise BadRequest
if order not in ['asc', 'desc', '']:
raise BadRequest
sortText = "properties." + sort + " " + order
if lga:
query = query.filter(text("properties.lga = '" + lga + "'"))
if p_type:
query = query.filter(
text("properties.property_type = '" + p_type + "'"))
if r_type:
query = query.filter(
text("properties.room_type = '" + r_type + "'"))
if b_count is not None:
b_count = validate_integer_param(b_count)
query = query.filter(text("properties.bed_count = " +
str(b_count)))
if g_count is not None:
g_count = validate_integer_param(g_count)
query = query.filter(
text("properties.guest_count = " + str(g_count)))
start = validate_integer_param(start)
limit = validate_integer_param(limit)
end = start + limit
records = query.order_by(text(sortText))[start:end]
respJson = list()
for record in records:
record = record.__dict__
record.pop('_sa_instance_state', None)
respJson.append(record)
# Analytics
status_code = 200
record = Recorder('property_index', status_code)
record.recordUsage()
msg = {'data': respJson}
return msg, status_code
def __init__(self, start_date=None, end_date=None, user_id=None):
self.session = Session()
self.start_date = start_date
self.end_date = end_date
self.user_id = user_id
class Summarizer:
def __init__(self, start_date=None, end_date=None, user_id=None):
self.session = Session()
self.start_date = start_date
self.end_date = end_date
self.user_id = user_id
def summarize(self):
summary = {'total': self.get_total()}
action_groups = self.get_action_groups()
per_action_count = {}
for action_group, count in action_groups:
per_action_count[action_group] = count
status_groups = self.get_status_groups()
status_code_count = {}
for status_group, count in status_groups:
status_code_count[status_group] = count
summary['actions'] = per_action_count
summary['status_codes'] = status_code_count
return summary
def get_total(self):
query = self.session.query(Usage)
if self.start_date is not None:
query = query.filter(Usage.used_at >= self.start_date)
if self.end_date is not None:
tomorrow = self.end_date + timedelta(days=1)
query = query.filter(Usage.used_at < tomorrow)
if self.user_id is not None:
query = query.filter(Usage.user_id == self.user_id)
return query.count()
def get_action_groups(self):
query = self.session.query(Usage.action, func.count(Usage.action))
if self.start_date is not None:
query = query.filter(Usage.used_at >= self.start_date)
if self.end_date is not None:
tomorrow = self.end_date + timedelta(days=1)
query = query.filter(Usage.used_at < tomorrow)
if self.user_id is not None:
query = query.filter(Usage.user_id == self.user_id)
return query.group_by(Usage.action).all()
def get_status_groups(self):
query = self.session.query(Usage.status_code,
func.count(Usage.status_code))
if self.start_date is not None:
query = query.filter(Usage.used_at >= self.start_date)
if self.end_date is not None:
tomorrow = self.end_date + timedelta(days=1)
query = query.filter(Usage.used_at < tomorrow)
if self.user_id is not None:
query = query.filter(Usage.user_id == self.user_id)
return query.group_by(Usage.status_code).all()