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