1.started removal of CDNs.\n 2. Improved modular structure for all parts of project including database.

datastores/datastore_base.py

@@ -0,0 +1,158 @@
+"""
+Project:    PARTS Website
+Author:     Edward Middleton-Smith
+            Precision And Research Technology Systems Limited
+
+Technology: DataStores
+Feature:    Base DataStore
+
+Description:
+Datastore for Store
+"""
+
+# internal
+# from routes import bp_home
+import lib.argument_validation as av
+from business_objects.store.basket import Basket, Basket_Item
+from business_objects.store.product_category import Container_Product_Category, Product_Category
+from business_objects.store.currency import Currency
+from business_objects.store.image import Image
+from business_objects.store.delivery_option import Delivery_Option
+from business_objects.store.delivery_region import Delivery_Region
+from business_objects.store.discount import Discount
+from business_objects.store.order import Order
+from business_objects.store.product import Product, Product_Permutation, Product_Price, Product_Filters # Permutation_Variation_Link
+from business_objects.sql_error import SQL_Error
+from business_objects.store.stock_item import Stock_Item, Stock_Item_Filters
+from business_objects.user import User, User_Filters, User_Permission_Evaluation
+from business_objects.store.product_variation import Product_Variation, Product_Variation_Filters, Product_Variation_List
+from helpers.helper_db_mysql import Helper_DB_MySQL
+# from models.model_view_store_checkout import Model_View_Store_Checkout # circular!
+from extensions import db
+# external
+# from abc import ABC, abstractmethod, abstractproperty
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import text
+import stripe
+import os
+from flask import Flask, session, current_app
+from pydantic import BaseModel, ConfigDict
+from typing import ClassVar
+from datetime import datetime
+
+
+class DataStore_Base(BaseModel):
+    # Global constants
+    # Attributes
+    app: Flask = None
+    db: SQLAlchemy = None
+    session: object = None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # Constructor
+        self.db = db
+        self.app = current_app    
+        with self.app.app_context():
+            self.session = session
+
+    def db_procedure_execute(self, proc_name, argument_dict_list = None):
+        # Argument validation
+        _m = 'DataStore_Base.db_procedure_execute'
+        av.val_str(proc_name, 'proc_name', _m)
+        has_arguments = not str(type(argument_dict_list)) == "<class 'NoneType'>"
+        if has_arguments:
+            # av.val_list_instances(argument_dict_list, 'argument_dict_list', _m, dict)
+            pass
+        # Methods
+        proc_string = f'CALL {proc_name}('
+        if has_arguments:
+            arg_keys = list(argument_dict_list.keys())
+            for i in range(len(arg_keys)):
+                proc_string += f'{"" if i == 0 else ", "}:{arg_keys[i]}'
+        proc_string += ')'
+        proc_string = text(proc_string)
+        print(f'{_m}\nproc_string: {proc_string}\nargs: {argument_dict_list}')
+
+        # with self.db.session.begin() as session:
+        # conn = Helper_DB_MySQL(self.app).get_db_connection()
+
+        if has_arguments:
+            result = self.db.session.execute(proc_string, argument_dict_list)
+        else:
+            result = self.db.session.execute(proc_string)
+        print(f'result: {result}')
+        # conn.session.remove()
+        return result
+        cursor = result.cursor
+        result_set_1 = cursor.fetchall()
+        print(f'categories: {result_set_1}')
+        cursor.nextset()
+        result_set_2 = cursor.fetchall()
+        print(f'products: {result_set_2}')
+    
+    def db_cursor_clear(cursor):
+        while cursor.nextset():
+            print(f'new result set: {cursor.fetchall()}')
+
+    def get_regions_and_currencies(self):
+        _m  = 'DataStore_Base.get_regions_and_currencies'
+        _m_db_currency = 'p_shop_get_many_currency'
+        _m_db_region = 'p_shop_get_many_region'
+
+        argument_dict_list_currency = {
+            'a_get_inactive_currency': 0
+        }
+        argument_dict_list_region = {
+            'a_get_inactive_currency': 0
+        }
+
+        print(f'executing {_m_db_currency}')
+        result = self.db_procedure_execute(_m_db_currency, argument_dict_list_currency)
+        cursor = result.cursor
+        print('data received')
+
+        # cursor.nextset()
+        result_set_1 = cursor.fetchall()
+        currencies = []
+        for row in result_set_1:
+            currency = Currency.from_DB_currency(row)
+            currencies.append(currency)
+        print(f'currencies: {currencies}')
+        DataStore_Base.db_cursor_clear(cursor)
+
+        print(f'executing {_m_db_region}')
+        result = self.db_procedure_execute(_m_db_region, argument_dict_list_region)
+        cursor = result.cursor
+        print('data received')
+
+        # cursor.nextset()
+        result_set_1 = cursor.fetchall()
+        regions = []
+        for row in result_set_1:
+            region = Delivery_Region.from_DB_region(row)
+            regions.append(region)
+        print(f'regions: {regions}')
+        DataStore_Base.db_cursor_clear(cursor)
+
+        return regions, currencies
+    
+    def get_user_session(self):
+        return User.from_json(self.session.get(User.KEY_USER))
+        user = User.get_default()
+        try:
+            print(f'user session: {session[self.app.ID_TOKEN_USER]}')
+            info_user = session[self.app.ID_TOKEN_USER].get('userinfo')
+            print(f'info_user: {info_user}')
+            user.is_logged_in = ('sub' in list(info_user.keys()) and not info_user['sub'] == '' and not str(type(info_user['sub'])) == "<class 'NoneType'?")
+            user.id_user_auth0 = info_user['sub'] if user.is_logged_in else None
+            print(f'user.id_user_auth0: {user.id_user_auth0}')
+        except:
+            print('get user login failed')
+        return user
+    
+    def get_user_auth0(self):
+        return User.from_json_auth0(self.session.get(self.app.config['ID_TOKEN_USER']))
+    

datastores/datastore_store_base.py

@@ -0,0 +1,294 @@
+"""
+Project:    PARTS Website
+Author:     Edward Middleton-Smith
+            Precision And Research Technology Systems Limited
+
+Technology: DataStores
+Feature:    Base Store DataStore
+
+Description:
+Datastore for Store
+"""
+
+# internal
+# from routes import bp_home
+import lib.argument_validation as av
+from business_objects.store.basket import Basket, Basket_Item
+from business_objects.store.product_category import Container_Product_Category, Product_Category
+from business_objects.store.currency import Currency
+from business_objects.store.image import Image
+from business_objects.store.delivery_option import Delivery_Option
+from business_objects.store.delivery_region import Delivery_Region
+from business_objects.store.discount import Discount
+from business_objects.store.order import Order
+from business_objects.store.product import Product, Product_Permutation, Product_Price, Product_Filters 
+from business_objects.sql_error import SQL_Error
+from business_objects.store.stock_item import Stock_Item, Stock_Item_Filters
+from business_objects.user import User, User_Filters, User_Permission_Evaluation
+from business_objects.store.product_variation import Product_Variation, Product_Variation_Filters, Product_Variation_List
+from datastores.datastore_base import DataStore_Base
+from helpers.helper_db_mysql import Helper_DB_MySQL
+# from models.model_view_store_checkout import Model_View_Store_Checkout # circular!
+from extensions import db
+# external
+# from abc import ABC, abstractmethod, abstractproperty
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import text
+import stripe
+import os
+from flask import Flask, session, current_app
+from pydantic import BaseModel, ConfigDict
+from typing import ClassVar
+from datetime import datetime
+
+
+class DataStore_Store_Base(DataStore_Base):
+    # Global constants
+    KEY_BASKET: ClassVar[str] = Basket.KEY_BASKET
+    KEY_IS_INCLUDED_VAT: ClassVar[str] = Basket.KEY_IS_INCLUDED_VAT # 'is_included_VAT'
+    KEY_ID_CURRENCY: ClassVar[str] = Basket.KEY_ID_CURRENCY # 'id_currency'
+    KEY_ID_REGION_DELIVERY: ClassVar[str] = Basket.KEY_ID_REGION_DELIVERY # 'id_region_delivery'
+    # Attributes
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def get_many_product(self, product_filters):
+        # redundant argument validation? 
+        _m = 'DataStore_Store_Base.get_many_product'
+        av.val_instance(product_filters, 'product_filters', _m, Product_Filters) 
+        argument_dict = product_filters.to_json()
+        user = self.get_user_session()
+        argument_dict['a_id_user'] = 1 # 'auth0|6582b95c895d09a70ba10fef' # id_user
+        print(f'argument_dict: {argument_dict}')
+        print('executing p_shop_get_many_product')
+        result = self.db_procedure_execute('p_shop_get_many_product', argument_dict)
+        cursor = result.cursor
+        print('data received')
+        
+        
+        category_list = Container_Product_Category()
+        # Categories
+        result_set_1 = cursor.fetchall()
+        print(f'raw categories: {result_set_1}')
+        # categories = [Product_Category(row[0], row[1], row[2], row[3]) for row in result_set_1]
+        # categories = []
+        # category_index = {}
+        for row in result_set_1:
+            new_category = Product_Category.from_DB_product(row) # Product_Category(row[0], row[1], row[2], row[3])
+            # category_index[new_category.id_category] = len(categories)
+            # categories.append(new_category)
+            category_list.add_category(new_category)
+        # print(f'categories: {[c.id_category for c in categories]}')
+
+        # Products
+        cursor.nextset()
+        result_set_2 = cursor.fetchall()
+        # print(f'products: {result_set_2}')
+        products = [] # [Product(**row) for row in result_set_2]
+        product_index = {}
+        for row in result_set_2:
+            new_permutation = Product_Permutation.from_DB_product(row) # (row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15], row[16], row[17], row[18], row[19])
+            index_category = category_list.get_index_category_from_id(new_permutation.id_category)
+            category = category_list.categories[index_category]
+            try:
+                index_product = category.get_index_product_from_id(new_permutation.id_product)
+                category_list.add_permutation(new_permutation)
+                # product = products[index_product]
+                # product.add_permutation(new_permutation)
+            except KeyError:
+                product_index[new_permutation.id_product] = len(products)
+                product = Product.from_DB_product(row)
+                product.add_permutation(new_permutation)
+                products.append(product)
+                # categories[category_index[new_product.id_category]].add_product(new_product)
+                category_list.add_product(product)
+            # category_list.add_permutation(new_permutation)
+        # print(f'products: {[p.id_product for p in products]}') # {products}')
+        print(f'category_list: {category_list}')
+
+        # Product_Variations
+        cursor.nextset()
+        result_set_3 = cursor.fetchall()
+        # print(f'variations: {result_set_3}')
+        # variations = [Product_Variation(**row) for row in result_set_3]
+        variations = []
+        for row in result_set_3:
+            new_variation = Product_Variation.from_DB_product(row) # (row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7])
+            variations.append(new_variation)
+            # products[product_index[new_variation.id_product]].variations.append(new_variation)
+            # index_category = category_index[new_variation.id_category]
+            # index_product = categories[index_category].index_product_from_ids_product_permutation(new_variation.id_product, new_variation.id_permutation)
+            # categories[index_category].products[index_product].variations.append(new_variation)
+            category_list.add_variation(new_variation)
+        # print(f'variations: {variations}')
+        # print(f'products: {[p.id_product for p in products]}')
+
+        # Images
+        cursor.nextset()
+        result_set_5 = cursor.fetchall()
+        # print(f'images: {result_set_4}')
+        # images = [Image(**row) for row in result_set_4]
+        images = []
+        for row in result_set_5:
+            new_image = Image.from_DB_product(row) # (row[0], row[1], row[2], row[3], row[4])
+            images.append(new_image)
+            # products[product_index[new_image.id_product]].images.append(new_image)
+            """
+            index_category = category_index[new_image.id_category]
+            index_product = categories[index_category].index_product_from_ids_product_permutation(new_image.id_product, new_image.id_permutation)
+            categories[index_category].products[index_product].images.append(new_image)
+            """
+            category_list.add_image(new_image)
+        # print(f'images: {images}')
+        # print(f'products: {[p.id_product for p in products]}')
+        
+        # Errors
+        cursor.nextset()
+        result_set_e = cursor.fetchall()
+        print(f'raw errors: {result_set_e}')
+        errors = []
+        if len(result_set_e) > 0:
+            errors = [SQL_Error.from_DB_record(row) for row in result_set_e] # (row[0], row[1])
+            for error in errors:
+                print(f"Error [{error.code}]: {error.msg}")
+        
+        category_list.get_all_variation_trees()
+        """
+        for category in category_list.categories:
+            print(f'category: {category.name}')
+            for product in category.products:
+                permutation = product.get_permutation_selected()
+                print(f'product: {product.name}\nselected permutation: {permutation}')
+        """
+        
+        if len(errors) > 0:
+            for error in errors:
+                if error.code == 'PRODUCT_AVAILABILITY':
+                    ids_permutation_unavailable = DataStore_Store_Base.get_ids_permutation_from_error_availability(error.msg)
+                    for id_permutation in ids_permutation_unavailable:
+                        index_category = category_list.get_index_category_from_id_permutation(id_permutation)
+                        category = category_list.categories[index_category]
+                        index_product = category.get_index_product_from_id_permutation(id_permutation)
+                        product = category.products[index_product]
+                        index_permutation = product.get_index_permutation_from_id(id_permutation)
+                        permutation = product.permutations[index_permutation]
+                        permutation.is_available = False
+                        if 'region' in error.msg or 'currency' in error.msg:
+                            permutation.is_unavailable_in_currency_or_region = True
+        
+        
+        DataStore_Store_Base.db_cursor_clear(cursor)
+
+        return category_list, errors # categories, category_index
+    
+    """
+    def get_many_id_price(self, product_ids):
+        _m = 'DataStore_Store_Base.get_many_id_price'
+        av.val_str(product_ids, 'product_ids', _m)
+        price_ids = []
+        for product_id in product_ids.split(','):
+            if product_id == 'prod_PB0NUOSEs06ymG':
+                price_ids.append() # get price id
+        return price_ids
+    """
+    
+    def get_ids_permutation_from_error_availability(msg_error_availability):
+        ids_permutation = []
+        index_colon = msg_error_availability.find(':', msg_error_availability.find(':'))
+        msg_error_availability = msg_error_availability[index_colon + 1:]
+        index_comma = 0
+        while index_comma > -1:
+            msg_error_availability = msg_error_availability[index_comma:]
+            index_comma = msg_error_availability.find(',')
+            ids_permutation.append(msg_error_availability[:index_comma])
+        return ids_permutation
+    
+    def get_regions_and_currencies(self):
+        _m  = 'DataStore_Store_Base.get_regions_and_currencies'
+        _m_db_currency = 'p_shop_get_many_currency'
+        _m_db_region = 'p_shop_get_many_region'
+
+        argument_dict_list_currency = {
+            'a_get_inactive_currency': 0
+        }
+        argument_dict_list_region = {
+            'a_get_inactive_currency': 0
+        }
+
+        print(f'executing {_m_db_currency}')
+        result = self.db_procedure_execute(_m_db_currency, argument_dict_list_currency)
+        cursor = result.cursor
+        print('data received')
+
+        # cursor.nextset()
+        result_set_1 = cursor.fetchall()
+        currencies = []
+        for row in result_set_1:
+            currency = Currency.from_DB_currency(row)
+            currencies.append(currency)
+        print(f'currencies: {currencies}')
+        DataStore_Store_Base.db_cursor_clear(cursor)
+
+        print(f'executing {_m_db_region}')
+        result = self.db_procedure_execute(_m_db_region, argument_dict_list_region)
+        cursor = result.cursor
+        print('data received')
+
+        # cursor.nextset()
+        result_set_1 = cursor.fetchall()
+        regions = []
+        for row in result_set_1:
+            region = Delivery_Region.from_DB_region(row)
+            regions.append(region)
+        print(f'regions: {regions}')
+        DataStore_Store_Base.db_cursor_clear(cursor)
+
+        return regions, currencies
+    
+    def get_many_product_variation(self, variation_filters):
+        _m = 'DataStore_Store_Base.get_many_product_variation'
+        print(_m)
+        av.val_instance(variation_filters, 'variation_filters', _m, Product_Variation_Filters)
+
+        guid = Helper_DB_MySQL.create_guid()
+        # now = datetime.now()
+        # user = self.get_user_session()
+        
+        """
+        argument_dict_list = {
+            'a_id_user': id_user,
+            'a_comment': comment,
+            'a_guid': guid
+        }
+        """
+        user = self.get_user_session()
+        argument_dict_list = {
+            # 'a_guid': guid
+            'a_id_user': user.id_user
+            , **variation_filters.to_json()
+        }
+        # argument_dict_list['a_guid'] = guid
+        result = self.db_procedure_execute('p_shop_get_many_product_variation', argument_dict_list)
+
+        cursor = result.cursor
+        result_set = cursor.fetchall()
+        
+        # Product_Variations
+        variations = Product_Variation_List()
+        for row in result_set:
+            new_variation = Product_Variation.from_DB_variation(row) 
+            variations.add_variation(new_variation)
+
+        errors = []
+        cursor.nextset()
+        result_set_e = cursor.fetchall()
+        print(f'raw errors: {result_set_e}')
+        if len(result_set_e) > 0:
+            errors = [SQL_Error.from_DB_record(row) for row in result_set_e] # [SQL_Error(row[0], row[1]) for row in result_set_e]
+            for error in errors:
+                print(f"Error [{error.code}]: {error.msg}")
+
+        DataStore_Store_Base.db_cursor_clear(cursor)
+
+        return variations, errors

datastores/datastore_store_basket.py

@@ -0,0 +1,151 @@
+"""
+Project:    PARTS Website
+Author:     Edward Middleton-Smith
+            Precision And Research Technology Systems Limited
+
+Technology: DataStores
+Feature:    Store Basket DataStore
+
+Description:
+Datastore for Store Baskets
+"""
+
+# internal
+# from routes import bp_home
+import lib.argument_validation as av
+from business_objects.store.basket import Basket, Basket_Item
+from business_objects.store.product_category import Container_Product_Category, Product_Category
+from business_objects.store.currency import Currency
+from business_objects.store.image import Image
+from business_objects.store.delivery_option import Delivery_Option
+from business_objects.store.delivery_region import Delivery_Region
+from business_objects.store.discount import Discount
+from business_objects.store.order import Order
+from business_objects.store.product import Product, Product_Permutation, Product_Price, Product_Filters 
+from business_objects.sql_error import SQL_Error
+from business_objects.store.stock_item import Stock_Item, Stock_Item_Filters
+from business_objects.user import User, User_Filters, User_Permission_Evaluation
+from business_objects.store.product_variation import Product_Variation, Product_Variation_Filters, Product_Variation_List
+from datastores.datastore_store_base import DataStore_Store_Base
+from helpers.helper_db_mysql import Helper_DB_MySQL
+# from models.model_view_store_checkout import Model_View_Store_Checkout # circular!
+from extensions import db
+# external
+# from abc import ABC, abstractmethod, abstractproperty
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import text
+import stripe
+import os
+from flask import Flask, session, current_app
+from pydantic import BaseModel, ConfigDict
+from typing import ClassVar
+from datetime import datetime
+
+
+class DataStore_Store_Basket(DataStore_Store_Base):
+    # Global constants
+    KEY_BASKET: ClassVar[str] = Basket.KEY_BASKET
+    # Attributes
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def get_metadata_basket(json_request):
+        try:
+            basket = json_request[DataStore_Store_Basket.KEY_BASKET]
+        except KeyError:
+            basket = {DataStore_Store_Basket.KEY_IS_INCLUDED_VAT: True, DataStore_Store_Basket.KEY_ID_CURRENCY: 1, DataStore_Store_Basket.KEY_ID_REGION_DELIVERY: 1}
+        is_included_VAT = basket[DataStore_Store_Basket.KEY_IS_INCLUDED_VAT]
+        id_currency = basket[DataStore_Store_Basket.KEY_ID_CURRENCY]
+        id_region_delivery = basket[DataStore_Store_Basket.KEY_ID_REGION_DELIVERY]
+        return id_currency, id_region_delivery, is_included_VAT
+
+    def edit_basket(self, ids_permutation_basket, quantities_permutation_basket, id_permutation_edit, quantity_permutation_edit, sum_not_edit, id_currency, id_region_delivery, is_included_VAT):
+        # redundant argument validation? 
+        _m = 'DataStore_Store_Base.edit_basket'
+        print(f'{_m}\nstarting...')
+        # av.val_instance(filters, 'filters', _m, Filters_Product_Category)
+        # av.val_str(ids_product_basket, 'ids_product_basket', _m)
+        av.val_str(ids_permutation_basket, 'ids_permutation_basket', _m)
+        # av.val_str(quantities_product_basket, 'quantities_product_basket', _m)
+        av.val_str(quantities_permutation_basket, 'quantities_permutation_basket', _m)
+        """
+        if id_product_edit == 'None':
+            id_product_edit = None
+        else:
+            print(f'id_product_edit: {id_product_edit}')
+            av.val_int(id_product_edit, 'id_product_edit', _m)
+        """
+        if id_permutation_edit == 'None' or str(type(id_permutation_edit)) =="<class 'NoneType'>":
+            id_permutation_edit = None
+        else:
+            print(f'id_permutation_edit: {id_permutation_edit}')
+            print(str(type(id_permutation_edit)))
+            av.val_int(id_permutation_edit, 'id_permutation_edit', _m)
+        if quantity_permutation_edit == 'None' or str(type(quantity_permutation_edit)) =="<class 'NoneType'>":
+            quantity_permutation_edit = None
+        else:
+            print(f'quantity_permutation_edit: {quantity_permutation_edit}')
+            av.val_int(quantity_permutation_edit, 'quantity_permutation_edit', _m)
+        if sum_not_edit == 'None':
+            sum_not_edit = None
+        else:
+            print(f'sum_not_edit: {sum_not_edit}')
+            av.val_bool(sum_not_edit, 'sum_not_edit', _m)
+
+        argument_dict_list = {
+            'a_id_user': self.info_user.get('sub'),
+            # 'a_ids_product_basket': ids_product_basket,
+            'a_ids_permutation_basket': ids_permutation_basket,
+            # 'a_quantities_product_basket': quantities_product_basket,
+            'a_quantities_permutation_basket': quantities_permutation_basket,
+            # 'a_id_product_edit': id_product_edit if id_permutation_edit is None else None,
+            'a_id_permutation_edit': id_permutation_edit,
+            'a_quantity_permutation_edit': quantity_permutation_edit,
+            'a_sum_not_edit': 1 if sum_not_edit else 0,
+            'a_id_currency': id_currency,
+            'a_id_region_purchase': id_region_delivery
+        }
+
+        result = self.db_procedure_execute('p_shop_edit_user_basket', argument_dict_list)
+        print('data received')
+
+        cursor = result.cursor
+
+        # categories, category_index = DataStore_Store_Base.input_many_product(cursor)
+        category_list, errors = DataStore_Store_Base.input_many_product(cursor)
+
+        print(f'cursor: {str(cursor)}')
+
+        # Basket
+        if not cursor.nextset():
+            raise Exception("No more query results! Cannot open basket contents")
+        result_set = cursor.fetchall()
+        print(f'raw basket: {result_set}')
+        # print(f'variations: {result_set_3}')
+        # variations = [Product_Variation(**row) for row in result_set_3]
+        basket = Basket(is_included_VAT, id_currency, id_region_delivery)
+        for row in result_set:
+            index_category = category_list.get_index_category_from_id(row[0])
+            category = category_list.categories[index_category]
+            index_product = category.get_index_product_from_id(row[1])
+            product = category.products[index_product]
+            basket_item = Basket_Item.from_product_and_quantity_and_VAT_included(product, row[7], self.app.is_included_VAT)
+            print(f'adding basket item: {row}')
+            print(f'basket item: {basket_item}')
+            basket.add_item(basket_item) # basket.append(basket_item) # Basket_Item(category.name, product, row[4]))
+            
+        print(f'basket: {basket}')
+
+        # Errors
+        cursor.nextset()
+        result_set_e = cursor.fetchall()
+        print(f'raw errors: {result_set_e}')
+        if len(result_set_e) > 0:
+            errors = [SQL_Error.from_DB_record(row) for row in result_set_e] # [SQL_Error(row[0], row[1]) for row in result_set_2]
+            for error in errors:
+                print(f"Error [{error.code}]: {error.msg}")
+        
+        DataStore_Store_Base.db_cursor_clear(cursor)
+
+        return basket

datastores/datastore_store_product_category.py

@@ -0,0 +1,75 @@
+"""
+Project:    PARTS Website
+Author:     Edward Middleton-Smith
+            Precision And Research Technology Systems Limited
+
+Technology: DataStores
+Feature:    Store Product Category DataStore
+
+Description:
+Datastore for Store Product Categories
+"""
+
+# internal
+import lib.argument_validation as av
+from business_objects.store.basket import Basket, Basket_Item
+from business_objects.store.product_category import Container_Product_Category, Product_Category
+from business_objects.store.currency import Currency
+from business_objects.store.image import Image
+from business_objects.store.delivery_option import Delivery_Option
+from business_objects.store.delivery_region import Delivery_Region
+from business_objects.store.discount import Discount
+from business_objects.store.order import Order
+from business_objects.store.product import Product, Product_Permutation, Product_Price, Product_Filters 
+from business_objects.sql_error import SQL_Error
+from business_objects.store.stock_item import Stock_Item, Stock_Item_Filters
+from business_objects.user import User, User_Filters, User_Permission_Evaluation
+from business_objects.store.product_variation import Product_Variation, Product_Variation_Filters, Product_Variation_List
+from datastores.datastore_store_base import DataStore_Store_Base
+from helpers.helper_db_mysql import Helper_DB_MySQL
+# from models.model_view_store_checkout import Model_View_Store_Checkout # circular!
+from extensions import db
+# external
+# from abc import ABC, abstractmethod, abstractproperty
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import text
+import stripe
+import os
+from flask import Flask, session, current_app
+from pydantic import BaseModel, ConfigDict
+from typing import ClassVar
+from datetime import datetime
+
+
+class DataStore_Store_Product_Category(DataStore_Store_Base):
+    def __init__(self):
+        super().__init__()
+
+    def save_categories(self, comment, categories):
+        _m = 'DataStore_Store_Product_Category.save_categories'
+        av.val_str(comment, 'comment', _m)
+        av.val_list(categories, 'categories', _m, Product_Category, 1)
+
+        guid = Helper_DB_MySQL.create_guid()
+        now = datetime.now()
+        user = self.get_user_session()
+        for permutation in permutations:
+            setattr(permutation, 'guid', guid)
+            setattr(permutation, 'created_on', now)
+            setattr(permutation, 'created_by', user.id_user)
+        
+        cursor = self.db.cursor()
+        cursor.executemany(
+            'INSERT INTO Shop_Product_Permutation_Temp (id_permutation, id_product, description, cost_local, id_currency_cost, profit_local_min, latency_manufacture, quantity_min, quantity_max, quantity_step, quantity_stock, is_subscription, id_recurrence_interval, count_recurrence_interval, id_stripe_product, active, display_order, guid) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)',
+            permutations
+        )
+        self.db.commit()
+        
+        argument_dict_list = {
+            'a_id_user': user.id_user,
+            'a_comment': comment,
+            'a_guid': guid
+        }
+        self.db_procedure_execute('p_shop_save_permutation', argument_dict_list)
+        
+        cursor.close()

datastores/datastore_store_product_permutation.py

@@ -0,0 +1,75 @@
+"""
+Project:    PARTS Website
+Author:     Edward Middleton-Smith
+            Precision And Research Technology Systems Limited
+
+Technology: DataStores
+Feature:    Store Product Permutation DataStore
+
+Description:
+Datastore for Store Product Permutations
+"""
+
+# internal
+import lib.argument_validation as av
+from business_objects.store.basket import Basket, Basket_Item
+from business_objects.store.product_category import Container_Product_Category, Product_Category
+from business_objects.store.currency import Currency
+from business_objects.store.image import Image
+from business_objects.store.delivery_option import Delivery_Option
+from business_objects.store.delivery_region import Delivery_Region
+from business_objects.store.discount import Discount
+from business_objects.store.order import Order
+from business_objects.store.product import Product, Product_Permutation, Product_Price, Product_Filters
+from business_objects.sql_error import SQL_Error
+from business_objects.store.stock_item import Stock_Item, Stock_Item_Filters
+from business_objects.user import User, User_Filters, User_Permission_Evaluation
+from business_objects.store.product_variation import Product_Variation, Product_Variation_Filters, Product_Variation_List
+from datastores.datastore_store_base import DataStore_Store_Base
+from helpers.helper_db_mysql import Helper_DB_MySQL
+# from models.model_view_store_checkout import Model_View_Store_Checkout # circular!
+from extensions import db
+# external
+# from abc import ABC, abstractmethod, abstractproperty
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import text
+import stripe
+import os
+from flask import Flask, session, current_app
+from pydantic import BaseModel, ConfigDict
+from typing import ClassVar
+from datetime import datetime
+
+
+class DataStore_Store_Product_Permutation(DataStore_Store_Base):
+    def __init__(self):
+        super().__init__()
+
+    def save_permutations(self, comment, permutations):
+        _m = 'DataStore_Store_Base.save_permutations'
+        av.val_str(comment, 'comment', _m)
+        av.val_list(permutations, 'list_permutations', _m, Product_Permutation, 1)
+
+        guid = Helper_DB_MySQL.create_guid()
+        now = datetime.now()
+        user = self.get_user_session()
+        for permutation in permutations:
+            setattr(permutation, 'guid', guid)
+            setattr(permutation, 'created_on', now)
+            setattr(permutation, 'created_by', user.id_user)
+        
+        cursor = self.db.cursor()
+        cursor.executemany(
+            'INSERT INTO Shop_Product_Permutation_Temp (id_permutation, id_product, description, cost_local, id_currency_cost, profit_local_min, latency_manufacture, quantity_min, quantity_max, quantity_step, quantity_stock, is_subscription, id_recurrence_interval, count_recurrence_interval, id_stripe_product, active, display_order, guid) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)',
+            permutations
+        )
+        self.db.commit()
+        
+        argument_dict_list = {
+            'a_id_user': user.id_user,
+            'a_comment': comment,
+            'a_guid': guid
+        }
+        self.db_procedure_execute('p_shop_save_permutation', argument_dict_list)
+        
+        cursor.close()

datastores/datastore_store_product_variation.py

@@ -0,0 +1,97 @@
+"""
+Project:    PARTS Website
+Author:     Edward Middleton-Smith
+            Precision And Research Technology Systems Limited
+
+Technology: DataStores
+Feature:    Store Product Variation DataStore
+
+Description:
+Datastore for Store Product Variations
+"""
+
+# internal
+# from routes import bp_home
+import lib.argument_validation as av
+from business_objects.store.basket import Basket, Basket_Item
+from business_objects.store.product_category import Container_Product_Category, Product_Category
+from business_objects.store.currency import Currency
+from business_objects.store.image import Image
+from business_objects.store.delivery_option import Delivery_Option
+from business_objects.store.delivery_region import Delivery_Region
+from business_objects.store.discount import Discount
+from business_objects.store.order import Order
+from business_objects.store.product import Product, Product_Permutation, Product_Price, Product_Filters 
+from business_objects.sql_error import SQL_Error
+from business_objects.store.stock_item import Stock_Item, Stock_Item_Filters
+from business_objects.user import User, User_Filters, User_Permission_Evaluation
+from business_objects.store.product_variation import Product_Variation, Product_Variation_Filters, Product_Variation_List
+from datastores.datastore_store_base import DataStore_Store_Base
+from helpers.helper_db_mysql import Helper_DB_MySQL
+# from models.model_view_store_checkout import Model_View_Store_Checkout # circular!
+from extensions import db
+# external
+# from abc import ABC, abstractmethod, abstractproperty
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import text
+import stripe
+import os
+from flask import Flask, session, current_app
+from pydantic import BaseModel, ConfigDict
+from typing import ClassVar
+from datetime import datetime
+
+
+class DataStore_Store_Product_Variation(DataStore_Store_Base):
+    # Global constants
+    # Attributes
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def get_many_product_variation(self, variation_filters):
+        _m = 'DataStore_Store_Product_Variation.get_many_product_variation'
+        print(_m)
+        av.val_instance(variation_filters, 'variation_filters', _m, Product_Variation_Filters)
+
+        guid = Helper_DB_MySQL.create_guid()
+        # now = datetime.now()
+        # user = self.get_user_session()
+        
+        """
+        argument_dict_list = {
+            'a_id_user': id_user,
+            'a_comment': comment,
+            'a_guid': guid
+        }
+        """
+        user = self.get_user_session()
+        argument_dict_list = {
+            # 'a_guid': guid
+            'a_id_user': user.id_user
+            , **variation_filters.to_json()
+        }
+        # argument_dict_list['a_guid'] = guid
+        result = self.db_procedure_execute('p_shop_get_many_product_variation', argument_dict_list)
+
+        cursor = result.cursor
+        result_set = cursor.fetchall()
+        
+        # Product_Variations
+        variations = Product_Variation_List()
+        for row in result_set:
+            new_variation = Product_Variation.from_DB_variation(row) 
+            variations.add_variation(new_variation)
+
+        errors = []
+        cursor.nextset()
+        result_set_e = cursor.fetchall()
+        print(f'raw errors: {result_set_e}')
+        if len(result_set_e) > 0:
+            errors = [SQL_Error.from_DB_record(row) for row in result_set_e] # [SQL_Error(row[0], row[1]) for row in result_set_e]
+            for error in errors:
+                print(f"Error [{error.code}]: {error.msg}")
+
+        DataStore_Store_Product_Variation.db_cursor_clear(cursor)
+
+        return variations, errors

datastores/datastore_store_stock_item.py

@@ -0,0 +1,173 @@
+"""
+Project:    PARTS Website
+Author:     Edward Middleton-Smith
+            Precision And Research Technology Systems Limited
+
+Technology: DataStores
+Feature:    Store Stock Item DataStore
+
+Description:
+Datastore for Store Stock Items
+"""
+
+# internal
+# from routes import bp_home
+import lib.argument_validation as av
+from business_objects.store.basket import Basket, Basket_Item
+from business_objects.store.product_category import Container_Product_Category, Product_Category
+from business_objects.store.currency import Currency
+from business_objects.store.image import Image
+from business_objects.store.delivery_option import Delivery_Option
+from business_objects.store.delivery_region import Delivery_Region
+from business_objects.store.discount import Discount
+from business_objects.store.order import Order
+from business_objects.store.product import Product, Product_Permutation, Product_Price, Product_Filters 
+from business_objects.sql_error import SQL_Error
+from business_objects.store.stock_item import Stock_Item, Stock_Item_Filters
+from business_objects.user import User, User_Filters, User_Permission_Evaluation
+from business_objects.store.product_variation import Product_Variation, Product_Variation_Filters, Product_Variation_List
+from datastores.datastore_store_base import DataStore_Store_Base
+from helpers.helper_db_mysql import Helper_DB_MySQL
+# from models.model_view_store_checkout import Model_View_Store_Checkout # circular!
+from extensions import db
+# external
+# from abc import ABC, abstractmethod, abstractproperty
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import text
+import stripe
+import os
+from flask import Flask, session, current_app
+from pydantic import BaseModel, ConfigDict
+from typing import ClassVar
+from datetime import datetime
+
+
+class DataStore_Store_Stock_Item(DataStore_Store_Base):
+    # Global constants
+    # Attributes
+
+    def __init__(self):
+        super().__init__()
+
+    # Stock Items
+    def get_many_stock_item(self, stock_item_filters):
+        # redundant argument validation? 
+        _m = 'DataStore_Store_Stock_Item.get_many_stock_item'
+        av.val_instance(stock_item_filters, 'stock_item_filters', _m, Stock_Item_Filters)
+        argument_dict = stock_item_filters.to_json()
+        user = self.get_user_session()
+        argument_dict['a_id_user'] = 1 # 'auth0|6582b95c895d09a70ba10fef' # id_user
+        print(f'argument_dict: {argument_dict}')
+        print('executing p_shop_get_many_stock_item')
+        result = self.db_procedure_execute('p_shop_get_many_stock_item', argument_dict)
+        cursor = result.cursor
+        print('data received')
+        # categories, category_index = DataStore_Store_Stock_Item.input_many_product(cursor)
+        category_list, errors = DataStore_Store_Stock_Item.input_many_stock_item(cursor)
+        DataStore_Store_Stock_Item.db_cursor_clear(cursor)
+
+        return category_list, errors # categories, category_index
+
+
+    def input_many_stock_item(cursor):
+        _m = 'DataStore_Store_Stock_Item.input_many_stock_item'
+        category_list = Container_Product_Category()
+        # Categories
+        result_set_1 = cursor.fetchall()
+        print(f'raw categories: {result_set_1}')
+        for row in result_set_1:
+            new_stock_item = Stock_Item.from_DB_stock_item(row)
+            # category_list.add_stock_item(new_stock_item, row)
+            try:
+                index_category = category_list.get_index_category_from_id(new_stock_item.id_category)
+                # category_list.add_stock_item(new_stock_item)
+                category = category_list.categories[index_category]
+                """
+                try:
+                    index_product = category.get_index_product_from_id(new_stock_item.id_product)
+                    product = category.products[index_product]
+                    try:
+                        index_permutation = product.get_index_permutation_from_id(new_stock_item.id_permutation)
+                        permutation = product.permutations[index_permutation]
+                        permutation.add_stock_item(new_stock_item)
+                    except KeyError:
+                        permutation = Product_Permutation.from_DB_stock_item(row)
+                        permutation.add_stock_item(new_stock_item)
+                        product.add_permutation(permutation)
+                except KeyError:
+                    product = Product.from_DB_stock_item(row)
+                    permutation = Product_Permutation.from_DB_stock_item(row)
+                    permutation.add_stock_item(new_stock_item)
+                    product.add_permutation(permutation)
+                    category_list.add_product(product)
+                """
+            except KeyError:
+                new_category = Product_Category.from_DB_stock_item(row)
+                """
+                product = Product.from_DB_stock_item(row)
+                permutation = Product_Permutation.from_DB_stock_item(row)
+                permutation.add_stock_item(new_stock_item)
+                product.add_permutation(permutation)
+                new_category.add_product(product)
+                """
+                category_list.add_category(new_category)
+            try:
+                index_product = category.get_index_product_from_id(new_stock_item.id_product)
+                product = category.products[index_product]
+            except KeyError:
+                new_product = Product.from_DB_stock_item(row)
+                category_list.add_product(new_product)
+            try:
+                index_permutation = product.get_index_permutation_from_id(new_stock_item.id_permutation)
+                permutation = product.permutations[index_permutation]
+                permutation.add_stock_item(new_stock_item)
+            except KeyError:
+                new_permutation = Product_Permutation.from_DB_stock_item(row)
+                product.add_permutation(new_permutation)
+            category_list.add_stock_item(new_stock_item)
+        
+        # Product_Variations
+        cursor.nextset()
+        result_set_3 = cursor.fetchall()
+        variations = []
+        for row in result_set_3:
+            new_variation = Product_Variation.from_DB_product(row)
+            variations.append(new_variation)
+            category_list.add_variation(new_variation)
+        
+        # Errors
+        cursor.nextset()
+        result_set_e = cursor.fetchall()
+        print(f'raw errors: {result_set_e}')
+        errors = []
+        if len(result_set_e) > 0:
+            errors = [SQL_Error.from_DB_record(row) for row in result_set_e] # (row[0], row[1])
+            for error in errors:
+                print(f"Error [{error.code}]: {error.msg}")
+        
+        category_list.get_all_variation_trees()
+        """
+        for category in category_list.categories:
+            print(f'category: {category.name}')
+            for product in category.products:
+                permutation = product.get_permutation_selected()
+                print(f'product: {product.name}\nselected permutation: {permutation}')
+        """
+        
+        if len(errors) > 0:
+            for error in errors:
+                if error.code == 'PRODUCT_AVAILABILITY':
+                    ids_permutation_unavailable = DataStore_Store_Stock_Item.get_ids_permutation_from_error_availability(error.msg)
+                    for id_permutation in ids_permutation_unavailable:
+                        index_category = category_list.get_index_category_from_id_permutation(id_permutation)
+                        category = category_list.categories[index_category]
+                        index_product = category.get_index_product_from_id_permutation(id_permutation)
+                        product = category.products[index_product]
+                        index_permutation = product.get_index_permutation_from_id(id_permutation)
+                        permutation = product.permutations[index_permutation]
+                        permutation.is_available = False
+                        if 'region' in error.msg or 'currency' in error.msg:
+                            permutation.is_unavailable_in_currency_or_region = True
+        
+        return category_list, errors # categories, category_index
+    

datastores/datastore_store_stripe.py

@@ -0,0 +1,202 @@
+"""
+Project:    PARTS Website
+Author:     Edward Middleton-Smith
+            Precision And Research Technology Systems Limited
+
+Technology: DataStores
+Feature:    Store Stripe DataStore
+
+Description:
+Datastore for Store Stripe service
+"""
+
+# internal
+# from routes import bp_home
+import lib.argument_validation as av
+from business_objects.store.basket import Basket, Basket_Item
+from business_objects.store.product_category import Container_Product_Category, Product_Category
+from business_objects.store.currency import Currency
+from business_objects.store.image import Image
+from business_objects.store.delivery_option import Delivery_Option
+from business_objects.store.delivery_region import Delivery_Region
+from business_objects.store.discount import Discount
+from business_objects.store.order import Order
+from business_objects.store.product import Product, Product_Permutation, Product_Price, Product_Filters
+from business_objects.sql_error import SQL_Error
+from business_objects.store.stock_item import Stock_Item, Stock_Item_Filters
+from business_objects.user import User, User_Filters, User_Permission_Evaluation
+from business_objects.store.product_variation import Product_Variation, Product_Variation_Filters, Product_Variation_List
+from datastores.datastore_store_base import DataStore_Store_Base
+from helpers.helper_db_mysql import Helper_DB_MySQL
+# from models.model_view_store_checkout import Model_View_Store_Checkout # circular!
+from extensions import db
+# external
+# from abc import ABC, abstractmethod, abstractproperty
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import text
+import stripe
+import os
+from flask import Flask, session, current_app
+from pydantic import BaseModel, ConfigDict
+from typing import ClassVar
+from datetime import datetime
+
+
+class DataStore_Store_Stripe(DataStore_Store_Base):
+    # Global constants
+    # Attributes
+    key_public_stripe: str = None
+    key_secret_stripe: str = None
+
+    def __init__(self):
+        super().__init__()
+        self.key_secret_stripe = os.environ.get("KEY_SECRET_STRIPE")
+        self.key_public_stripe = os.environ.get("KEY_PUBLIC_STRIPE")
+        
+        # For sample support and debugging, not required for production:
+        stripe.set_app_info(
+            'stripe-samples/checkout-one-time-payments',
+            version='0.0.1',
+            url='https://github.com/stripe-samples/checkout-one-time-payments')
+        stripe.api_key = self.key_secret_stripe
+
+    def get_many_stripe_product_new(self):
+        _m  = 'DataStore_Store_Stripe.get_many_stripe_product_new'
+        _m_db = 'p_shop_get_many_stripe_product_new'
+        # av.val_str(id_user)
+        # validation conducted by server
+
+        argument_dict_list = {
+            'a_id_user': self.info_user
+        }
+
+        print(f'executing {_m_db}')
+        result = self.db_procedure_execute(_m_db, argument_dict_list)
+        cursor = result.cursor
+        print('data received')
+
+        
+        # Products
+        cursor.nextset()
+        result_set_1 = cursor.fetchall()
+        products = []
+        for row in result_set_1:
+            new_product = Product.from_DB_Stripe_product(row) # Product(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15], row[16], row[17], row[18], row[19])
+            products.append(new_product)
+        print(f'products: {products}')        
+        
+        # Errors
+        cursor.nextset()
+        result_set_e = cursor.fetchall()
+        print(f'raw errors: {result_set_e}')
+        if len(result_set_e) > 0:
+            errors = [SQL_Error.from_DB_record(row) for row in result_set_e] # [SQL_Error(row[0], row[1]) for row in result_set_e]
+            for error in errors:
+                print(f"Error [{error.code}]: {error.msg}")
+
+        DataStore_Store_Stripe.db_cursor_clear(cursor)
+
+        return products
+    
+    def get_many_stripe_price_new(self):
+        _m  = 'DataStore_Store_Stripe.get_many_stripe_price_new'
+        _m_db = 'p_shop_get_many_stripe_price_new'
+        # av.val_str(id_user)
+        # validation conducted by server
+
+        argument_dict_list = {
+            'a_id_user': self.info_user
+        }
+
+        print(f'executing {_m_db}')
+        result = self.db_procedure_execute(_m_db, argument_dict_list)
+        cursor = result.cursor
+        print('data received')
+
+        
+        # Products
+        cursor.nextset()
+        result_set_1 = cursor.fetchall()
+        products = []
+        for row in result_set_1:
+            new_product = Product.from_DB_Stripe_price(row) # Product(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15], row[16], row[17], row[18], row[19])
+            products.append(new_product)
+        print(f'products: {products}')        
+        
+        # Errors
+        cursor.nextset()
+        result_set_e = cursor.fetchall()
+        print(f'raw errors: {result_set_e}')
+        if len(result_set_e) > 0:
+            errors = [SQL_Error.from_DB_record(row) for row in result_set_e] # [SQL_Error(row[0], row[1]) for row in result_set_e]
+            for error in errors:
+                print(f"Error [{error.code}]: {error.msg}")
+
+        DataStore_Store_Stripe.db_cursor_clear(cursor)
+
+        return products
+    
+    def get_many_product_new(self):
+        _m  = 'DataStore_Store_Stripe.get_many_product_new'
+        # Stripe
+        new_products = self.get_many_stripe_product_new()
+        for product in new_products:
+            product.id_stripe_product = self.create_stripe_product(product)
+        return new_products
+    
+    def get_many_price_new(self):
+        _m  = 'DataStore_Store_Stripe.get_many_product_new'
+        # Stripe
+        new_products = self.get_many_stripe_price_new()
+        for product in new_products:
+            product.id_stripe_price = self.create_stripe_price(product)
+        return new_products
+
+    # Stripe
+    def create_stripe_product(self, product): # _name, product_description):
+        _m  = 'DataStore_Store_Stripe_Checkout.create_stripe_product'
+        # av.val_str(product_name, 'product_name', _m)
+        # av.val_str(product_description, 'product_description', _m)
+        av.val_instance(product, 'product', _m, Product)
+
+        print(f'stripe.api_key = {stripe.api_key}')
+        new_product = stripe.Product.create(
+            name = product.name,
+            description = product.description,
+        )
+
+        # Save these identifiers
+        print(f"Success! Here is your new Stripe product id: {new_product.id}")
+
+        return new_product.id
+    
+    def create_stripe_price(self, product, currency): # product_id, product_price, product_currency, product_is_subscription, product_recurring_interval = '', product_interval_count = 0):
+        _m  = 'DataStore_Store_Stripe_Checkout.create_stripe_price'
+        """
+        av.val_str(p_id, 'p_id', _m)
+        av.full_val_float(p_price, 'p_price', _m, 0.01)
+        p_price = round(p_price, 2)
+        av.val_str(p_currency, 'p_currency', _m)
+        av.full_val_bool(p_is_subscription, 'p_is_subscription', _m)
+        p_is_subscription = bool(p_is_subscription)
+        av.val_str(p_recurring_interval, 'p_recurring_interval', _m)
+        av.full_val_int(p_interval_count, 'p_interval_count', _m, 1 if p_is_subscription else 0)
+        p_interval_count = int(p_interval_count)
+        """
+        av.val_instance(product, 'product', _m, Product)
+        av.val_str(currency, 'currency', _m)
+
+        print(f'stripe.api_key = {stripe.api_key}')
+
+        new_product_price = stripe.Price.create(
+            unit_amount = product.unit_price,
+            currency = currency,
+            recurring = { "interval": product.name_recurring_interval, "interval_count": product.count_recurring_interval } if product.is_subscription else None,
+            product = product.id_stripe_product
+        )
+
+        # Save these identifiers
+        print(f"Success! Here is your Stripe product price id: {new_product_price.id} for {product.name}")
+
+        return new_product_price.id
+    

datastores/datastore_user.py

@@ -0,0 +1,189 @@
+"""
+Project:    PARTS Website
+Author:     Edward Middleton-Smith
+            Precision And Research Technology Systems Limited
+
+Technology: DataStores
+Feature:    User DataStore
+
+Description:
+Datastore for Users
+"""
+
+# internal
+# from routes import bp_home
+import lib.argument_validation as av
+from business_objects.store.basket import Basket, Basket_Item
+from business_objects.store.product_category import Container_Product_Category, Product_Category
+from business_objects.store.currency import Currency
+from business_objects.store.image import Image
+from business_objects.store.delivery_option import Delivery_Option
+from business_objects.store.delivery_region import Delivery_Region
+from business_objects.store.discount import Discount
+from business_objects.store.order import Order
+from business_objects.store.product import Product, Product_Permutation, Product_Price, Product_Filters 
+from business_objects.sql_error import SQL_Error
+from business_objects.store.stock_item import Stock_Item, Stock_Item_Filters
+from business_objects.user import User, User_Filters, User_Permission_Evaluation
+from business_objects.store.product_variation import Product_Variation, Product_Variation_Filters, Product_Variation_List
+from datastores.datastore_base import DataStore_Base
+from helpers.helper_db_mysql import Helper_DB_MySQL
+# from models.model_view_store_checkout import Model_View_Store_Checkout # circular!
+from extensions import db
+# external
+# from abc import ABC, abstractmethod, abstractproperty
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import text
+import stripe
+import os
+from flask import Flask, session, current_app
+from pydantic import BaseModel, ConfigDict
+from typing import ClassVar
+from datetime import datetime
+
+
+class DataStore_User(DataStore_Base):
+    # Global constants
+    # Attributes
+
+    def __init__(self):
+        super().__init__()
+
+    def edit_user(self):
+        # redundant argument validation? 
+        _m = 'DataStore_User.edit_user'
+        # av.val_instance(filters, 'filters', _m, Filters_Product_Category)
+
+        argument_dict_list = {
+            'a_id_user': self.info_user.get('sub'),
+            'a_name': self.info_user.get('name'),
+            'a_email': self.info_user.get('email'),
+            'a_email_verified': 1 if self.info_user.get('email_verified') == 'True' else 0
+        }
+
+        result = self.db_procedure_execute('p_shop_edit_user', argument_dict_list)
+        cursor = result.cursor
+        
+        result_set_1 = cursor.fetchall()
+        print(f'raw user data: {result_set_1}')
+
+        # Errors
+        cursor.nextset()
+        result_set_e = cursor.fetchall()
+        print(f'raw errors: {result_set_e}')
+        if len(result_set_e) > 0:
+            errors = [SQL_Error.from_DB_record(row) for row in result_set_e] # [SQL_Error(row[0], row[1]) for row in result_set_2]
+            for error in errors:
+                print(f"Error [{error.code}]: {error.msg}")
+
+        DataStore_User.db_cursor_clear(cursor)
+
+        return (result_set_1[0][1] == b'\x01')
+    
+    """
+    def get_many_user_order(self, id_user, ids_order, n_order_max, id_checkout_session):
+        _m  = 'DataStore_User.get_many_user_order'
+        # av.val_str(id_user)
+        # validation conducted by server
+
+        argument_dict_list = {
+            'a_id_user': id_user,
+            'a_ids_order': ids_order,
+            'a_n_order_max': n_order_max,
+            'a_id_checkout_session': id_checkout_session
+        }
+
+        print('executing p_shop_get_many_user_order')
+        result = self.db_procedure_execute('p_shop_get_many_user_order', argument_dict_list)
+        cursor = result.cursor
+        print('data received')
+
+        
+        # Discount Delivery Regions
+        cursor.nextset()
+        result_set_1 = cursor.fetchall()
+        orders = []
+        for row in result_set_1:
+            new_order = Order(row[0], row[1], row[2], row[3], row[4], row[5], row[6])
+            orders.append(new_order)
+        print(f'orders: {orders}')        
+        
+        # Errors
+        cursor.nextset()
+        result_set_e = cursor.fetchall()
+        print(f'raw errors: {result_set_e}')
+        if len(result_set_e) > 0:
+            errors = [SQL_Error.from_DB_record(row) for row in result_set_e] # [SQL_Error(row[0], row[1]) for row in result_set_e]
+            for error in errors:
+                print(f"Error [{error.code}]: {error.msg}")
+
+        DataStore_User.db_cursor_clear(cursor)
+
+        return orders
+    """
+
+    def get_many_user(self, user_filters, user=None):
+        _m = 'DataStore_User.get_many_user'
+        print(_m)
+        # av.val_str(user_filters, 'user_filters', _m)
+        # av.val_list(permutations, 'list_permutations', _m, Product_Permutation, 1)
+        av.val_instance(user_filters, 'user_filters', _m, User_Filters)
+
+        guid = Helper_DB_MySQL.create_guid()
+        # now = datetime.now()
+        # user = self.get_user_session()
+        
+        """
+        argument_dict_list = {
+            'a_id_user': id_user,
+            'a_comment': comment,
+            'a_guid': guid
+        }
+        """
+        if user is None:
+            user = self.get_user_session()
+        argument_dict_list = {
+            # 'a_guid': guid
+            'a_id_user': user.id_user
+            , 'a_id_user_auth0': user.id_user_auth0
+            , **user_filters.to_json()
+        }
+        # argument_dict_list['a_guid'] = guid
+        result = self.db_procedure_execute('p_get_many_user', argument_dict_list)
+        """
+        query = text(f"SELECT * FROM Shop_User_Eval_Temp UE_T WHERE UE_T.guid = '{guid}'")
+        result = self.db.session.execute(query)
+        """
+        cursor = result.cursor
+        result_set = cursor.fetchall()
+        print(f'raw users: {result_set}')
+        print(f'type result set: {str(type(result_set))}')
+        print(f'len result set: {len(result_set)}') 
+        """
+        user_permission_evals = []
+        for row in result_set:
+            user_permission_eval = User_Permission_Evaluation.from_DB_user_eval(row)
+            user_permission_evals.append(user_permission_eval)
+        print(f'user_permission_evals: {user_permission_evals}')
+        """
+        users = []
+        if len(result_set) > 0:
+            for row in result_set:
+                print(f'row: {row}')
+                user = User.from_DB_user(row)
+                users.append(user)
+                print(f'user {str(type(user))}: {user}')
+        print(f'type users: {str(type(users))}\n type user 0: {str(type(None if len(users) == 0 else users[0]))}')
+        # error_list, cursor = self.get_error_list_from_cursor(cursor)
+        errors = []
+        cursor.nextset()
+        result_set_e = cursor.fetchall()
+        print(f'raw errors: {result_set_e}')
+        if len(result_set_e) > 0:
+            errors = [SQL_Error.from_DB_record(row) for row in result_set_e] # [SQL_Error(row[0], row[1]) for row in result_set_e]
+            for error in errors:
+                print(f"Error [{error.code}]: {error.msg}")
+
+        DataStore_User.db_cursor_clear(cursor)
+
+        return users, errors