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)