def set_text_content(self, text_content, database):
"""Edit the text_content of this order step"""
if check_type(text_content, str) and check_type(database, Database):
if len(text_content.strip()) == 0:
raise ValueError('text_content should be a non-empty string')
self.text_content = text_content
self.save(database)
def set_name(self, name, database):
"""Edit the name of this order"""
if check_type(name, str) and check_type(database, Database):
if len(name.strip()) == 0:
raise ValueError('name should be a non-empty string')
self.name = name
self.save(database)
def test_check_type_return(self):
"""
check_type returns True when the object is of any type in args
check_type raises TypeError when the types are different
check_type raises an error when the type_object is not a type
"""
self.assertTrue(utilities.check_type('girl', str))
self.assertTrue(utilities.check_type('girl', float, int, str))
self.assertRaises(TypeError, utilities.check_type, 5, bool)
self.assertRaises(ValueError, utilities.check_type, 5, 9)
def __init__(self, key, name, description, category):
if check_type(key, int):
self.key = key
if check_type(name, str):
if len(name.strip()) == 0:
raise ValueError('name should be a non-empty string')
self.name = name
if check_type(description, str):
self.description = description
# the category key.
if check_type(category, int):
self.category = category
self._order_steps = []
def __init__(self, key, text_content, order):
if check_type(key, int):
self.key = key
if check_type(text_content, str):
if len(text_content.strip()) == 0:
raise ValueError('text content should be a non-empty string')
self.text_content = text_content
# the order key. It does not change
if check_type(order, int):
self.order = order
self.key = key
self.order = order
self.text_content = text_content
def __init__(self, key, name, user, description=''):
if check_type(key, int):
self.key = key
if check_type(name, str):
if len(name.strip()) == 0:
raise ValueError('name should be a non-empty string')
self.name = name
if check_type(description, str):
self.description = description
# the creator's key. It does not change
if check_type(user, int):
self.user = user
# the list of child order keys
self._orders = []
def __init__(self, key, first_name, last_name, email, password):
if check_type(key, int):
self.key = key
if check_type(first_name, str):
self.first_name = first_name
if check_type(last_name, str):
self.last_name = last_name
if check_type(email, str):
if check_email_format(email):
self.email = email
if check_type(password, str):
self.password = password
# a list of recipe_category keys
self._recipe_categories = []
def save(self, database):
"""Saves user to the database appropriately"""
# add self's key to db's set of user keys
# Add self to db.users dict with key as self.key
if check_type(database, Database):
database.user_keys.append(self.key)
database.users[self.key] = self
database.user_email_key_map[self.email] = self.key
def __get_max_value(self, unsorted_list):
"""Returns the maximum value of a list or 0 if list is empty"""
if check_type(unsorted_list, list):
length = len(unsorted_list)
if length == 0:
return 0
unsorted_list.sort()
return unsorted_list[length - 1]
def delete(self, database):
"""Deleted the order step"""
if check_type(database, Database):
try:
database.delete_object(self)
order = database.get_order(self.order)
if order:
order.order_steps.remove(self.key)
except KeyError:
raise KeyError('The order step is non-existent in database')
def delete(self, database):
"""Deleted the order and all its steps"""
if check_type(database, Database):
try:
database.delete_object(self)
category = database.get_order_category(self.category)
if category:
category.orders.remove(self.key)
except KeyError:
raise KeyError('The order is non-existent in database')
def delete(self, database):
"""Deletes this category of orders and all orders in it"""
if check_type(database, Database):
try:
database.delete_object(self)
user = database.get_user(self.user)
if user:
user.order_categories.remove(self.key)
except KeyError:
raise KeyError(
'The order category is non-existent in database')
def get_user_by_email(self, email):
"""
Returns a user object corresponding to the email
passed in or None is user does not exist
"""
if check_type(email, str):
try:
user_key = self.user_email_key_map[email]
except KeyError:
return None
return self.get_user(user_key)
def get_order_category(self, order_category_key):
"""
Returns the orderCategory object if it exists
or None if it doesn't
"""
if check_type(order_category_key, int):
try:
order_category = self.order_categories[order_category_key]
except KeyError:
return None
return order_category
def get_user(self, user_key):
"""
returns the User object corresponding to user_key or
None if user does not exist
"""
if check_type(user_key, int):
try:
user = self.users[user_key]
except KeyError:
return None
return user
def get_order_step(self, order_step_key):
"""
Returns the orderStep object if it exists
or None if it doesn't
"""
if check_type(order_step_key, int):
try:
order_step = self.order_steps[order_step_key]
except KeyError:
return None
return order_step
def get_all_orders(self, database):
"""Returns all orders under this category"""
if check_type(database, Database):
local_orders = []
for order in self.orders:
try:
order_object = database.orders[order]
except KeyError:
self.orders.remove(order)
else:
local_orders.append(order_object)
return local_orders
def get_all_steps(self, database):
"""returns a list of all steps that belong to self"""
if check_type(database, Database):
local_order_steps = []
for order_step in self.order_steps:
try:
order_step_object = database.order_steps[order_step]
except KeyError:
self.order_steps.remove(order_step)
else:
local_order_steps.append(order_step_object)
return local_order_steps
def get_all_order_categories(self, database):
"""Returns all the user's order categories"""
if check_type(database, Database):
local_order_categories = []
for category in self.order_categories:
try:
order_category_object = database.order_categories[category]
except KeyError:
self.order_categories.remove(category)
else:
local_order_categories.append(order_category_object)
return local_order_categories
def save(self, database):
"""Saves order category in db and in user"""
# add self's key to set of order categories of user
if check_type(database, Database):
try:
user = database.users[self.user]
user.order_categories.append(self.key)
except KeyError:
raise KeyError('User should be saved in db first')
# add self's key to set of db's order_category_keys
database.order_category_keys.append(self.key)
# Add self to db.order_categories dict with key as self.key
database.order_categories[self.key] = self
# Add self's name and key in db's order_category_name_key_map
database.order_category_name_key_map[self.name] = self.key
def get_next_key(self, type_of_object):
"""Gets the next key basing on the type of object"""
# type_of_object should be of type type
if check_type(type_of_object, type):
if type_of_object == User:
return self.__get_max_value(self.user_keys) + 1
if type_of_object == order:
return self.__get_max_value(self.order_keys) + 1
if type_of_object == orderCategory:
return self.__get_max_value(self.order_category_keys) + 1
if type_of_object == orderStep:
return self.__get_max_value(self.order_step_keys) + 1
def save(self, database):
"""
Save this object's key in parent order's set of order steps
and in db
"""
if check_type(database, Database):
try:
order = database.orders[self.order]
order.order_steps.append(self.key)
except KeyError:
raise KeyError('order should be saved in db first')
# add self's key to set of db's order_step_keys
database.order_step_keys.append(self.key)
# Add self to db.order_steps dict with key as self.key
database.order_steps[self.key] = self
def process_args_data(dict_args_data, *args):
"""
Raise ValueError if mandatory values are empty strings or
non-existent
"""
if utilities.check_type(dict_args_data, dict):
for arg in args:
try:
value = dict_args_data[arg]
if isinstance(value, str):
if len(value.strip()) == 0:
raise ValueError('%s should not be an empty string' %
str(arg))
except KeyError:
raise ValueError('%s is an expected key' % str(arg))
return dict_args_data
def create_order(self, database, order_data):
"""
Creates a new order and
adds it to database.orders
"""
if check_type(database, Database):
# get the last order key and add 1
key = database.get_next_key(order)
try:
# save category in database
self.save(database)
order = order(**order_data, key=key, category=self.key)
order.save(database)
except TypeError:
return None
return order
def save(self, database):
"""
Saves the order to the db and to the category's set of orders
"""
if check_type(database, Database):
try:
category = database.order_categories[self.category]
category.orders.append(self.key)
except KeyError:
raise KeyError('Category should be saved in db first')
# add self's key to set of db's order_keys
database.order_keys.append(self.key)
# Add self to db.orders dict with key as self.key
database.orders[self.key] = self
# Add self's name and key in db's order_name_key_map
database.order_name_key_map[self.name] = self.key
def create_step(self, database, order_step_data):
"""
Creates a new order step and
adds it to database.order_steps
"""
if check_type(database, Database):
# get the last order_step key and add 1
key = database.get_next_key(orderStep)
try:
# save order in database
self.save(database)
order_step = orderStep(**order_step_data,
key=key,
order=self.key)
order_step.save(database)
except TypeError:
return None
return order_step
def create_order_category(self, database, order_category_data):
"""
Creates a new order category and
adds it to database.order_categories
"""
if check_type(database, Database):
# get the last order category key and add 1
key = database.get_next_key(orderCategory)
try:
# save user in database
self.save(database)
category = orderCategory(**order_category_data,
key=key,
user=self.key)
category.save(database)
except TypeError:
return None
return category
def set_description(self, description, database):
"""Edit the description of this order"""
if check_type(description, str) and check_type(database, Database):
self.description = description
self.save(database)
