def save_shopping_list(self, shopping_list: ShoppingList):
"""Einkaufsliste aktualisieren
:param shopping_list: Einkaufslisten-Objekt
:return: Aktualisierte Einkaufsliste
"""
shopping_list.set_last_updated(datetime.now())
with ShoppingListMapper() as mapper:
return mapper.update(shopping_list)
def archive_shopping_list(self, shopping_list: ShoppingList):
"""Einkaufsliste archivieren
:param shopping_list: Einkaufslisten-Objekt
:return: Archiviertes Einkaufslisten-Objekt
"""
shopping_list.set_archived(True)
with ShoppingListMapper() as mapper:
return mapper.update(shopping_list)
def find_by_group(self, group, include_archived=False):
"""Auslesen von Shoppinglisten durch Fremdschlüssel (group_id) geg. Gruppe
:param group: Gruppen-Objekt
:param include_archived: Angabe, ob archivierte Shoppinglists
ausgegeben werden sollen
:return Eine Sammlung mit Shoppinglisten-Objekten.
"""
incl_arch = ""
if include_archived == False:
incl_arch = " AND archived = FALSE"
print(include_archived)
cursor = self._connection.cursor()
command = "SELECT * FROM shopping_list " \
"WHERE group_id={}{}".format(group.get_id(),
incl_arch)
cursor.execute(command)
tuples = cursor.fetchall()
result = ShoppingList.from_tuples(tuples)
self._connection.commit()
cursor.close()
return result
def put(self, shopping_list_id):
"""Update eines bestimmten Shoppinglisten-Objekts."""
adm = Administration()
sl = ShoppingList.from_dict(api.payload)
if sl is not None:
sl.set_id(shopping_list_id)
adm.save_shopping_list(sl)
return '', 200
else:
return '', 500
def create_shopping_list(self, name: str, group_id: int):
"""Einkaufsliste erstellen
:param name:
:param group_id:
:return: Einkaufslisten-Objekt
"""
shopping_list = ShoppingList()
shopping_list.set_id(0)
shopping_list.set_name(name)
shopping_list.set_group(group_id)
with ShoppingListMapper() as mapper:
return mapper.insert(shopping_list)
def post(self, group_id):
"""Anlegen eines neuen Shoppinglisten-Objekts, das zu einer bestimmten
Gruppe gehören wird."""
adm = Administration()
sl = adm.get_group_by_id(group_id)
proposal = ShoppingList.from_dict(api.payload)
if sl is not None and proposal is not None:
result = adm.create_shopping_list(proposal.get_name(), group_id)
return result
else:
return "Group unkown or payload not valid", 500
def delete_shopping_list(self, shopping_list: ShoppingList):
"""Einkaufsliste und zugehörige Beziehungen löschen
:param shopping_list: Einkaufslisten-Objekt
:return:
"""
with ListEntryMapper() as mapper:
group = self.get_group_by_id(shopping_list.get_group())
mapper.delete_standardarticle_by_group(group)
mapper.delete_by_shopping_list(shopping_list)
with ShoppingListMapper() as mapper:
mapper.delete(shopping_list)
def find_all(self):
"""Auslesen aller vorhandenen Shoppinglisten
:return Eine Sammlung aller Shoppinglisten-Objekten.
"""
cursor = self._connection.cursor()
command = "SELECT * FROM shopping_list"
cursor.execute(command)
tuples = cursor.fetchall()
result = ShoppingList.from_tuples(tuples)
self._connection.commit()
cursor.close()
return result
def add_standardarticle_to_shopping_list(self, group: Group,
shopping_list: ShoppingList):
"""Alle Standardartikel einer Gruppe zu einer Einkaufsliste
hinzufügen
:param group: Gruppen-Objekt
:param shopping_list: Einkaufslisten-Objekt
:return:
"""
with ListEntryMapper() as mapper:
standardarticles = mapper.find_standardarticles_by_group_id(
group.get_id())
for standardarticle in standardarticles:
standardarticle.set_id(0)
standardarticle.set_shopping_list(shopping_list.get_id())
mapper.insert(standardarticle)
def find_by_name(self, name):
"""Auslesen von Shoppinglisten durch Name
:param name:
:return Eine Sammlung mit Shoppinglisten-Objekten.
"""
cursor = self._connection.cursor()
command = "SELECT * FROM shopping_list " \
"WHERE name LIKE '{}' AND archived = FALSE " \
"ORDER BY name".format(name)
cursor.execute(command)
tuples = cursor.fetchall()
result = ShoppingList.from_tuples(tuples)
self._connection.commit()
cursor.close()
return result
def find_by_id(self, shopping_list_id):
"""Eindeutiges Auslesen einer Shoppingliste durch ID
:param user_id:
:return Shoppinglisten-Objekt, das der übergebenen ID entspricht
oder None wenn DB-Tupel nicht vorhanden ist.
"""
cursor = self._connection.cursor()
command = "SELECT * FROM shopping_list " \
"WHERE shopping_list_id={}".format(shopping_list_id)
cursor.execute(command)
tuples = cursor.fetchall()
result = ShoppingList.from_tuples(tuples)
self._connection.commit()
cursor.close()
if len(result) == 0:
return None
return result[0]