def create_database():
try:
User.create_table()
except peewee.OperationalError:
pass
try:
State.create_table()
except peewee.OperationalError:
pass
try:
City.create_table()
except peewee.OperationalError:
pass
try:
Place.create_table()
except peewee.OperationalError:
pass
try:
PlaceBook.create_table()
except peewee.OperationalError:
pass
try:
Amenity.create_table()
except peewee.OperationalError:
pass
try:
PlaceAmenities.create_table()
except peewee.OperationalError:
pass
def states():
if request.method == 'GET':
#get list states
states_list = []
states = State.select()
for state in states:
states_list.append(state.to_hash())
return jsonify(states_list)
elif request.method == 'POST':
#create new state
post_name = request.form['name']
states = State.select()
for state in states:
if state.name == post_name:
message = {
'code': 10001,
'msg': 'State already exists',
}
res = jsonify(message)
res.status_code = 409
return res
else:
new_state = State.create(name=post_name)
return jsonify(new_state.to_hash())
def handle_states():
'''Returns all the states from the database as JSON objects with a GET
request, or adds a new state to the database with a POST request. Refer to
exception rules of peewee `get()` method for additional explanation of
how the POST request is handled:
http://docs.peewee-orm.com/en/latest/peewee/api.html#SelectQuery.get
'''
if request.method == 'GET':
list = ListStyle().list(State.select(), request)
return jsonify(list), 200
elif request.method == 'POST':
params = request.values
'''Check that all the required parameters are made in request.'''
required = set(["name"]) <= set(request.values.keys())
if required is False:
return jsonify(msg="Missing parameter."), 400
try:
State.select().where(State.name == request.form['name']).get()
return jsonify(code=10001, msg="State already exists"), 409
except State.DoesNotExist:
state = State.create(name=request.form['name'])
return jsonify(state.to_dict()), 201
def tearDown(self):
#delete all from users
PlaceBook.delete().execute()
Place.delete().execute()
User.delete().execute()
City.delete().execute()
State.delete().execute()
def handle_state_id(state_id):
'''Select the state with the id from the database and store as the variable
`state` with a GET request method. Update the data of the particular state
with a PUT request method. This will take the parameters passed and update
only those values. Remove the state with this id from the database with
a DELETE request method.
Keyword arguments:
state_id: The id of the state from the database.
'''
try:
state = State.select().where(State.id == state_id).get()
except State.DoesNotExist:
return jsonify(msg="There is no state with this id."), 404
if request.method == 'GET':
return jsonify(state.to_dict()), 200
elif request.method == 'DELETE':
try:
state = State.delete().where(State.id == state_id)
except State.DoesNotExist:
raise Exception("There is no state with this id.")
state.execute()
return jsonify(msg="State deleted successfully."), 200
def places_in_state(state_id):
try:
State.get(State.id == state_id)
except State.DoesNotExist:
return jsonify({'code': 404, 'msg': "State does not exist in the database"}), 404
query = Place.select().join(City).join(State).where(State.id == state_id)
return ListStyles.list(query, request), 200
def setUp(self):
# disabling logs
logging.disable(logging.CRITICAL)
self.app = app.test_client()
# connecting to the database
db.connect()
# creating tables
db.create_tables([User], safe=True)
db.create_tables([State], safe=True)
db.create_tables([City], safe=True)
db.create_tables([Place], safe=True)
db.create_tables([PlaceBook], safe=True)
# Creating a setUp
new_state = State(name='California')
new_state.save()
new_city = City(name='San Francisco', state=1)
new_city.save()
# Creating a new users
user1 = User(first_name='Jon',
last_name='Snow',
email='jon@snow',
password='******')
user1.save()
new_place = Place(owner=1,
city=1,
name="Steven",
description="house",
number_rooms=3,
number_bathrooms=2,
max_guest=3,
price_by_night=100,
latitude=37.774929,
longitude=-122.419416)
new_place.save()
def setUp(self):
#connect to db and delete everyone in the users table
PlaceBook.delete().execute()
Place.delete().execute()
User.delete().execute()
City.delete().execute()
State.delete().execute()
def create_state():
"""
Create a state
"""
data = request.form
try:
if 'name' not in data:
raise KeyError('name')
state_check = State.select().where(State.name == data['name'])
new = State.create(name=data['name'])
res = {}
res['code'] = 201
res['msg'] = "State was created successfully"
return res, 201
except KeyError as e:
response = {}
response['code'] = 40000
response['msg'] = 'Missing parameters'
return response, 400
except Exception as e:
response = {}
response['code'] = 10001
response['msg'] = "State already exists"
return response, 409
def test_city_state(self):
new_state = State(name="California")
new_state.save()
new_city = City(name="San Francisco", state=1)
new_city.save()
get_cities = self.app.get('/states/1/cities/1')
assert get_cities.status_code == 200
def handle_state_id(state_id):
'''Select the state with the id from the database and store as the variable
`state` with a GET request method. Update the data of the particular state
with a PUT request method. This will take the parameters passed and update
only those values. Remove the state with this id from the database with
a DELETE request method.
Keyword arguments:
state_id: The id of the state from the database.
'''
try:
state = State.select().where(State.id == state_id).get()
except State.DoesNotExist:
return jsonify(msg="There is no state with this id."), 404
if request.method == 'GET':
return jsonify(state.to_dict()), 200
elif request.method == 'DELETE':
try:
state = State.delete().where(State.id == state_id)
except State.DoesNotExist:
raise Exception("There is no state with this id.")
state.execute()
return jsonify(msg="State deleted successfully."), 200
def setUp(self):
# disabling logs
logging.disable(logging.CRITICAL)
self.app = app.test_client()
# connecting to the database
db.connect()
# creating tables
db.create_tables([User], safe=True)
db.create_tables([State], safe=True)
db.create_tables([City], safe=True)
db.create_tables([Place], safe=True)
db.create_tables([PlaceBook], safe=True)
# Creating a setUp
new_state = State(name='California')
new_state.save()
new_city = City(name='San Francisco', state=1)
new_city.save()
# Creating a new users
user1 = User(first_name='Jon',
last_name='Snow',
email='jon@snow',
password='******')
user1.save()
new_place = Place(owner=1,
city=1,
name="Steven",
description="house",
number_rooms=3,
number_bathrooms=2,
max_guest=3,
price_by_night=100,
latitude=37.774929,
longitude=-122.419416)
new_place.save()
def test_review_place2(self):
# Creating a setUp
new_state = State(name='California')
new_state.save()
new_city = City(name='San Francisco', state=1)
new_city.save()
new_place = Place(owner=1,
city=1,
name="Steven",
description="house",
number_rooms=3,
number_bathrooms=2,
max_guest=3,
price_by_night=100,
latitude=37.774929,
longitude=-122.419416)
new_place.save()
# Creating a review for a place that exist
new_review = self.app.post('/places/1/reviews',
data=dict(message="I like it",
stars=5))
assert new_review.status_code == 200
# checking the review id, should be 1
assert json.loads(new_review.data)["id"] == 1
# Creating a review for a place that does not exist
new_review = self.app.post('/places/3/reviews',
data=dict(message="I like it",
user_id=1,
stars=5))
assert new_review.status_code == 404
def test_review_place3(self):
# Creating a setUp
new_state = State(name='California')
new_state.save()
new_city = City(name='San Francisco', state=1)
new_city.save()
new_place = Place(owner=1,
city=1,
name="Steven",
description="house",
number_rooms=3,
number_bathrooms=2,
max_guest=3,
price_by_night=100,
latitude=37.774929,
longitude=-122.419416)
new_place.save()
# Creating a review for a place that exist
new_review = self.app.post('/places/1/reviews',
data=dict(message="I like it",
stars=5))
assert new_review.status_code == 200
# Checking for a review that does not exist
new_review_get = self.app.get('/places/1/reviews/5')
assert new_review_get.status_code == 404
# Checking for a place that does not exist
new_review_get = self.app.get('/places/2/reviews/2')
assert new_review_get.status_code == 404
# Checking for a review that does exist
new_review_get = self.app.get('/places/1/reviews/1')
assert new_review_get.status_code == 200
def states():
"""Handle GET and POST requests to /states route.
Return a list of all states in the database in the case of a GET request.
Create a new state in the database in the case of a POST request
"""
# handle GET requests:
# --------------------------------------------------------------------------
if request.method == 'GET':
list = ListStyle.list(State.select(), request)
return jsonify(list)
# handle POST requests:
# --------------------------------------------------------------------------
elif request.method == 'POST':
try:
record = State(name=request.form["name"])
record.save()
return jsonify(record.to_hash())
# return 409 state with given name already exists
except IntegrityError:
return json_response(
add_status_=False,
status_=409,
code=10001,
msg="State already exists"
)
def tearDown(self):
"""
Remove city table from airbnb_test database upon completion of test
case.
"""
# drop tables from database
City.drop_table()
State.drop_table()
def MakeState(state_id, state_name, region, is_state, all_states, futures):
state = State.get_by_id(state_id) or State(id=state_id)
state.name = state_name
state.region = region.key
state.is_state = is_state
futures.append(state.put_async())
all_states[state_id] = state
return state
def del_state(id):
id_check = State.select().where(State.id == id)
if not id_check:
return {'code': 404, 'msg': 'State not found'}, 404
item = State.delete().where(State.id == id)
item.execute()
return {'code': 200, 'msg': 'Deleted successfully'}, 200
def tearDown(self):
"""
Remove city table from airbnb_test database upon completion of test
case.
"""
# drop tables from database
City.drop_table()
State.drop_table()
def get_state(state_id):
"""
Get the given state
Returns the given state in the database.
---
tags:
- State
parameters:
-
in: path
name: state_id
type: integer
required: True
description: ID of the state
responses:
200:
description: State returned successfully
schema:
id: State
required:
- name
- id
- created_at
- updated_at
properties:
name:
type: string
description: name of the given state
default: None
id:
type: integer
description: id of the state
default: 1
created_at:
type: datetime string
description: date and time the state was created in the database
default: '2016-08-11 20:30:38'
updated_at:
type: datetime string
description: date and time the state was updated in the database
default: '2016-08-11 20:30:38'
404:
description: State was not found
500:
description: Request could not be processed
"""
try:
''' Check that state_id exists '''
query = State.select().where(State.id == state_id)
if not query.exists():
raise LookupError('state_id')
state = State.get(State.id == state_id)
return state.to_dict(), 200
except LookupError as e:
abort(404)
except Exception as e:
abort(500)
def tearDown(self):
"""
Remove place table from airbnb_test database upon completion of test
case.
"""
Place.drop_table()
City.drop_table()
State.drop_table()
User.drop_table()
def tearDown(self):
"""
Remove place table from airbnb_test database upon completion of test
case.
"""
Place.drop_table()
City.drop_table()
State.drop_table()
User.drop_table()
def create_state():
data = request.form
name_check = State.select().where(State.name == data['name'])
if name_check:
return {'code': 10001, 'msg': 'State already exists'}, 409
state = State.create(
name = data['name']
)
return {'code': 201,'msg': 'State was created successfully'}, 201
def tearDown(self):
"""Remove tables from airbnb_test database upon completion of test."""
ReviewUser.drop_table()
ReviewPlace.drop_table()
Review.drop_table()
Place.drop_table()
City.drop_table()
State.drop_table()
User.drop_table()
def createStateViaPeewee(self):
"""
Create a state record using the API's database/Peewee models.
createStateViaPeewee returns the Peewee object for the record. This
method will not work if the database models are not written correctly.
"""
record = State(name='namestring')
record.save()
return record
def modify_state(state_id):
state = State.get(State.id == state_id)
if request.method == "GET":
return jsonify(state.to_hash())
elif request.method == 'DELETE':
state_info = State.get(State.id == state_id)
state_info.delete_instance()
state_info.save()
return jsonify(msg="State deleted")
def state_id(state_id):
if request.method == 'GET':
#get state from state_id
state = State.get(State.id == state_id)
return jsonify(state.to_hash())
elif request.method == 'DELETE':
#delete state with id state_id
state = State.get(State.id == state_id)
state.delete_instance()
return 'State %s deleted \n' % state_id
def tearDown(self):
"""
Remove placebook table from airbnb_test database upon completion of
test case.
"""
# drop tables from database
PlaceBook.drop_table()
Place.drop_table()
City.drop_table()
State.drop_table()
User.drop_table()
def tearDown(self):
"""
Remove placebook table from airbnb_test database upon completion of
test case.
"""
# drop tables from database
PlaceBook.drop_table()
Place.drop_table()
City.drop_table()
State.drop_table()
User.drop_table()
def state(number):
if request.method == 'GET':
query = State.get(State.id == number)
return query.to_hash()
else:
try:
query = State.select().where(State.id == number).get()
except:
return {'code':404, 'msg':'state not found'}, 404
out_json = query.to_hash()
query.delete_instance()
return out_json
def setUp(self):
"""
Overload def setUp(self): to create a test client of airbnb app, and
create placebook table in airbnb_test database.
"""
self.app = app.test_client() # set up test client
self.app.testing = True # set testing to True
logging.disable(logging.CRITICAL) # disable logs
# connect to airbnb_test database and create tables
database.connect()
database.create_tables([User, State, City, Place, PlaceBook],
safe=True)
# create user record for route
user_record = User(email='anystring',
password='******',
first_name='anystring2',
last_name='anystring3')
user_record.save()
# create state record for route
state_record = State(name="foo-state")
state_record.save()
# create city record for route
city_record = City(name="foo-city", state="1")
city_record.save()
# create place records for route
place_record = Place(owner=1,
city=1,
name="foo",
description="foo description",
number_rooms=1,
number_bathrooms=1,
max_guest=1,
price_by_night=1,
latitude=20.0,
longitude=22.0)
place_record.save()
place_record2 = Place(owner=1,
city=1,
name="foo",
description="foo description",
number_rooms=1,
number_bathrooms=1,
max_guest=1,
price_by_night=1,
latitude=20.0,
longitude=22.0)
place_record2.save()
def setUp(self):
"""
Overload def setUp(self): to create a test client of airbnb app, and
create placebook table in airbnb_test database.
"""
self.app = app.test_client() # set up test client
self.app.testing = True # set testing to True
logging.disable(logging.CRITICAL) # disable logs
# connect to airbnb_test database and create tables
database.connect()
database.create_tables([User, State, City, Place, PlaceBook], safe=True)
# create user record for route
user_record = User( email='anystring',
password='******',
first_name='anystring2',
last_name='anystring3' )
user_record.save()
# create state record for route
state_record = State(name="foo-state")
state_record.save()
# create city record for route
city_record = City(name="foo-city", state="1")
city_record.save()
# create place records for route
place_record = Place( owner=1,
city=1,
name="foo",
description="foo description",
number_rooms=1,
number_bathrooms=1,
max_guest=1,
price_by_night=1,
latitude=20.0,
longitude=22.0 )
place_record.save()
place_record2 = Place( owner=1,
city=1,
name="foo",
description="foo description",
number_rooms=1,
number_bathrooms=1,
max_guest=1,
price_by_night=1,
latitude=20.0,
longitude=22.0 )
place_record2.save()
def create_new_state():
post_data = request.values
if 'name' not in post_data:
return {'code':400, 'msg':'bad request'}, 400
state_query = State.select().where(State.name == post_data['name'])
if state_query.exists():
out = {'code': 10001, 'msg': 'State already exists'}
return out, 409
try:
state_row = State.create(name=post_data['name'])
return state_row.to_hash()
except:
return {'code':500, 'msg':'database connection error'}, 500
def create_state():
"""
Create a state
Creates a state based on post parameters.
---
tags:
- state
parameters:
- name: name
in: query
type: string
description: name of the state to create
responses:
200:
description: Success message
schema:
id: success_message
properties:
status:
type: number
description: status code
default: 200
msg:
type: string
description: Status message
default: 'Success'
400:
description: Error message
schema:
id: error_message
properties:
status:
type: number
description: status code
default: 40000
msg:
type: string
description: Status message
default: 'Missing parameters'
"""
content = request.get_json(force=True)
if not all(param in content.keys() for param in ["name"]):
#ERROR
return error_msg(400, 40000, "Missing parameters")
try:
state = State()
state.name = content["name"]
state.save()
except Exception as e:
return error_msg(400, 400, "Error")
return error_msg(200, 200, "Success")
def get_places_by_city(state_id, city_id):
"""
Get all places
List all places in the given city in the database.
---
tags:
- Place
parameters:
-
name: state_id
in: path
type: integer
required: True
description: ID of the state
-
name: city_id
in: path
type: integer
required: True
description: ID of the city
responses:
200:
description: List of all places
schema:
$ref: '#/definitions/get_places_get_Places'
"""
try:
''' Check if the state_id exists '''
query = State.select().where(State.id == state_id)
if not query.exists():
raise LookupError('state_id')
''' Check if the city_id exists '''
query = City.select().where(City.id == city_id)
if not query.exists():
raise LookupError('city_id')
''' Check if the city_id is associated to the state_id '''
city = City.get(City.id == city_id)
query = State.select().where(State.id == city.state, State.id == state_id)
if not query.exists():
raise LookupError('city_id, state_id')
''' Return all places in the given city '''
data = Place.select().where(Place.city == city.id)
return ListStyle.list(data, request), 200
except LookupError as e:
abort(404)
except Exception as error:
abort(500)
def setUp(self):
"""
Overload def setUp(self): to create a test client of airbnb app, and
create review table in airbnb_test database.
"""
self.app = app.test_client() # set up test client
self.app.testing = True # set testing to True
logging.disable(logging.CRITICAL) # disable logs
database.connect() # connect to airbnb_test db
database.create_tables( # create tables
[User, State, City, Place, Review, ReviewUser, ReviewPlace],
safe=True
)
# create user record for routes
user_record = User(
email='anystring',
password='******',
first_name='anystring2',
last_name='anystring3'
)
user_record.save()
user_record2 = User(
email='anystring-2',
password='******',
first_name='anystring2',
last_name='anystring3'
)
user_record2.save()
# create place records (and dependencies) for routes
state_record = State(name='foo-statee')
state_record.save()
city_record = City(name='foo-city', state=1)
city_record.save()
place_record = Place(
owner_id=1,
city_id=1,
name="foo",
description="foo description",
number_rooms=1,
number_bathrooms=1,
max_guest=1,
price_by_night=1,
latitude=20.0,
longitude=22.0
)
place_record.save()
def app_states():
if request.method == "GET":
try:
query = State.select()
return ListStyles.list(query, request), 200
except State.DoesNotExist:
return jsonify({"code": 404, "msg": "No tables exist yet"}), 404
elif request.method == "POST":
try:
new = State.create(name=str(request.form['name']))
return jsonify(new.to_dict()), 201
except:
return jsonify({"code": 10001, "msg": "State already exists"}), 409
def app_states_id(state_id):
if request.method == "GET":
try:
query = State.get(State.id == state_id)
return jsonify(query.to_dict()), 200
except:
return jsonify({"code": 404, "msg": "not found"}), 404
elif request.method == "DELETE":
try:
query = State.get(State.id == state_id)
query.delete_instance()
return jsonify({"code": 200, "msg": "success"}), 200
except:
return jsonify({"code": 404, "msg": "not found"}), 404
def regional():
with client.context():
year = datetime.date.today().year
championships = Championship.query(
ndb.AND(Championship.year == year,
Championship.region != None)).fetch()
competitions = ndb.get_multi([c.competition for c in championships])
states = State.query().fetch()
regions = Region.query().order(Region.name).fetch()
championships.sort(
key=lambda championship: championship.competition.get().start_date)
championship_regions = [
championship.region for championship in championships
]
regions_missing_championships = [
region for region in regions
if region.key not in championship_regions
]
return render_template(
'regional.html',
c=common.Common(wca_disclaimer=True),
year=year,
championships=championships,
regions_missing_championships=regions_missing_championships)
def edit_championships():
with client.context():
me = auth.user()
if not me or not me.HasAnyRole(Roles.AdminRoles()):
abort(403)
all_us_competitions = (Competition.query(
Competition.country == ndb.Key(Country, 'USA')).order(
Competition.name).fetch())
national_championships = (Championship.query(
Championship.national_championship == True).order(
-Championship.year).fetch())
regional_championships = (Championship.query(
Championship.region != None).order(
Championship.region).order(-Championship.year).fetch())
state_championships = (Championship.query(
Championship.state != None).order(
Championship.state).order(-Championship.year).fetch())
states = State.query().fetch()
regions = Region.query().fetch()
return render_template('admin/edit_championships.html',
c=common.Common(),
all_us_competitions=all_us_competitions,
national_championships=national_championships,
regional_championships=regional_championships,
state_championships=state_championships,
states=states,
regions=regions)
def state_id(state_id):
"""Handle GET and DELETE requests to /states/<state_id> route.
Return a hash of the appropriate record in the database in the case of a
GET request.
Delete the appropriate record in the case of a DELETE request.
"""
# check whether resource exists:
# --------------------------------------------------------------------------
try:
record = State.get(State.id == state_id)
# return 404 not found if it does not
except State.DoesNotExist:
return json_response(
add_status_=False,
status_=404,
code=404,
msg="not found"
)
# if exception does not arise:
# --------------------------------------------------------------------------
# handle GET requests
if request.method == 'GET':
return jsonify(record.to_hash())
# handle DELETE requests
elif request.method == "DELETE":
record.delete_instance()
record.save()
return 'deleted state\n'
def get_states():
if request.method == 'GET':
states = []
query = State.select()
for state in query:
states.append(state.to_hash())
return jsonify(states)
def get_state(id):
try:
state = State.get(State.id == id)
except Exception as e:
return {'code': 404, 'msg': "State not found"}, 404
return state.to_hash(), 200
def ParseFromDict(self, row):
self.start_date = datetime.date(int(row['year']), int(row['month']),
int(row['day']))
self.end_date = datetime.date(int(row['year']), int(row['endMonth']),
int(row['endDay']))
self.year = int(row['year'])
self.name = row['name']
self.short_name = row['cellName']
self.events = [
ndb.Key(Event, event_id)
for event_id in row['eventSpecs'].split(' ')
]
self.latitude = int(row['latitude'])
self.longitude = int(row['longitude'])
state = None
if ',' in row['cityName']:
city_split = row['cityName'].split(',')
state_name = city_split[-1].strip()
state = State.get_state(state_name)
self.city_name = ','.join(city_split[:-1])
if state:
self.state = state.key
else:
self.city_name = row['cityName']
self.country = ndb.Key(Country, row['countryId'])
def setUp(self):
"""
Overload def setUp(self): to create a test client of airbnb app, and
create city table in airbnb_test database.
"""
self.app = app.test_client() # set up test client
self.app.testing = True # set testing to True
logging.disable(logging.CRITICAL) # disable logs
# connect to airbnb_test db and create tables
database.connect()
database.create_tables([State, City], safe=True)
# create state record for route
state_record = State(name='namestring')
state_record.save()
def state_id(state_id):
"""Handle GET and DELETE requests to /states/<state_id> route.
Return a hash of the appropriate record in the database in the case of a
GET request.
Delete the appropriate record in the case of a DELETE request.
"""
# check whether resource exists:
# --------------------------------------------------------------------------
try:
record = State.get(State.id == state_id)
# return 404 not found if it does not
except State.DoesNotExist:
return json_response(add_status_=False,
status_=404,
code=404,
msg="not found")
# if exception does not arise:
# --------------------------------------------------------------------------
# handle GET requests
if request.method == 'GET':
return jsonify(record.to_hash())
# handle DELETE requests
elif request.method == "DELETE":
record.delete_instance()
record.save()
return 'deleted state\n'
def list_of_states():
if request.method == 'GET':
list = ListStyle.list(State.select(), request)
return jsonify(list)
if request.method == 'POST':
# name_state = request.form['name']
try:
new_state = State(name=request.form['name'])
# saving the changes
new_state.save()
# returning the new information in hash form
return "New State entered! -> %s\n" % (new_state.name)
except:
return make_response(jsonify({'code': 10000,
'msg': 'State already exist'}), 409)
def setUp(self):
"""
Overload def setUp(self): to create a test client of airbnb app, and
create city table in airbnb_test database.
"""
self.app = app.test_client() # set up test client
self.app.testing = True # set testing to True
logging.disable(logging.CRITICAL) # disable logs
# connect to airbnb_test db and create tables
database.connect()
database.create_tables([State, City], safe=True)
# create state record for route
state_record = State(name='namestring')
state_record.save()
def handle_place_state_id(state_id):
'''Retrieve all the places with a state of that passed in the URL.
Keyword arguments:
state_id -- The id of the state that this place belongs.
'''
if request.method == 'GET':
try:
State.select().where(State.id == state_id).get()
except State.DoesNotExist:
return jsonify("No state exists with this id."), 400
list = ListStyle().list((Place.select().join(City).join(State).where(
State.id == state_id)), request)
return jsonify(list), 200
def get_states():
"""
Get all states
List all states in the database.
---
tags:
- State
responses:
200:
description: List of all states
schema:
id: States
required:
- data
- paging
properties:
data:
type: array
description: states array
items:
$ref: '#/definitions/get_state_get_State'
paging:
description: pagination
schema:
$ref: '#/definitions/get_amenities_get_Paging'
"""
try:
''' Returns a list of states in list named result '''
data = State.select()
return ListStyle.list(data, request), 200
except Exception as e:
abort(500)
def delete_state(state_id):
"""
Delete state with id as state_id
"""
try:
state = State.get(State.id == state_id)
except Exception as error:
response = {}
response['code'] = 404
response['msg'] = 'State not found'
return response, 404
delete_state = State.delete().where(State.id == state_id)
delete_state.execute()
response = {}
response['code'] = 200
response['msg'] = "State was deleted successfully"
return response, 200
def modify_state(state_id):
try:
# displaying state by id
if request.method == 'GET':
return jsonify(State.get(State.id == state_id).to_dict())
except:
return "No State was found with id %d\n" % (int(id))
if request.method == 'DELETE':
id = state_id
try:
# creating and oobject calling the State
get_state = State.get(State.id == id)
# deleting state based on the id
get_state.delete_instance()
return "State with id %d was deleted\n" % (int(id))
except:
return "No State was found with id %d\n" % (int(id))
def delete_state(number):
try:
query = State.get(State.id == number)
except State.DoesNotExist:
return {'code':404, 'msg':'state not found'}, 404
out_json = query.to_dict()
query.delete_instance()
return out_json
def modify_state(state_id):
try:
# displaying state by id
if request.method == 'GET':
return jsonify(State.get(State.id == state_id).to_dict())
except:
return "No State was found with id %d\n" % (int(id))
if request.method == 'DELETE':
id = state_id
try:
# creating and oobject calling the State
get_state = State.get(State.id == id)
# deleting state based on the id
get_state.delete_instance()
return "State with id %d was deleted\n" % (int(id))
except:
return "No State was found with id %d\n" % (int(id))
def state_places(state_id): state = State.select().where(State.id == state_id) if state.wrapped_count() < 1: return json_response(status_=404, code=10002, msg="state not found") query = Place.select().join(City).join(State).where(State.id == state_id) return ListStyle.list(query, request)
def state_create_modify():
if request.method == 'GET':
state_list = State.select()
order_values = [i.to_hash() for i in state_list]
return jsonify(order_values)
elif request.method == 'POST':
check_state_name = State.select().where(
State.name == request.form['name'])
if check_state_name:
error_msg = {'code': 10001, 'msg': 'State already exists'}
return jsonify(error_msg)
else:
state = State.create(name=request.form['name'])
return jsonify(state.to_hash())
def GetEligibleStateKeys(self):
if self.state:
return [self.state]
if self.region:
return State.query(State.region == self.region).fetch(
keys_only=True)
# National championships are not based on residence, they're based on
# citizenship.
return None
def states_id(state_id): if request.method == 'GET': try: state = State.get(State.id == state_id) return jsonify(state.to_dict()), 200 except State.DoesNotExist: return json_response(status_=404, msg="not found") elif request.method == 'DELETE': try: state = State.get(State.id == state_id) state.delete_instance() state.save() return json_response(status_=200, msg="State succesfully deleted") except State.DoesNotExist: return json_response(status_=404, msg="state does not exist")