def test_coursette_far(self):
businessService = BusinessService()
price, rules = businessService.get_price_and_associated_rules(
category=Category_Enum.COURSETTE.value, nb_far_products=1)
assert float(price) == 6.0
def test_drive_far(self):
businessService = BusinessService()
price, rules = businessService.get_price_and_associated_rules(
category=Category_Enum.DRIVE.value, nb_far_products=1)
assert float(price) == 8.00
def test_article_far_equal_six(self):
businessService = BusinessService()
price, rules = businessService.get_price_and_associated_rules(
Category_Enum.ARTICLE.value, nb_far_products=6)
assert float(price) == 2.90
def test_article_local_equal_seven(self):
businessService = BusinessService()
price, rules = businessService.get_price_and_associated_rules(
category=Category_Enum.ARTICLE.value, nb_local_products=7)
assert float(price) == 3.00
def test_article_local_less_seven(self):
businessService = BusinessService()
price, rules = businessService.get_price_and_associated_rules(Category_Enum.ARTICLE.value, nb_local_products=1, nb_far_products=0)
assert float(price) == 0.60
class SubscriptionManager():
businessService = BusinessService()
shipmentServices = ShipmentManager()
def duplicate_subscription(self, subscription_id, subscription):
existing_subscription = SubscriptionDao.get_one(subscription_id)
created_subscription = SubscriptionDao.add(subscription)
created_subscription.category = existing_subscription.category
db.session.flush()
for subscription_day in existing_subscription.days:
created_day = SubscriptionDayDao.add(created_subscription.id, subscription_day.day_of_week)
created_day.nb_products = subscription_day.nb_products
created_day.price = subscription_day.price
created_day.shipping_price = subscription_day.shipping_price
SubscriptionDayDao.add_existing_lines(created_day, subscription_day.lines)
def create_subscription(self, subscription):
created_subscription = SubscriptionDao.add(subscription)
db.session.flush()
self.create_subscription_days(created_subscription.id)
db.session.commit()
def create_subscription_days(self, subscription_id):
nb_days = 7
for number in range(1, nb_days+1):
SubscriptionDayDao.add(subscription_id, number)
def get_all(self):
return SubscriptionDao.read_all()
def get_all_by_customer(self, customer_id):
return SubscriptionDao.read_all_by_customer(customer_id)
def count_by_customer(self, customer_id):
return SubscriptionDao.count_by_customer(customer_id)
def get_all_by_seller(self, seller_id):
return SubscriptionDao.read_all_by_seller(seller_id)
def get_some(self, customer_id=0, day=datetime.utcnow, period=Period_Enum.ALL.value):
datetime_day = datetime.strptime(day, '%d%m%Y')
start, end = dates_range(period, datetime_day)
return SubscriptionDao.read_some(customer_id=customer_id, start=start, end=end)
def get_some_pagination(self, customer_id=0, day=datetime.utcnow, period=Period_Enum.ALL.value, page=1, per_page=10):
datetime_day = datetime.strptime(day, '%d%m%Y')
start, end = dates_range(period, datetime_day)
return SubscriptionDao.read_some_pagination(customer_id=customer_id, start=start, end=end, page=page, per_page=per_page)
def get_one(self, subscription_id):
return SubscriptionDao.read_one(subscription_id)
def get_one_db(self, subscription_id):
return SubscriptionDao.get_one(subscription_id)
def get_one_day(self, subscription_day_id):
return SubscriptionDayDao.read_one(subscription_day_id)
def get_week_day(self, subscription_id, week_day):
return SubscriptionDayDao.get_one_by_week_day(subscription_id, week_day)
def delete_subscription(self, subscription_id):
SubscriptionDao.delete(subscription_id)
def parse_lines(self, lines):
headers = ('product_id', 'seller_id', 'quantity', 'price' )
items = [{} for i in range(len(lines[0]))]
for x, i in enumerate(lines):
for _x, _i in enumerate(i):
items[_x][headers[x]] = _i
return items
# @
#
def create_day_and_parse_line(self, subscription_day, lines, category=Category_Enum.ARTICLE.value):
parsed_lines = self.parse_lines(lines)
self.create_day(subscription_day, parsed_lines, category)
# @
#
def create_day(self, subscription_day, lines, category=Category_Enum.ARTICLE.value):
id = subscription_day.get('id')
subscription_day_db = SubscriptionDayDao.get_one(id)
SubscriptionDayDao.add_lines(subscription_day_db, lines)
if subscription_day_db.subscription.category == 'INIT':
subscription_day_db.subscription.category = category
db.session.commit()
subscription_day_db.shipping_price, subscription_day_db.shipping_rules = self.businessService.apply_rules_for_subscription_day(
subscription_day_db)
db.session.commit()
# @
#
def cancel_day(self, subscription_day_id):
subscription_day_tmp = SubscriptionDayDao.get_one(subscription_day_id)
subscription_id = subscription_day_tmp.subscription_id
number = subscription_day_tmp.day_of_week
SubscriptionDayDao.delete(subscription_day_id)
subscription_day = SubscriptionDayDao.add(subscription_id, number)
db.session.commit()
return subscription_day
def generate_shipments(self, subscription):
# get a list from all days fo the periode : dict
# date_of_day : datetime 8:00
# get the id of the subscription_day
# for all days from the list :
# get the subscription_day
# create the order (convertion from subscription_day) for the day and for the customer / seller / nb_pducts / prices etc...
# get all the subscription_lines and (convertion to line)
week_day = 0
current_dt = subscription.start_dt
delta = subscription.end_dt - subscription.start_dt
nb_days = 1
while current_dt <= subscription.end_dt:
week_day = current_dt.weekday()+1
subscription_day = self.get_week_day(
subscription_id=subscription.id, week_day=week_day)
shipment = {'title': f'abo {subscription.id} - {nb_days}/{delta.days}',
'customer_id': subscription.customer_id,
'shipping_dt': current_dt,
'subscription_id': subscription.id,
'category' : subscription.category,
}
nb_products = subscription_day.get('nb_products')
lines = []
if nb_products > 0:
for line in subscription_day.get('lines') :
lines.append({'product_id': line.get('product_id'), 'seller_id': line.get('seller_id'), 'quantity': line.get(
'quantity'), 'price': line.get('price')})
self.shipmentServices.create_shipment(shipment, lines)
#increment day
current_dt = current_dt + timedelta(days=1)
nb_days = nb_days + 1
def calculate(self, subscription):
subscription.nb_products = 0
subscription.nb_orders = 0
subscription.price = 0.0
subscription.shipping_price = 0.0
subscription.nb_shipments = 0
db.session.commit()
for shipment in subscription.shipments:
if shipment.status != ShipmentStatus_Enum.ANNULEE.value:
subscription.nb_shipments = subscription.nb_shipments + 1
subscription.shipping_price = subscription.shipping_price + shipment.shipping_price
for order in shipment.orders:
subscription.nb_orders = subscription.nb_orders + 1
subscription.price = subscription.price + order.price
subscription.nb_products = subscription.nb_products + order.nb_products
db.session.commit()
def delete_all_shipments(self, subscription):
for shipment in subscription.shipments:
ShipmentDao.delete(shipment.id)
subscription.nb_products = 0
subscription.nb_orders = 0
subscription.price = 0.0
subscription.shipping_price = 0.0
subscription.nb_shipments = 0
db.session.commit()
class ShipmentManager():
businessService = BusinessService()
itemService = ItemService()
orderService = OrderManager()
def parse_lines(self, lines):
headers = ('product_id', 'seller_id', 'quantity', 'price')
items = [{} for i in range(len(lines[0]))]
for x, i in enumerate(lines):
for _x, _i in enumerate(i):
items[_x][headers[x]] = _i
return items
def sort_lines_by_seller(self, lines):
sorted_lines = []
for line in lines:
res_line = [
sorted_line for sorted_line in sorted_lines
if sorted_line["seller_id"] == line['seller_id']
]
new_line = {
'product_id': line['product_id'],
'quantity': line['quantity'],
'price': line['price']
}
if len(res_line) > 0:
res_line[0]['lines'].append(new_line)
else:
sorted_lines.append({
'seller_id': line['seller_id'],
'lines': [new_line]
})
return sorted_lines
def create_shipment_and_parse_line(self, shipment, lines):
parsed_lines = self.parse_lines(lines)
self.create_shipment(shipment, parsed_lines)
def create_shipment(self, shipment, lines):
created_shipment = ShipmentDao.create_shipment(shipment)
sorted_lines = self.sort_lines_by_seller(lines)
for grouped_lines in sorted_lines:
self.orderService.create_by_shipment(created_shipment,
grouped_lines['lines'],
grouped_lines['seller_id'])
db.session.commit()
if created_shipment.category != Category_Enum.PRESTATION.value:
created_shipment.shipping_price, created_shipment.shipping_rules = self.businessService.apply_rules_for_shipment(
created_shipment)
else:
created_shipment.shipping_price, created_shipment.shipping_rules = self.businessService.prestation_rules_for_shipment(
created_shipment)
db.session.commit()
if created_shipment.subscription_id is not None:
self.items_add_subscription(created_shipment)
def delete_shipment(self, shipment_id):
shipment = ShipmentDao.get_one(shipment_id)
if shipment.subscription_id is not None and shipment.status != ShipmentStatus_Enum.ANNULEE.value:
self.remove_shipment_subscriptions(shipment)
ShipmentDao.delete(shipment_id)
ShipmentDao.update_db(shipment)
def update_shipment_and_parse_line(self, category, shipment_id, lines):
shipment = ShipmentDao.get_one(shipment_id)
shipment.category = category
#remove shipment from subscription
if shipment.subscription != None:
self.remove_shipment_subscriptions(shipment)
# init to 0 shipment
shipment.init_stats()
parsed_lines = self.parse_lines(lines)
sorted_lines = self.sort_lines_by_seller(parsed_lines)
for order in shipment.orders:
b_delete = True
for grouped_lines in sorted_lines:
if str(order.seller_id) == grouped_lines['seller_id']:
b_delete = False
if (b_delete):
shipment.remove_order(order)
for grouped_lines in sorted_lines:
self.orderService.update_by_shipment(shipment,
grouped_lines['lines'],
grouped_lines['seller_id'])
if shipment.category != Category_Enum.PRESTATION.value:
shipment.shipping_price, shipment.shipping_rules = self.businessService.apply_rules_for_shipment(
shipment)
else:
shipment.shipping_price, shipment.shipping_rules = self.businessService.prestation_rules_for_shipment(
shipment)
shipment.updated_at = datetime.now()
if shipment.subscription != None:
self.add_shipment_subscriptions(shipment)
db.session.commit()
def remove_shipment_subscriptions(self, shipment):
subscription = SubscriptionDao.get_one(shipment.subscription_id)
itemService = ItemService()
itemService.decrement_subscription_nb_shipments(subscription) \
.remove_shipment_subscription_nb_products(subscription, shipment.nb_products) \
.remove_shipment_subscription_shipping_price(subscription, shipment.shipping_price) \
.remove_shipment_subscription_nb_orders(subscription, shipment.nb_orders)
SubscriptionDao.update_db(subscription, itemService.items)
def add_shipment_subscriptions(self, shipment):
subscription = SubscriptionDao.get_one(shipment.subscription_id)
itemService = ItemService()
itemService.increment_subscription_nb_shipments(subscription) \
.add_shipment_subscription_nb_products(subscription, shipment.nb_products) \
.add_shipment_subscription_shipping_price(subscription, shipment.shipping_price) \
.add_shipment_subscription_nb_orders(subscription, shipment.nb_orders)
SubscriptionDao.update_db(subscription, itemService.items)
def items_remove_subscription(self, shipment):
subscription = SubscriptionDao.get_one(shipment.subscription_id)
itemService = ItemService()
itemService.remove_shipment_subscription_nb_products(subscription, shipment.nb_products) \
.remove_shipment_subscription_shipping_price(subscription, shipment.shipping_price) \
.decrement_subscription_nb_shipments(subscription) \
.remove_shipment_subscription_nb_orders(subscription, shipment.nb_orders)
SubscriptionDao.update_db(subscription, itemService.items)
def items_add_subscription(self, shipment):
subscription = SubscriptionDao.get_one(shipment.subscription_id)
itemService = ItemService()
itemService.add_shipment_subscription_nb_products(subscription, shipment.nb_products) \
.add_shipment_subscription_shipping_price(subscription, shipment.shipping_price) \
.increment_subscription_nb_shipments(subscription) \
.add_shipment_subscription_nb_orders(subscription, shipment.nb_orders)
SubscriptionDao.update_db(subscription, itemService.items)
# @
#
def update_shipment_status(self, shipment_id, shipment_status):
shipment = ShipmentDao.get_one(shipment_id)
if shipment.status != shipment_status:
if shipment_status == ShipmentStatus_Enum.ANNULEE.value and shipment.subscription_id is not None:
self.items_remove_subscription(shipment)
if shipment_status == ShipmentStatus_Enum.CREE.value and shipment.subscription_id is not None:
self.items_add_subscription(shipment)
for order in shipment.orders:
order.status = shipment_status
ShipmentDao.update_status(shipment_id, shipment_status)
# @
#
def update_shipment_shipping_status(self, shipment_id, shipping_status):
ShipmentDao.update_shipping_status(shipment_id, shipping_status)
# @
#
def update_shipment_payment_status(self, shipment_id, payment_status):
ShipmentDao.update_payment_status(shipment_id, payment_status)
# @
#
def get_in_progess_shipments_counter(self):
return Shipment.query.filter(
Shipment.status == ShipmentStatus_Enum.CREE.value).count()
# @
#
def get_latest_shipments_counter(self):
date_since_2_days = date.today() - timedelta(days=2)
return Shipment.query.filter(
Shipment.created_at > date_since_2_days).count()
def get_all(self):
return ShipmentDao.read_all()
def get_all_by_subscription(self, subscription_id, nocanceled, nopaid):
return ShipmentDao.read_by_subscription(subscription_id, nocanceled,
nopaid)
def get_all_by_subscription_pagination(self,
subscription_id,
page=1,
per_page=10):
return ShipmentDao.read_by_subscription_pagination(
subscription_id, page, per_page)
def get_by_customer_by_period(self,
customer_id=0,
day=datetime.utcnow,
period=Period_Enum.ALL.value,
nocanceled=False,
nopaid=False):
datetime_day = datetime.strptime(day, '%d%m%Y')
start, end = dates_range(period, datetime_day)
return ShipmentDao.read_by_customer_by_period(customer_id,
start=start,
end=end,
nocanceled=nocanceled,
nopaid=nopaid)
def count_by_customer(self, customer_id):
return ShipmentDao.count_by_customer(customer_id)
def sum_by_customer(self, customer_id):
return ShipmentDao.sum_by_customer(customer_id)
def count_canceled_by_customer(self, customer_id):
return ShipmentDao.count_canceled_by_customer(customer_id)
def get_all_by_customer_pagination(self, customer_id, page=1, per_page=10):
return ShipmentDao.read_by_customer_pagination(customer_id, page,
per_page)
def get_some(self,
customer_id=0,
day=datetime.utcnow,
period=Period_Enum.ALL.value):
datetime_day = datetime.strptime(day, '%d%m%Y')
start, end = dates_range(period, datetime_day)
return ShipmentDao.read_some(customer_id=customer_id,
start=start,
end=end)
def get_some_pagination(self,
customer_id=0,
day=datetime.utcnow,
period=Period_Enum.ALL.value,
page=1,
per_page=30,
nocanceled=False,
nopaid=False):
datetime_day = datetime.strptime(day, '%d%m%Y')
start, end = dates_range(period, datetime_day)
return ShipmentDao.read_some_pagination(customer_id=customer_id,
start=start,
end=end,
page=page,
per_page=per_page,
nocanceled=nocanceled,
nopaid=nopaid)
def get_some_valid(self,
customer_id=0,
day=datetime.utcnow,
period=Period_Enum.ALL.value):
datetime_day = datetime.strptime(day, '%d%m%Y')
start, end = dates_range(period, datetime_day)
return ShipmentDao.read_some_valid(customer_id=customer_id,
start=start,
end=end)
def get_one(self, shipment_id):
return ShipmentDao.read_one(shipment_id)
def get_shipment_status(self):
return list(map(lambda c: c.value, ShipmentStatus_Enum))
def update_shipping_dt(self, shipment, shipping_dt):
ShipmentDao.update_shipping_dt(shipment['id'], shipping_dt)
def find(self, products, short_name):
for product in products:
if product['short_name'] == short_name:
return product
return None
def extract_products_from_shipments(self, shipments):
products = []
product = None
for shipment in shipments:
for line in shipment['lines']:
short_name = line['product_short_name']
quantity = line['quantity']
product = self.find(products, short_name)
if product != None:
#line_tmp = [d for d in shipment['lines'] if d['line']['product_short_name'] == short_name]
product['quantity'] = product['quantity'] + int(
line['quantity'])
else:
products.append({
'short_name': line['product_short_name'],
'quantity': int(line['quantity'])
})
return products
def get_total_price(self, shipment):
price = 0.0
for order in shipment.orders:
price = price + order.price