def get_user_plants():
'''
Route which returns a list of all of the user's plants in json format
'''
if 'email' not in session:
abort(403)
plants_list = []
with util.MongoConnect():
user = users.objects(email=session['email'])
if str(user) == '[]':
abort(401)
user = user[0]
# add all plants in each of the user's gardens
for garden_id in user.gardens:
garden = gardens.objects(id=garden_id)
if garden != []:
garden = garden[0]
for plant_id in garden.plants:
plant = user_plants.objects(id=plant_id)
if plant != []:
plant = plant[0]
plants_list.append(plant.to_dict())
return jsonify(plants_list), 200
def unsubscribe(user_email: str):
with util.MongoConnect():
for user in users.objects():
if user_email == user.email:
user.unsubscribed = True
user.save()
return "Successfully unsubscribed.", 200
return "User not found.", 404
def get_guide_page(guide_page_id):
""" Route to get a guide page """
guide = {}
with util.MongoConnect():
guide = greenthumb.models.mongo.guides.objects.get(id=guide_page_id)
return flask.jsonify(guide.to_dict())
def create_user():
if 'email' in session:
# TODO: change based on function name
return redirect(url_for('get_user_gardens'))
if request.method == 'POST':
with util.MongoConnect():
for user in users.objects():
if request.json['email'] == user.email:
# TODO: Change later
return "", 200
# insert into database, then login
with util.MongoConnect():
users(email=request.json['email'],
gardens=[],
unsubscribed=False).save()
session['email'] = request.json['email']
# TODO: change based on function name
return "", 200
# TODO: change this return
return {}
def get_guides():
""" Route to get the guide page list """
guides = []
with util.MongoConnect():
for guide in greenthumb.models.mongo.guides.objects():
guides.append(json.loads(guide.to_json()))
return flask.jsonify(guides)
def get_catalog_plant_page(plant_id):
""" Route to get a plant page from the catalog """
# connects to data db
with util.MongoConnect():
# Queries catalog Document for plant with matching id
plant = greenthumb.models.mongo.plant_types.objects.get(id=plant_id)
# returns json of plant information
return flask.jsonify(plant.to_dict_image())
def send_all_task_lists(self):
"""
Generate and send task lists for all subscribed users.
"""
with util.MongoConnect():
usrs = users.objects()
for usr in usrs:
self.generate_and_send_task_list(usr)
print("task list sent to {}.".format(usr.email))
def get_catalog():
""" Route to get the catalog plant list """
plants = []
# connects to data db
with util.MongoConnect():
# Queries the catalog document for all plants
# and returns all their information as json
for plant in greenthumb.models.mongo.plant_types.objects():
plants.append(plant.to_dict())
return flask.jsonify(plants)
def login():
if 'email' in session:
# TODO: change based on function name
return redirect(url_for('get_user_gardens'))
if request.method == 'POST':
with util.MongoConnect():
for user in users.objects():
if request.json['email'] == user.email:
session['email'] = user['email']
# TODO: change based on function name
return "", 200
return "", 200
# TODO: change this return
return {}
def delete_plant_in_garden(garden_id: str, plant_id: str):
if 'email' not in session:
abort(403)
if not is_valid_id(garden_id):
abort(401)
if not is_valid_id(plant_id):
abort(401)
with util.MongoConnect():
user = users.objects(email=session['email'])
if str(user) == '[]':
abort(401)
user = user[0]
# need to do str(i) because user.gardens is a list of ObjectIdFields
if garden_id in [str(i) for i in user.gardens]:
try:
garden = gardens.objects(id=garden_id)
except Exception as e:
abort(404)
if str(garden) == '[]':
abort(404)
garden = garden[0]
# same as above
if plant_id not in [str(i) for i in garden.plants]:
abort(401)
try:
plant = user_plants.objects(id=plant_id)
except Exception as e:
abort(404)
if str(plant) == '[]':
abort(404)
plant = plant[0]
plant_type = plant_types.objects(id=str(plant.plant_type_id))
if str(plant_type) == '[]':
abort(401)
plant_type = plant_type[0]
#goes in place of "Water it": plant_type["watering_description"]
garden.plants.remove(plant.id)
garden.save()
plant.delete()
else:
abort(401)
return "", 200
def get_user_gardens():
'''
Route which returns a list of all gardens in json format
'''
if 'email' not in session:
abort(403)
user_gardens = []
with util.MongoConnect():
user = users.objects(email=session['email'])
if str(user) == '[]':
abort(401)
user = user[0]
for garden_id in user.gardens:
garden = gardens.objects(id=garden_id)
if garden != []:
garden = garden[0]
user_gardens.append(json.loads(garden.to_json()))
return jsonify(user_gardens), 200
def add_garden_location():
expected_fields = [
'name', 'address', 'latitudetl', 'longitudetl', 'latitudebr',
'longitudebr'
]
if 'email' not in session:
abort(403)
# check that the right info was provided, else 401
for field in expected_fields:
if field not in request.json:
abort(401)
with util.MongoConnect():
# if user not in database 401
user = greenthumb.models.mongo.users.objects(email=session['email'])
if str(user) == '[]':
abort(401)
user = user[0]
body = request.json
# add garden to db
garden = greenthumb.models.mongo.gardens(
name=body['name'],
address=body['address'],
topleft_lat=body['latitudetl'],
topleft_long=body['longitudetl'],
bottomright_lat=body['latitudebr'],
bottomright_long=body['longitudebr'],
plants=[])
garden.save()
# add garden id to user's garden list
user.gardens.append(str(garden.id))
user.save()
return {"id": str(garden.id)}, 200
def get_user_plants_with_id(plant_id):
'''
Route which returns a the specified plant in json format
'''
if 'email' not in session:
abort(403)
if not is_valid_id(plant_id):
abort(401)
plants_list = {}
with util.MongoConnect():
user = users.objects(email=session['email'])
if str(user) == '[]':
abort(401)
user = user[0]
# add all plants in each of the user's gardens
for garden_id in user.gardens:
garden = gardens.objects(id=garden_id)
if garden != []:
garden = garden[0]
for user_plant_id in garden.plants:
if plant_id != str(user_plant_id):
continue
try:
plant = user_plants.objects(id=plant_id)
except Exception as e:
abort(404)
if str(plant) == '[]':
abort(404)
plant = plant[0]
plants_list = plant.to_dict()
return jsonify(plants_list), 200
def generate_user_tasks(self, usr):
"""
Generate task lists for a user.
"""
spring_mulch_month = 3
spring_mulch_day = 20
fall_mulch_month = 9
fall_mulch_day = 22
min_temp_today = None
min_temp_tomorrow = None
watering_tasks = []
cold_weather_tasks = []
fertilize = (date.today().day == 1)
mulch = ((date.today().month == spring_mulch_month
and date.today().day == spring_mulch_day)
or (date.today().month == fall_mulch_month
and date.today().day == fall_mulch_day))
for garden_id in usr.gardens:
garden_weather_data = util.calc_garden_plants_watering(garden_id)
# in degrees C
if "forecast_data" in garden_weather_data and garden_weather_data[
"forecast_data"][0] and garden_weather_data[
"forecast_data"][1]:
min_temp_today = garden_weather_data["forecast_data"][0][
"min_temp"]
min_temp_tomorrow = garden_weather_data["forecast_data"][1][
"min_temp"]
garden = None
with util.MongoConnect():
gardens_found = gardens.objects(id=garden_id)
if gardens_found:
garden = gardens_found[0]
if garden:
for plant_id in garden.plants:
plant = None
plant_type = None
with util.MongoConnect():
plants_found = user_plants.objects(id=plant_id)
if plants_found:
plant = plants_found[0]
plant_types_found = plant_types.objects(
id=plant.plant_type_id)
if plants_found and plant_types_found:
plant_type = plant_types_found[0]
if plant and plant_type:
last_watered_date = plant.last_watered
days_to_water = plant_type.days_to_water
if days_to_water and (date.today() - last_watered_date
).days >= days_to_water:
watering_tasks.append(
WateringTask(
plant_name=plant.name,
plant_type=plant_type.name,
plant_lat=plant.latitude,
plant_long=plant.longitude,
water_instr=plant_type.
watering_description,
))
if plant.outdoors and min_temp_today and min_temp_tomorrow and "zones" in plant_type.tags:
min_zone = min(plant_type.tags["zones"])
if min_temp_today < util.zone_min_temp(
min_zone
) or min_temp_tomorrow < util.zone_min_temp(
min_zone):
cold_weather_tasks.append(
ColdWeatherTask(
plant_name=plant.name,
plant_type=plant_type.name,
plant_lat=plant.latitude,
plant_long=plant.longitude,
plant_zone=min_zone,
))
return fertilize, mulch, watering_tasks, cold_weather_tasks, min_temp_today, min_temp_tomorrow
def get_garden(garden_id: str):
'''
Route which returns a json object with a single garden
'''
if 'email' not in session:
abort(403)
if not is_valid_id(garden_id):
abort(401)
if request.method == 'DELETE':
with util.MongoConnect():
user = users.objects(email=session['email'])
if str(user) == '[]':
abort(401)
user = user[0]
# need to do str(i) because user.gardens is a list of ObjectIdFields
if garden_id in [str(i) for i in user.gardens]:
try:
garden = gardens.objects(id=garden_id)
except Exception as e:
abort(404)
if str(garden) == '[]':
abort(404)
garden = garden[0]
user.gardens.remove(garden.id)
# delete all plants in the garden
for plant_id in garden.plants:
plant = user_plants.objects(id=plant_id)
if str(plant) == '[]':
continue
plant = plant[0]
plant_type = plant_types.objects(id=plant.plant_type_id)
if str(plant_type) == '[]':
plant.delete()
continue
plant_type = plant_type[0]
plant.delete()
garden.delete()
user.save()
else:
abort(401)
elif request.method == 'PUT':
expected_fields = [
'name', 'address', 'latitudetl', 'longitudetl', 'latitudebr',
'longitudebr'
]
for field in expected_fields:
if field not in request.json:
abort(401)
with util.MongoConnect():
user = users.objects(email=session['email'])
if str(user) == '[]':
abort(401)
user = user[0]
# need to do str(i) because user.gardens is a list of ObjectIdFields
if garden_id in [str(i) for i in user.gardens]:
garden = gardens.objects(id=garden_id)
if str(garden) == '[]':
abort(404)
garden = garden[0]
garden.name = request.json['name']
garden.address = request.json['address']
garden.topleft_lat = request.json['latitudetl']
garden.topleft_long = request.json['longitudetl']
garden.bottomright_lat = request.json['latitudebr']
garden.bottomright_long = request.json['longitudebr']
garden.save()
else:
abort(401)
else:
garden = {}
with util.MongoConnect():
user = users.objects(email=session['email'])
if str(user) == '[]':
abort(401)
user = user[0]
if garden_id in [str(i) for i in user.gardens]:
garden = gardens.objects(id=garden_id)
if str(garden) == '[]':
abort(404)
garden = json.loads(garden[0].to_json())
return jsonify(garden)
return "", 200
def edit_plant_in_garden(garden_id: str, plant_id: str):
expected_fields = [
'plant_type_id', 'latitude', 'longitude', 'light_duration',
'light_intensity', 'last_watered', 'name', 'price', 'outdoors'
]
if 'email' not in session:
abort(403)
if not is_valid_id(garden_id):
abort(401)
if not is_valid_id(plant_id):
abort(401)
# check that the right info was provided, else 401
for field in expected_fields:
if field not in request.json:
# Don't reject if still using the old set of expected fields
if field in ['light_duration', 'light_intensity', 'price']:
request.json[field] = 0
elif field == 'name':
request.json['name'] = ''
elif field == 'outdoors':
request.json['outdoors'] = False
else:
abort(401)
if not is_valid_id(request.json['plant_type_id']):
abort(401)
if request.json['last_watered'].find('.') == -1:
request.json['last_watered'] = request.json['last_watered'] + '.000000'
with util.MongoConnect():
user = users.objects(email=session['email'])
if str(user) == '[]':
abort(401)
user = user[0]
# need to do str(i) because user.gardens is a list of ObjectIdFields
if garden_id in [str(i) for i in user.gardens]:
try:
garden = gardens.objects(id=garden_id)
except Exception as e:
abort(404)
if str(garden) == '[]':
abort(404)
garden = garden[0]
# same as above
if plant_id not in [str(i) for i in garden.plants]:
abort(401)
try:
plant_type = plant_types.objects(
id=request.json['plant_type_id'])
except Exception as e:
abort(404)
if str(plant_type) == '[]':
abort(404)
plant_type = plant_type[0]
try:
plant = user_plants.objects(id=plant_id)
except Exception as e:
abort(404)
if str(plant) == '[]':
abort(404)
plant = plant[0]
plant.plant_type_id = plant_type.id
plant.latitude = request.json['latitude']
plant.longitude = request.json['longitude']
plant.light_duration = request.json['light_duration']
plant.light_intensity = request.json['light_intensity']
plant.name = request.json['name']
plant.price = request.json['price']
plant.outdoors = request.json['outdoors']
plant.last_watered = datetime.datetime.strptime(
request.json['last_watered'], '%Y-%m-%d %H:%M:%S.%f')
plant.save()
else:
abort(401)
return "", 200
