def test_return_404_when_city_report_by_term_not_exists(self):
State().save(self.db.session,
id=1,
name="state1",
abbreviation="s1",
lat=0,
lng=0)
City().save(self.db.session,
id=1,
city='c1',
ibge_id=1,
country='Country1',
state_id=1,
totalcases=10)
City().save(self.db.session,
id=2,
city='c2',
ibge_id=2,
country='Country1',
state_id=1,
totalcases=20)
self.db.session.commit()
resp = self.client.get(
'/data_api/v1/cases/city/c3/report',
headers={
'Authorization':
f"Bearer {self.authentication['access_token']}"
})
self.assertEqual(resp.status_code, 404)
def test_search_on_location_by_term_returns_Null_when_not_exists(self):
State().save(self.db.session,
id=1,
name="state1",
abbreviation="s1",
lat=0,
lng=0)
City().save(self.db.session,
id=1,
city='c1',
ibge_id=1,
country='Country1',
state_id=1,
totalcases=10)
City().save(self.db.session,
id=2,
city='c2',
ibge_id=2,
country='Country1',
state_id=1,
totalcases=20)
self.db.session.commit()
response = city_services.search_on_location_by_term('c3')
self.assertEqual(len(response), 0)
self.assertEqual(response, [])
def store_city():
country = request.json.get("country", "ni")
city = request.json.get("city", "Managua")
active = request.json.get("active", False)
country_rs = Country.query.filter(Country.country == country).one_or_none()
if country_rs is not None:
city_rs = City.query.filter(City.country_id == country_rs.id).filter(
City.city == city).one_or_none()
if city_rs is None:
city_rs = City(city=city, active=active, country_id=country_rs.id)
db.session.add(city_rs)
db.session.commit()
else:
country_rs = Country(country=country)
db.session.add(country_rs)
db.session.commit()
city_rs = City(city=city, active=active, country_id=country_rs.id)
db.session.add(city_rs)
db.session.commit()
info = {"active": active, "country": country, "city": city}
return jsonify(info)
def test_parse_city(self):
response = '''
{"response":[
{"cid":1,"title":"Москва","region":"Regione Abruzzo область"},
{"cid":1074996,"title":"Москва","area":"Порховский район","region":"Псковская область"},
{"cid":1102561,"title":"Москва","area":"Пеновский район","region":"Тверская область"},
{"cid":1130701,"title":"Москва","area":"Верхошижемский район","region":"Кировская область"}
]}
'''
country = CountryFactory.create(remote_id=1)
instance = City(country=country)
instance.parse(json.loads(response)['response'][0])
instance.save()
self.assertEqual(instance.remote_id, 1)
self.assertEqual(instance.name, u'Москва')
instance = City(country=country)
instance.parse(json.loads(response)['response'][1])
instance.save()
self.assertEqual(instance.remote_id, 1074996)
self.assertEqual(instance.name, u'Москва')
self.assertEqual(instance.area, u"Порховский район")
self.assertEqual(instance.region, u"Псковская область")
def test_return_cases_by_state_with_reports(self):
# Generate test data
City().save(self.db.session, city='Igarapava', state='SP',
country='Brasil', total_cases=45, suspects=35,
refuses=3, deaths=2, recovered=1)
City().save(self.db.session, city='Franca', state='SP',
country='Brasil', total_cases=50, suspects=35,
refuses=3, deaths=1, recovered=1)
# Should not include this data
City().save(self.db.session, city='Uberaba', state='MG',
country='Brasil', total_cases=50, suspects=35,
refuses=3, deaths=1, recovered=1)
self.db.session.commit()
resp = self.client.get(
'/data_api/v1/data/state/SP',
headers={
'Authorization': f"Bearer {self.authentication['access_token']}"
}
)
data = json.loads(resp.get_data(as_text=True))
self.assertEqual(data, {
'activeCases': 14,
'deaths': 3,
'recoveredCases': 2,
'suspectedCases': 70
})
def test_return_all_cases(self):
# Seed test data
City().save(
self.db.session, city="c1", state="s1",
country="c1", total_cases=20, suspects=5,
refuses=3, deaths=2, recovered=1)
City().save(
self.db.session, city="c2", state="s2",
country="c1", total_cases=20, suspects=5,
refuses=3, deaths=2, recovered=1)
self.db.session.commit()
resp = self.client.get(
'/data_api/v1/data/all',
headers={
'Authorization': f"Bearer {self.authentication['access_token']}"
}
)
data = json.loads(resp.get_data(as_text=True))
self.assertEqual(data, {
'activeCases': 18,
'deaths': 4,
'recoveredCases': 2,
'suspectedCases': 10
})
def get_city_cases(page):
try:
if page:
city_cases, pagination = City().fetch_paginated(db.session, page)
else:
city_cases = City().fetch_all(db.session)
pagination = {}
cases = []
for c in city_cases:
if c.city not in RESTRAINED_CITIES:
cases.append({
'id': c.id,
'city': c.city,
'ibge_id': c.ibge_id,
'country': c.country,
'state_id': c.state_id,
'totalcases': c.totalcases,
'deaths': c.deaths
})
return {
'cases': cases,
'pagination': pagination,
}
finally:
db.session.close()
def test_return_cases_by_search_state(self):
# Seed test data
City().save(
self.db.session, city="c1", state="s1",
country="c1", total_cases=20, suspects=5,
refuses=3, deaths=2, recovered=1)
City().save(
self.db.session, city="c2", state="s2",
country="c1", total_cases=20, suspects=5,
refuses=3, deaths=2, recovered=1)
self.db.session.commit()
resp = self.client.get(
'/data_api/v1/data/search/s2',
headers={
'Authorization': f"Bearer {self.authentication['access_token']}"
}
)
data = json.loads(resp.get_data())
self.assertEqual(len(data), 1)
self.assertEqual(data, [{
'city': 'c2',
'state': 's2',
'cases': {
'activeCases': 9,
'suspectedCases': 5,
'recoveredCases': 1,
'deaths': 2
}
}])
def test_city_model_1(self):
"""Test adding City objects to and deleting City objects from the db"""
with app.test_request_context():
example1 = City("id1", "name1", "state1", "region1",
"companies1", "finorgs1", "people1")
example2 = City("id2", "name2", "state2", "region2",
"companies2", "finorgs2", "people2")
cities1 = db.session.query(City).all()
db.session.add(example1)
db.session.add(example2)
db.session.commit()
cities2 = db.session.query(City).all()
self.assertTrue(example1 in cities2)
self.assertTrue(example2 in cities2)
self.assertEqual(len(cities2), len(cities1) + 2)
db.session.delete(example1)
db.session.delete(example2)
db.session.commit()
cities3 = db.session.query(City).all()
self.assertTrue(example1 not in cities3)
self.assertTrue(example2 not in cities3)
self.assertEqual(len(cities1), len(cities2) - 2)
def test_return_cases_by_search_multiple_cities(self):
#generate test data
City().save(self.db.session,
city="c1",
state="s1",
country="c1",
total_cases=20,
suspects=5,
refuses=3,
deaths=2,
recovered=1)
City().save(self.db.session,
city="c2",
state="s2",
country="c1",
total_cases=20,
suspects=5,
refuses=3,
deaths=2,
recovered=1)
City().save(self.db.session,
city="c3",
state="s2",
country="c1",
total_cases=20,
suspects=5,
refuses=3,
deaths=2,
recovered=1)
self.db.session.commit()
#act
resp = self.client.get(
'/data_api/v1/data/search?query=s2',
headers={
'Authorization':
f"Bearer {self.authentication['access_token']}"
})
data = json.loads(resp.get_data())
city_data1 = data[0]
city_data2 = data[1]
#assert
assert len(data) == 2
assert city_data1['city'] == "c2"
assert city_data1['state'] == "s2"
assert city_data1['cases']['activeCases'] == 9
assert city_data1['cases']['suspectedCases'] == 5
assert city_data1['cases']['recoveredCases'] == 1
assert city_data1['cases']['deaths'] == 2
assert city_data2['city'] == "c3"
assert city_data2['state'] == "s2"
assert city_data2['cases']['activeCases'] == 9
assert city_data2['cases']['suspectedCases'] == 5
assert city_data2['cases']['recoveredCases'] == 1
assert city_data2['cases']['deaths'] == 2
def test_return_all_city_reports(self):
City().save(self.db.session,
id=1,
city='c1',
ibge_id=1,
country='Country1',
state_id=1,
totalcases=10,
deaths=1)
City().save(self.db.session,
id=2,
city='c2',
ibge_id=2,
country='Country1',
state_id=1,
totalcases=20,
deaths=1)
self.db.session.commit()
resp = self.client.get(
'/data_api/v1/cases/city/report',
headers={
'Authorization':
f"Bearer {self.authentication['access_token']}"
})
response = json.loads(resp.get_data(as_text=True))
self.assertEqual(resp.status_code, 200)
self.assertEqual(response, {'totalCases': 30, 'deaths': 2})
def test_city_cases_paginated_return_cases_without_restrained_cities(self):
City().save(self.db.session,
id=1,
city='NÃO ESPECIFICADA',
ibge_id=1,
country='Country1',
state_id=1,
totalcases=10,
deaths=1)
City().save(self.db.session,
id=2,
city='FORA DO ESTADO',
ibge_id=2,
country='Country1',
state_id=1,
totalcases=10,
deaths=1)
City().save(self.db.session,
id=3,
city='ESTRANGEIRO',
ibge_id=3,
country='Country1',
state_id=1,
totalcases=10,
deaths=1)
City().save(self.db.session,
id=4,
city='c1',
ibge_id=4,
country='Country1',
state_id=1,
totalcases=20,
deaths=1)
self.db.session.commit()
response = city_services.get_city_cases(1)
self.assertEqual(len(response.get('cases')), 1)
self.assertEqual(
response, {
'cases': [{
'city': 'c1',
'ibge_id': 4,
'id': 4,
'country': 'Country1',
'deaths': 1,
'state_id': 1,
'totalcases': 20
}],
'pagination': {
'current_page': 1,
'has_next': False,
'has_previous': False,
'next_page': None,
'total_pages': 1
}
})
def setUp(self):
# set up the test DB
self.db = tested_db
self.db.create_all()
self.db.session.add(City(id=1, city_name="montreal", country="canada"))
self.db.session.add(City(id=2, city_name="boston", country="us"))
self.db.session.commit()
self.app = tested_app.test_client()
def test_return_all_city_cases_paginated(self):
City().save(self.db.session,
id=1,
city='c1',
ibge_id=1,
country='Country1',
state_id=1,
totalcases=10,
deaths=1)
City().save(self.db.session,
id=2,
city='c2',
ibge_id=2,
country='Country1',
state_id=1,
totalcases=20,
deaths=1)
self.db.session.commit()
resp = self.client.get(
'/data_api/v1/cases/city/1',
headers={
'Authorization':
f"Bearer {self.authentication['access_token']}"
})
response = json.loads(resp.get_data(as_text=True))
self.assertEqual(resp.status_code, 200)
self.assertEqual(
response, {
'cases': [{
'id': 1,
'city': 'c1',
'deaths': 1,
'ibge_id': '1',
'country': 'Country1',
'state_id': 1,
'totalcases': 10
}, {
'id': 2,
'city': 'c2',
'deaths': 1,
'ibge_id': '2',
'country': 'Country1',
'state_id': 1,
'totalcases': 20
}],
'pagination': {
'current_page': 1,
'has_next': False,
'has_previous': False,
'next_page': None,
'total_pages': 1
}
})
def test_search_on_location_by_term_return_cases_without_restrained_cities(
self):
State().save(self.db.session,
id=1,
name="state1",
abbreviation="s1",
lat=0,
lng=0)
City().save(self.db.session,
id=1,
city='NÃO ESPECIFICADA',
ibge_id=1,
country='Country1',
state_id=1,
totalcases=10,
deaths=1)
City().save(self.db.session,
id=2,
city='FORA DO ESTADO',
ibge_id=2,
country='Country1',
state_id=1,
totalcases=10,
deaths=1)
City().save(self.db.session,
id=3,
city='ESTRANGEIRO',
ibge_id=3,
country='Country1',
state_id=1,
totalcases=10,
deaths=1)
City().save(self.db.session,
id=4,
city='c1',
ibge_id=4,
country='Country1',
state_id=1,
totalcases=20,
deaths=1)
self.db.session.commit()
response = city_services.search_on_location_by_term('c1')
self.assertEqual(len(response), 1)
self.assertEqual(response, [{
'city': 'c1',
'state': 'state1',
'cases': {
'totalCases': 20,
'deaths': 1
}
}])
def test_city_cases_return_cases_with_pagination(self):
City().save(self.db.session,
id=1,
city='c1',
ibge_id=1,
country='Country1',
state_id=1,
totalcases=10,
deaths=1)
City().save(self.db.session,
id=2,
city='c2',
ibge_id=2,
country='Country1',
state_id=1,
totalcases=20,
deaths=1)
self.db.session.commit()
response = city_services.get_city_cases(1)
self.assertEqual(len(response.get('cases')), 2)
self.assertEqual(
response, {
'cases': [{
'city': 'c1',
'ibge_id': 1,
'id': 1,
'country': 'Country1',
'deaths': 1,
'state_id': 1,
'totalcases': 10
}, {
'city': 'c2',
'ibge_id': 2,
'id': 2,
'country': 'Country1',
'deaths': 1,
'state_id': 1,
'totalcases': 20
}],
'pagination': {
'current_page': 1,
'has_next': False,
'has_previous': False,
'next_page': None,
'total_pages': 1
}
})
def test_city_init_2(self):
"""Tests construction of two instances of City"""
city1 = City("id1", "name1", "state1", "region1",
"companies1", "finorgs1", "people1")
city2 = City("id2", "name1", "state2", "region1",
"companies2", "finorgs1", "people2")
self.assertNotEqual(city1.city_id, city2.city_id)
self.assertEqual(city1.name, city2.name)
self.assertNotEqual(city1.state, city2.state)
self.assertEqual(city1.region, city2.region)
self.assertNotEqual(city1.companies, city2.companies)
self.assertEqual(city1.financial_orgs, city2.financial_orgs)
self.assertNotEqual(city1.people, city2.people)
def test01_setup(self):
"Setting up for related model tests."
for name, state, lon, lat in cities:
loc = Location(point=Point(lon, lat))
loc.save()
c = City(name=name, state=state, location=loc)
c.save()
def add_city(state_id):
"""Creates City object"""
req = request.get_json()
state = storage.get("State", state_id)
if state is None:
abort(404)
if req is None:
return (jsonify("Not a JSON"), 400)
try:
req['name']
except:
return (jsonify("Missing name"), 400)
req['state_id'] = state_id
city_data = City(**req)
for k, v in req.items():
setattr(city_data, k, v)
city_data.save()
return (jsonify(city_data.to_json()), 201)
def post(self):
if request.is_json:
data = request.get_json()
id = data.get('id')
if id:
city = City.query.get(data['id'])
city.countrycode = data['countrycode']
city.name = name = data['name']
city.district = data['district']
city.population = data['population']
db.session.commit()
results = city_serilize(city)
return {"message": "City has been created successfully.", "city": results}
else:
result = db.session.query(func.max(City.id).label('ml')).subquery()
users = db.session.query(City).join(result, result.c.ml == City.id).first()
city = City(id=users.id + 1, name=data['name'], countrycode=data['countrycode'],
district=data['district'],
population=data['population'])
db.session.add(city)
db.session.commit()
results = city_serilize(city)
return {"message": "City has been created successfully.", "city": results}
else:
return {"error": "The request payload is not in JSON format"}
def index():
if 'file' in request.files:
filename = request.files['file'].filename
if allowed_file(filename, {'xls', 'xlsx'}):
filename = secure_filename(filename)
filepath = join(path_app, 'data', filename)
request.files['file'].save(filepath)
sheet = open_workbook(filepath).sheet_by_index(0)
properties = sheet.row_values(0)
db.session.query(City).delete()
for row_index in range(1, sheet.nrows):
city_dict = dict(zip(properties, sheet.row_values(row_index)))
city = City(**city_dict)
db.session.add(city)
db.session.commit()
tsp.update_data()
session['best'] = float('inf')
session['crossover'], session['mutation'] = 'OC', 'Swap'
view = request.form['view'] if 'view' in request.form else '2D'
cities = {
city.id: OrderedDict([(property, getattr(city, property))
for property in City.properties])
for city in City.query.all()
}
return render_template('index.html',
view=view,
cities=cities,
async_mode=socketio.async_mode)
def create_city(**kwargs):
session = Session()
city = City()
for k, v in kwargs.iteritems():
setattr(city, k, v)
session.add(city)
session.commit()
def load_users():
"""Users generated from online mock data"""
is_activated_list = [True, False]
signup_file = open('seed_data/signup.csv')
profile_pic = "http://i.imgur.com/Jckb780t.jpeg"
for line in signup_file:
name, lastname, email, password, country, city = line.rstrip().split(',')
city_in_db = db.session.query(City).filter(City.name==city).first()
if not city_in_db:
country_code = search_country_code(country)
new_city = City(name=city, country_code=country_code)
db.session.add(new_city)
db.session.commit()
city_id = db.session.query(City).filter(City.name==city).first().city_id
is_activated = choice(is_activated_list)
password = argon2.hash(password)
description = "I love traveling, meeting new people, trying different kinds of food and learning new languages. There are so many places to visit and very little time!"
user = User(name=name, lastname=lastname, city_id=city_id, email=email, password=password, is_activated=is_activated, picture=profile_pic, description=description)
db.session.add(user)
db.session.commit()
def setUp(self):
"""Before each test, add sample city, user, cafe, and like"""
City.query.delete()
User.query.delete()
Cafe.query.delete()
Like.query.delete()
city = City(**CITY_DATA)
db.session.add(city)
user = User.register(**TEST_USER_DATA)
db.session.add(user)
cafe = Cafe(**CAFE_DATA)
db.session.add(cafe)
db.session.commit()
like = Like(user_id=user.id, cafe_id=cafe.id)
db.session.add(like)
db.session.commit()
self.cafe_name = cafe.name
self.cafe_id = cafe.id
# self.cafe = cafe
self.user = user
self.like = like
def index_post():
err_msg = ''
new_city = request.form.get('city')
if new_city:
existing_city = City.query.filter_by(name=new_city).first()
if not existing_city:
new_city_data = get_weather_data(new_city)
if new_city_data['cod'] == 200:
new_city_obj = City(name=new_city)
db.session.add(new_city_obj)
db.session.commit()
else:
err_msg = 'City does not exist in the World'
else:
err_msg = 'City already exists in the database!'
if err_msg:
flash(err_msg, 'error' )
else:
flash('City added succesfully!')
return redirect(url_for('index_get'))
def test_child_City(self):
""" Tests if the class City is a child class """
city = City()
self.assertIsInstance(city, BaseModel)
self.assertTrue(hasattr(user, "id"))
self.assertTrue(hasattr(user, "created_at"))
self.assertTrue(hasattr(user, "updated_at"))
def create_city_nodes(df):
n_nodes = 0
for _, row in df.drop_duplicates(subset=["city"]).iterrows():
city = City(name=row["city"])
city.save()
n_nodes += 1
print("created {} nodes".format(n_nodes))
def get_alert_cities():
cities = list()
for job in aioschedule.jobs:
city = City(job.job_func.args[1])
city.time = job.at_time.strftime('%H:%M')
cities.append(city)
return cities
def post_city():
data = request.get_json()
cities = session.query(City).all()
countries = session.query(Country).all()
c = [city.city for city in cities]
country_ids = sorted([country.country_id for country in countries])
city_ids = sorted([city.city_id for city in cities])
last = session.query(City).filter(
City.city_id == city_ids[-1]).one().city_id
if data["country_id"] in country_ids:
new_city = City(city_id=(last + 1),
city=data["city_name"],
country_id=data["country_id"],
last_update=datetime.utcnow())
session.add(new_city)
session.commit()
new_city = {
"country_id": new_city.country_id,
"city_name": new_city.city,
"city_id": new_city.city_id
}
new_city = jsonify(new_city)
return new_city
else:
err = {"error": "Invalid country_id"}
err = jsonify(err)
return make_response(err, 400)
return "OK"
def cities_scrape():
"""
scrape cities from seed file
"""
cities_list = []
with open("cities.txt", "r") as cities:
for line in cities:
cities_list.append(line)
for city in cities_list:
name, longitude, latitude, uri = search_for_city(city)
description = get_wikipedia_description(name)
state = city.split(",")[1]
state = state[1:-1]
print(name)
print(longitude)
print(latitude)
print(uri)
print(description)
print(state)
print("\n\n")
city_model = City(name=name,
longitude=longitude,
latitude=latitude,
image_uri=uri,
description=description,
state=state,
country="United States")
add_city_to_database(city_model)
