def remove_manager(self, owner, to_remove):
"""
Args:
owner:
to_remove:
Returns:
"""
if owner in self.store_owners:
if to_remove in self.store_managers.keys():
if to_remove in self.appointed_by.get(owner):
self.appointed_by[owner].remove(to_remove)
self.store_managers.pop(to_remove)
return True
else:
return False
else:
return False
else:
logger.error("%s is not a store owner", owner)
return False
def get_store(self, store_id: int) -> Store:
if store_id in self.stores.keys():
return self.stores.get(store_id)
else:
logger.error("%d store id doesn't exist", store_id)
return NullStore()
def appoint_manager(self, owner, to_appoint):
"""
Args:
owner: user that in the owners list
to_appoint: user that should be appoint to manager
Returns:
"""
if owner in self.store_owners:
if to_appoint not in self.store_managers.keys():
self.store_managers[to_appoint] = [
getattr(Store, "get_sales_history")
]
self.appointed_by[owner].append(to_appoint)
self.orm.appoint_manager(owner, to_appoint)
return {
'error': False,
'data': to_appoint + ' has become a manager'
}
else:
return {
'error': True,
'error_msg': to_appoint + ' is already a manager'
}
else:
logger.error("%s is not a store owner", owner)
return {
'error': True,
'error_msg': to_appoint + ' is not an owner'
}
def remove_permission_from_manager(self, owner, manager, permission):
"""
Args:
owner:
manager:
permission:
Returns:
"""
if owner in self.store_owners:
if manager in self.store_managers.keys():
if manager in self.appointed_by[owner]:
permission_function = getattr(Store, permission)
if permission_function in self.store_managers.get(manager):
self.store_managers[manager].remove(permission_function)
return True
else:
return False
else:
return False
else:
return False
else:
logger.error("%s is not a store owner", owner)
return False
def add_product(self, user_name: str, product_name: str,
product_price: int, product_categories, key_words: [str],
amount):
"""
Args:
user_name:the user who wants to add product, should be a owner
or a manager with permission
product_name:product name
product_price:product price
product_categories:
key_words:
Returns:
"""
if self.is_owner(user_name) or self.check_permission(
user_name, 'update_products'):
self.inventory.add_product(
product_name,
Product(product_name, product_price, product_categories,
key_words, amount, self.store_id))
return {'error': False, 'data': "Product has been added"}
else:
logger.error("%s Don't have this permission", user_name)
return {'error': True, 'error_msg': "User don't have permission"}
def appoint_owner(self, owner, to_appoint):
"""
Args:
owner:
to_appoint:
Returns:
"""
if owner in self.store_owners and \
to_appoint not in self.store_owners:
return {
'error': False,
'data': self.appoint_owner_helper(owner, to_appoint)
}
else:
logger.error("%s is not a store owner or %s is already owner",
owner, to_appoint)
return {
'error':
True,
'error_msg':
owner + "is not a store owner or " + to_appoint +
" is already owner"
}
def find_reg_user(self, username):
if username in self.reg_user_list.keys():
user = self.reg_user_list[username]
return True, user
logger.error("registered user with username %s does not exist",
username)
return False, {'error_msg': 'User ' + username + ' does not exist.'}
def find_reg_user(self, username) -> RegisteredUser:
if username in self.reg_user_list.keys():
user = self.reg_user_list[username]
return user
logger.error("registered user with username %s does not exist",
username)
return NullUser()
def _import_events_from_sitemap(self):
sitememap_urls = self.harzinfo_loader.load_sitemap()
for url, lastmod in sitememap_urls.items():
try:
self._import_event_from_sitemap(url, lastmod)
except Exception:
logger.error(f"Event Exception {url}", exc_info=True)
def remove_stock(market, ticker):
try:
stock_list_entry = StockListEntry.query.filter_by(
market=market, ticker=ticker).first()
if stock_list_entry:
db.session.delete(stock_list_entry)
db.session.commit()
except Exception as e:
logger.error(traceback.format_exc())
def find_user(self, username) -> User:
if username in self.reg_user_list.keys():
user = self.reg_user_list[username]
else:
if username in self.guest_user_list.keys():
user = self.guest_user_list[username]
else:
logger.error("user with username %s does not exist", username)
user = NullUser()
return user
def _load_categories(self):
try:
category_list = self.api_client.get_categories()
self.categories = {
c["name"]: {
"id": c["id"]
}
for c in category_list
}
except Exception:
logger.error("Categories Exception", exc_info=True)
def add_stock(market, ticker):
try:
stock = Stock(market, ticker)
stock.generate_metrics()
if stock.data and stock.data['price']:
stock_list_entry = StockListEntry(market.upper(), ticker.upper())
db.session.add(stock_list_entry)
db.session.commit()
return stock
except Exception as e:
logger.error(traceback.format_exc())
def get_stocks_from_db():
try:
stocks = []
stock_list_entries = StockListEntry.query.all()
for stock_list_entry in stock_list_entries:
stocks.append(object_to_dict(stock_list_entry))
return stocks
except Exception as e:
logger.error(traceback.format_exc())
def pay(self, user, cart: Cart) -> [Purchase]:
res = []
cart = jsonpickle.decode(cart)
if True: #self.external_payment_system.pay(user, cart):
for store in cart.baskets.keys():
res.append(
Purchase(
cart.baskets.get(store).products, user, store,
self.p_id))
self.p_id += 1
else:
logger.error("Failed to complete payment")
return jsonpickle.encode(res)
def find_user(self, username):
print(type(username))
if username in self.reg_user_list.keys():
user = self.reg_user_list[username]
return True, user
else:
if username in self.guest_user_list.keys():
user = self.guest_user_list[username]
return True, user
else:
logger.error("user with username %s does not exist", username)
return False, {'error_msg ': 'user not found'}
def update_product(self, user, product_name, attribute, updated):
if self.check_permission(user, "update_products"):
return {
'error':
not self.inventory.update_product(product_name, attribute,
updated),
'data':
'updated'
}
logger.error("%s don't have this permission", user)
return {
'error': True,
'error_msg': user + " don't have this permission"
}
def remove_permission_from_manager(self, owner, manager, permission):
"""
Args:
owner:
manager:
permission:
Returns:
"""
if owner in self.store_owners:
if manager in self.store_managers.keys():
if manager in self.appointed_by[owner]:
# permission_function = getattr(Store, permission)
if permission in self.store_managers.get(manager):
self.store_managers[manager].remove(permission)
self.orm.remove_permission(manager, permission)
return {
'error':
False,
'data':
permission + ' has been removed from ' + manager
}
else:
return {
'error': True,
'error_msg': manager + ' dont has this permission'
}
else:
return {
'error': True,
'error_msg': manager + ' not appointed by ' + owner
}
else:
return {
'error': False,
'error_msg': manager + ' is not a manager'
}
else:
logger.error("%s is not a store owner", owner)
return {
'error': True,
'error_msg': owner + 'is not an owner of this store'
}
def add_permission_to_manager(self, owner, manager, permission):
"""
Args:
owner:
manager:
permission:
Returns:
"""
if owner in self.store_owners:
if manager in self.appointed_by.get(owner):
if manager in self.store_managers.keys():
# permission_function = getattr(Store, permission)
if permission not in self.store_managers.get(manager):
self.store_managers[manager].append(permission)
self.orm.add_permission(manager, permission)
return {
'error': False,
'data':
permission + ' has been added to ' + manager
}
else:
return {
'error': True,
'error_msg':
manager + ' has already this permission'
}
else:
return {
'error': True,
'error_msg': manager + ' is not a manager'
}
else:
return {
'error': True,
'error_msg': manager + ' not appointed by ' + owner
}
else:
logger.error("%s is not a store owner", owner)
return {
'error': True,
'error_msg': owner + ' is not an owner of this store'
}
def drop_data() -> None:
"""
Drop Data from the Tables.
Raises:
SQLAlchemy Exception : May raise when error occurs while working with the DB.
"""
try:
Department.query.delete()
Employee.query.delete()
db.session.commit()
except Exception as err:
logger.error('Couldn\'t delete Data from the Database: {}'.format(
str(err)))
db.session.rollback()
def appoint_owner(self, owner, to_appoint):
"""
Args:
owner:
to_appoint:
Returns:
"""
if owner in self.store_owners and \
to_appoint not in self.store_owners:
return self.appoint_owner_helper(owner, to_appoint)
else:
logger.error("%s is not a store owner or %s is already owner", owner, to_appoint)
return False
def get_stocks_from_google():
try:
stocks = []
stock_list_entries = StockListEntry.query.all()
for stock_list_entry in stock_list_entries:
stock = Stock(stock_list_entry.market, stock_list_entry.ticker)
stock.generate_metrics()
for key, value in stock.data.items():
setattr(stock_list_entry, key, value)
db.session.commit()
stocks.append(object_to_dict(stock_list_entry))
return stocks
except Exception as e:
logger.error(traceback.format_exc())
def appoint_manager(self, owner, to_appoint):
"""
Args:
owner: user that in the owners list
to_appoint: user that should be appoint to manager
Returns:
"""
if owner in self.store_owners:
if to_appoint not in self.store_managers.keys():
self.store_managers[to_appoint] = [getattr(Store, "get_sales_history")]
self.appointed_by[owner].append(to_appoint)
return True
else:
return False
else:
logger.error("%s is not a store owner", owner)
return False
def remove_owner(self, owner, to_remove, publisher: Publisher):
"""
Args:
owner:
to_remove:
:param owner:
:param to_remove:
:param publisher:
Returns:
"""
if owner in self.store_owners:
if to_remove in self.store_owners:
if owner in self.appointed_by.keys(
) and to_remove in self.appointed_by.get(owner):
if to_remove in self.appointed_by.keys():
self.appointed_by[owner].remove(to_remove)
self.__remove_owner_all_appointed(to_remove, publisher)
self.orm.remove_owner(to_remove)
return {'ans': True, 'desc': 'product has been removed'}
else:
logger.error("%s is not a store owner", owner)
return {
'ans': False,
'desc': to_remove + ' is not a appointed by ' + owner
}
else:
return {
'ans': False,
'desc': to_remove + ' is not owner of this store'
}
else:
return {
'ans': False,
'desc': to_remove + ' is not owner of this store'
}
def add_product(self, user_name: str, product_name: str, product_price: int, product_categories,
key_words: [str], amount) -> bool:
"""
Args:
user_name:the user who wants to add product, should be a owner
or a manager with permission
product_name:product name
product_price:product price
product_categories:
key_words:
Returns:
"""
if self.check_permission(user_name, getattr(Store, "add_product")):
self.inventory.add_product(product_name,
Product(product_name, product_price, product_categories, key_words, amount))
return True
else:
logger.error("%s Don't have this permission", user_name)
return False
def remove_manager(self, owner, to_remove):
"""
Args:
owner:
to_remove:
Returns:
"""
if owner in self.store_owners:
if to_remove in self.store_managers.keys():
if to_remove in self.appointed_by.get(owner):
self.appointed_by[owner].remove(to_remove)
self.store_managers.pop(to_remove)
return {
'ans': True,
'desc': to_remove + ' is not a manager by ' + owner
}
else:
return {
'ans': False,
'desc': to_remove + ' is not a appointed by ' + owner
}
else:
return {
'ans': False,
'desc': to_remove + ' is not a manager of this store'
}
else:
logger.error("%s is not a store owner", owner)
return {
'ans': False,
'desc': owner + ' is not an owner of this store'
}
def connect(self):
if self.external_payment_system is not None:
if self.external_payment_system.connect():
return True
logger.error("Failed to connect to payment system")
return False
def connect(self):
if self.external is not None:
if self.external.connect():
logger.error("Failed to connect to shipment system")
return True
return False
def update_product(self, user, product_name, attribute, updated):
if self.check_permission(user, getattr(Store, "update_product")):
return self.inventory.update_product(product_name, attribute, updated)
logger.error("%s don't have this permission", user)
return False
