admin/demo_partsERP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix: \n 1. Rename database to demo \n 2. Improve card styles for ERP Admin pages

Browse Source
This commit is contained in:
Teddy Middleton-Smith
2025-03-21 16:09:42 +00:00
parent 85a3ec4c9f
commit 5c54c23798
95 changed files with 2576 additions and 24368 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
business_objects/store/product.py
View File

@@ -16,7 +16,6 @@ from lib import data_types
from forms.forms import Form_Basket_Add, Form_Basket_Edit
from forms.store.product_permutation import Filters_Product_Permutation
from business_objects.db_base import SQLAlchemy_ABC, Get_Many_Parameters_Base
from business_objects.store.delivery_option import Delivery_Option
from business_objects.store.discount import Discount
from business_objects.store.image import Image
from business_objects.store.product_permutation import Product_Permutation
@@ -36,7 +35,6 @@ from typing import ClassVar, List
class Product(SQLAlchemy_ABC, Store_Base):
NAME_ATTR_OPTION_VALUE: ClassVar[str] = Store_Base.ATTR_ID_PRODUCT
NAME_ATTR_OPTION_TEXT = Store_Base.FLAG_NAME
# FLAG_HAS_VARIATIONS: ClassVar[str] = 'has-variations-product'
FLAG_INDEX_PERMUTATION_SELECTED: ClassVar[str] = 'index-permutation-selected'
FLAG_PRODUCT_VARIATION_TREES: ClassVar[str] = 'variation-trees'

155
business_objects/store/product_category.py
View File

@@ -17,7 +17,6 @@ from business_objects.store.product import Product, Product_Permutation, Product
# from business_objects.store.product_variation import Product_Variation
from business_objects.store.product_variation_type import Product_Variation_Type
from business_objects.store.image import Image
from business_objects.store.delivery_option import Delivery_Option
from business_objects.store.discount import Discount
from business_objects.store.stock_item import Stock_Item
from business_objects.store.store_base import Store_Base
@@ -48,11 +47,6 @@ class Product_Category(SQLAlchemy_ABC, Store_Base):
created_on = db.Column(db.DateTime)
created_by = db.Column(db.Integer)
"""
products: list = None # []
product_index: dict = None # {}
"""
def __init__(self):
self.products = []
self.product_index = {}
@@ -74,13 +68,6 @@ class Product_Category(SQLAlchemy_ABC, Store_Base):
category.can_edit = av.input_bool(query_row[9], cls.FLAG_CAN_EDIT, f'{cls.__name__}.from_DB_get_many_product_catalogue')
category.can_admin = av.input_bool(query_row[10], cls.FLAG_CAN_ADMIN, f'{cls.__name__}.from_DB_get_many_product_catalogue')
return category
"""
def key_product_index_from_ids_product_permutation(id_product, id_permutation):
return f'{id_product},{"" if id_permutation is None else id_permutation}'
def key_product_index_from_product(product):
av.val_instance(product, 'product', 'Category.key_product_index_from_product', Product)
return f'{product.id_product},{"" if product.id_permutation is None else product.id_permutation}'
"""
def get_index_product(self, product):
return self.get_index_product_from_id(product.id_product)
def get_index_product_from_id(self, id_product):
@@ -99,8 +86,6 @@ class Product_Category(SQLAlchemy_ABC, Store_Base):
def add_product(self, product):
_m = 'Category.add_product'
av.val_instance(product, 'product', _m, Product)
# self.product_index.append(len(self.products))
# self.product_index[Category.key_product_index_from_ids_product_permutation(product.id_product, product.id_permutation)] = len(self.products)
try:
self.get_index_product(product)
Helper_App.console_log(f'category: {self}')
@@ -111,17 +96,8 @@ class Product_Category(SQLAlchemy_ABC, Store_Base):
def add_product_permutation(self, permutation):
_m = 'Category.add_product_permutation'
av.val_instance(permutation, 'permutation', _m, Product_Permutation)
# self.product_index.append(len(self.products))
# self.product_index[Category.key_product_index_from_ids_product_permutation(product.id_product, product.id_permutation)] = len(self.products)
index_product = self.get_index_product_from_id(permutation.id_product)
# index_product = self.product_index[permutation.id_product]
self.products[index_product].add_product_permutation(permutation)
"""
def add_product_variation(self, variation):
av.val_instance(variation, 'variation', 'Category.add_product_variation', Product_Variation)
index_product = self.get_index_product_from_id(variation.id_product)
self.products[index_product].add_product_variation(variation)
"""
def add_product_variation_type(self, variation_type):
av.val_instance(variation_type, 'variation_type', 'Category.add_product_variation_type', Product_Variation_Type)
variation = variation_type.variations[0]
@@ -152,16 +128,6 @@ class Product_Category(SQLAlchemy_ABC, Store_Base):
if product.has_variations:
Helper_App.console_log(f'product with id:{product.id_product} has variations')
product.get_variation_trees()
"""
def index_product_from_ids_product_permutation(self, id_product, id_permutation):
key = Category.key_product_index_from_ids_product_permutation(id_product, id_permutation)
Helper_App.console_log(f'product_index: {self.product_index}')
Helper_App.console_log(f'Key Error: {key}')
try:
return self.product_index[key]
except KeyError:
pass
"""
def __repr__(self):
return f'''
id: {self.id_category[0] if isinstance(self.id_category, tuple) else self.id_category}
@@ -173,12 +139,6 @@ class Product_Category(SQLAlchemy_ABC, Store_Base):
active: {self.active}
products: {self.products}
'''
"""
def get_permutation_first(self):
if not (len(self.products) == 0):
Helper_App.console_log(f'getting first permutation from product')
return None if len(self.products) == 0 else self.products[0].get_permutation_selected()
"""
def is_available(self):
if len(self.products) == 0:
return False
@@ -227,22 +187,6 @@ class Product_Category(SQLAlchemy_ABC, Store_Base):
category.can_edit = json.get(cls.FLAG_CAN_EDIT, False)
category.can_admin = json.get(cls.FLAG_CAN_ADMIN, False)
return category
"""
def to_json_str(self):
return {
self.ATTR_ID_PRODUCT_CATEGORY: self.id_category[0] if isinstance(self.id_category, tuple) else self.id_category,
self.FLAG_CODE: self.code[0] if isinstance(self.code, tuple) else self.code,
self.FLAG_NAME: self.name[0] if isinstance(self.name, tuple) else self.name,
self.FLAG_DESCRIPTION: self.description[0] if isinstance(self.description, tuple) else self.description,
self.ATTR_ID_ACCESS_LEVEL: self.id_access_level_required[0] if isinstance(self.id_access_level_required, tuple) else self.id_access_level_required,
self.FLAG_ACCESS_LEVEL_REQUIRED: self.name_access_level_required[0] if isinstance(self.name_access_level_required, tuple) else self.name_access_level_required,
self.FLAG_DISPLAY_ORDER: self.display_order,
self.FLAG_ACTIVE: self.output_bool(self.active),
self.FLAG_CAN_VIEW: self.output_bool(self.can_view),
self.FLAG_CAN_EDIT: self.output_bool(self.can_edit),
self.FLAG_CAN_ADMIN: self.output_bool(self.can_admin)
}
"""
@staticmethod
def output_bool(value):
return av.input_bool(value, 'Product_Category bool attribute', 'Product_Category.output_bool')
@@ -256,78 +200,7 @@ class Product_Category(SQLAlchemy_ABC, Store_Base):
for product in self.products:
list_ids += product.get_csv_ids_permutation()
return list_ids
"""
class Filters_Product_Category(BaseModel, Store_Base):
ids_product_category: str
ids_product: str
""
def __new__(cls, product_ids, product_categories):
_m = 'Parameters_Product.__new__'
v_arg_type = 'class attribute'
# av.val_list_instances(product_ids, 'product_ids', _m, str, v_arg_type=v_arg_type)
# av.val_list_instances(product_categories, 'product_categories', _m, Product_Category_Enum, v_arg_type=v_arg_type)
av.val_str(product_ids, 'product_ids', _m, v_arg_type=v_arg_type)
av.val_str(product_categories, 'product_categories', _m, v_arg_type=v_arg_type)
return super(Parameters_Product_Category, cls).__new__(cls)
""
def __init__(self, ids_product, ids_product_category):
super().__init__(ids_product=ids_product, ids_product_category=ids_product_category)
""
# Constructor
self.ids = product_ids
self.categories = product_categories
""
@classmethod
def get_default(cls):
return Filters_Product_Category(
ids_product_category = '',
ids_product = ''
)
def to_json(self):
return {
**self.get_shared_json_attributes(self),
'a_ids_product_category': self.ids_product_category,
'a_ids_product': self.ids_product
}
@classmethod
def from_json(cls, json):
filters = cls()
filters.ids_product_category = json['a_ids_product_category'],
filters.ids_product = json['a_ids_product']
class Filters_Product_Category(Get_Many_Parameters_Base):
FLAG_IS_NOT_EMPTY: ClassVar[str] = 'is_not_empty'
is_not_empty: bool
active: bool
def __init__(self, is_not_empty, active):
super().__init__(is_not_empty=is_not_empty, active=active)
@classmethod
def get_default(cls):
return cls(
is_not_empty = False,
active = True
)
def to_json(self):
return {
**self.get_shared_json_attributes(self),
self.FLAG_IS_NOT_EMPTY: self.is_not_empty,
self.FLAG_ACTIVE: av.input_bool(self.active, self.FLAG_ACTIVE, f'{self.__class__.__name__}.to_json')
}
@classmethod
def from_json(cls, json):
return cls(
is_not_empty = json['is_not_empty'],
active = json['active']
)
@classmethod
def from_form(cls, form):
return cls(
is_not_empty = av.input_bool(form.is_not_empty.data, 'is_not_empty', 'Filters_Product_Category.from_form'),
active = av.input_bool(form.active.data, 'active', 'Filters_Product_Category.from_form')
)
"""
class Product_Category_Container(Store_Base):
NAME_ATTR_OPTION_TEXT: ClassVar[str] = ''
NAME_ATTR_OPTION_VALUE: ClassVar[str] = Store_Base.FLAG_ROWS
@@ -360,12 +233,6 @@ class Product_Category_Container(Store_Base):
av.val_instance(permutation, 'permutation', 'Container_Product_Categories.add_product_permutation', Product_Permutation)
index_category = self.get_index_category_from_id(permutation.id_category)
self.categories[index_category].add_product_permutation(permutation)
"""
def add_product_variation(self, variation):
av.val_instance(variation, 'variation', 'Container_Product_Categories.add_product_variation', Product_Variation)
index_category = self.get_index_category_from_id(variation.id_category)
self.categories[index_category].add_product_variation(variation)
"""
def add_product_variation_type(self, variation_type):
av.val_instance(variation_type, 'variation_type', 'Container_Product_Categories.add_product_variation_type', Product_Variation_Type)
variation = variation_type.variations[0]
@@ -396,13 +263,6 @@ class Product_Category_Container(Store_Base):
category.get_all_product_variation_trees()
def __repr__(self):
return f'categories: {self.categories}'
"""
def get_permutation_first(self):
Helper_App.console_log(f'getting first permutation from category list')
if not (len(self.categories) == 0):
Helper_App.console_log(f'getting first permutation from category')
return None if len(self.categories) == 0 else self.categories[0].get_permutation_first()
"""
def get_category_count(self):
return len(self.categories)
def to_permutation_row_list(self):
@@ -418,11 +278,6 @@ class Product_Category_Container(Store_Base):
def get_list_products(self):
list_products = []
for category in self.categories:
# list_products.append(category.to_product_option_list())
"""
for product in category.products:
list_products.append({'value': product.id_product, 'text': product.name, Product.ATTR_ID_PRODUCT_CATEGORY: product.id_category})
"""
list_products += category.products
return list_products
def to_product_option_list(self):
@@ -438,12 +293,6 @@ class Product_Category_Container(Store_Base):
**self.get_shared_json_attributes(self),
f'{self.FLAG_ROWS}': [category.to_json() for category in self.categories]
}
"""
def to_json_str(self):
return {
f'{self.FLAG_ROWS}': [category.to_json_str() for category in self.categories]
}
"""
@classmethod
def from_json(cls, json):
return None
@@ -479,7 +328,7 @@ class Product_Category_Temp(db.Model, Store_Base):
def __init__(self):
super().__init__()
self.id_temp = None
@classmethod
def from_product_category(cls, product_category):
row = cls()

123
business_objects/store/product_permutation.py
View File

@@ -15,7 +15,6 @@ import lib.argument_validation as av
from lib import data_types
from forms.forms import Form_Basket_Add, Form_Basket_Edit
from business_objects.currency import Currency
from business_objects.store.delivery_option import Delivery_Option
from business_objects.store.discount import Discount
from business_objects.store.image import Image
from business_objects.store.product_price import Product_Price
@@ -68,16 +67,7 @@ class Product_Permutation(db.Model, Store_Base):
id_product = db.Column(db.Integer)
id_category = db.Column(db.Integer)
csv_id_pairs_variation = db.Column(db.String(4000))
# name = db.Column(db.String(255))
description = db.Column(db.String(4000))
# price_GBP_full = db.Column(db.Float)
# price_GBP_min = db.Column(db.Float)
"""
id_currency_cost = db.Column(db.Integer)
code_currency_cost = db.Column(db.String(3))
symbol_currency_cost = db.Column(db.String(3))
"""
# currency_cost: Currency
cost_local_VAT_excl = db.Column(db.Float)
cost_local_VAT_incl = db.Column(db.Float)
profit_local_min = db.Column(db.Float)
@@ -109,15 +99,9 @@ class Product_Permutation(db.Model, Store_Base):
count_interval_expiration_unsealed = db.Column(db.Integer)
has_variations = db.Column(db.Boolean)
active = db.Column(db.Boolean)
# display_order = db.Column(db.Integer)
can_view = db.Column(db.Boolean)
can_edit = db.Column(db.Boolean)
can_admin = db.Column(db.Boolean)
# form_basket_add: Form_Basket_Add
# form_basket_edit: Form_Basket_Edit
# is_unavailable_in_currency_or_region: bool
# is_available: bool
# variation_tree
def __init__(self):
self.prices = []
@@ -136,9 +120,7 @@ class Product_Permutation(db.Model, Store_Base):
self.form_basket_add = Form_Basket_Add()
self.form_basket_edit = Form_Basket_Edit()
self.is_unavailable_in_currency_or_region = False
# self.is_available = False
self.variation_tree = None
# self.variations = []
@classmethod
def from_DB_get_many_product_catalogue(cls, query_row):
_m = f'{cls.__name__}.from_DB_get_many_product_catalogue'
@@ -180,7 +162,6 @@ class Product_Permutation(db.Model, Store_Base):
permutation.count_interval_expiration_unsealed = query_row[34]
permutation.has_variations = av.input_bool(query_row[35], cls.FLAG_HAS_VARIATIONS, _m, v_arg_type=v_arg_type)
permutation.active = av.input_bool(query_row[36], cls.FLAG_ACTIVE, _m, v_arg_type=v_arg_type)
# permutation.display_order = query_row[27]
permutation.can_view = av.input_bool(query_row[37], "can_view", _m, v_arg_type=v_arg_type)
permutation.can_edit = av.input_bool(query_row[38], "can_edit", _m, v_arg_type=v_arg_type)
permutation.can_admin = av.input_bool(query_row[39], "can_admin", _m, v_arg_type=v_arg_type)
@@ -191,7 +172,6 @@ class Product_Permutation(db.Model, Store_Base):
v_arg_type = 'class attribute'
permutation = Product_Permutation()
permutation.id_product = query_row[0]
# permutation.name = query_row[1]
permutation.description = query_row[2]
return permutation
@@ -200,21 +180,11 @@ class Product_Permutation(db.Model, Store_Base):
v_arg_type = 'class attribute'
permutation = Product_Permutation()
permutation.id_product = query_row[0]
# permutation.price_GBP_full = query_row[1]
permutation.id_stripe_product = query_row[2]
permutation.is_subscription = av.input_bool(query_row[3], "is_subscription", _m, v_arg_type=v_arg_type)
permutation.name_singular_unit_measurement_interval_recurrence = query_row[4]
permutation.count_interval_recurrence = query_row[5]
return permutation
"""
def from_json(json_basket_item, key_id_product, key_id_permutation):
_m = 'Product_Permutation.from_json'
v_arg_type = 'class attribute'
permutation = Product_Permutation()
permutation.id_product = json_basket_item[key_id_product]
permutation.id_permutation = json_basket_item[key_id_permutation]
return permutation
"""
@classmethod
def from_json(cls, json):
_m = f'{cls.__name__}.from_json'
@@ -257,11 +227,6 @@ class Product_Permutation(db.Model, Store_Base):
if permutation.has_variations:
permutation.csv_id_pairs_variation = json[cls.FLAG_PRODUCT_VARIATIONS]
permutation.variation_tree = Product_Variation_Tree.from_json_str(permutation.csv_id_pairs_variation)
"""
for jsonProductVariation in json[cls.FLAG_PRODUCT_VARIATIONS]:
variation = Product_Variation.from_json(jsonProductVariation)
permutation.add_product_variation(variation)
"""
return permutation
def to_json(self):
return {
@@ -327,29 +292,6 @@ class Product_Permutation(db.Model, Store_Base):
def output_delivery_date(self):
return (datetime.now() + timedelta(days=self.latency_manufacture)).strftime('%A, %d %B %Y')
"""
def output_lead_time(self):
return '1 day' if self.latency_manufacture == 1 else f'{self.latency_manufacture} days'
def output_price(self, is_included_VAT):
if self.is_unavailable_in_currency_or_region:
return 'Not available in currency and region'
if not self.is_available:
return 'Not available'
price = self.get_price()
locale.setlocale(locale.LC_ALL, '')
if is_included_VAT:
return f'{price.symbol_currency} {locale.format_string("%d", price.value_local_VAT_incl, grouping=True)}'
else:
return f'{price.symbol_currency} {locale.format_string("%d", price.value_local_VAT_excl, grouping=True)}'
def output_variations(self):
if not self.has_variations: return ''
return '\n'.join([f'{variation.name_variation_type}: {variation.name_variation}' for variation in self.variations])
def output_variations_jsonify(self):
if not self.has_variations: return ''
return ','.join([f'{variation.id_type}: {variation.id_variation}' for variation in self.variations])
"""
def __repr__(self):
return f'''Product_Permutation
id_permutation: {self.id_permutation}
@@ -394,27 +336,7 @@ class Product_Permutation(db.Model, Store_Base):
delivery_options: {self.delivery_options}
prices: {self.prices}
'''
"""
price_GBP_full: {self.price_GBP_full}
price_GBP_min: {self.price_GBP_min}
"""
"""
def add_product_variation(self, variation):
_m = 'Product_Permutation.add_product_variation'
""
av.val_instance(variation, 'variation', _m, Product_Variation)
try:
self.variation_index[variation.id_variation]
raise ValueError(f"{av.error_msg_str(variation, 'variation', _m, Product_Variation)}\nProduct_Variation already in product.")
except KeyError:
self.variation_index[variation.id_variation] = len(self.variations)
self.variations.append(variation)
""
if self.variation_tree is None:
self.variation_tree = Product_Variation_Tree.from_product_variation(variation)
else:
self.variation_tree.add_product_variation(variation)
"""
def add_product_variation_type(self, variation_type):
_m = 'Product_Permutation.add_product_variation_type'
if self.variation_tree is None:
@@ -487,23 +409,6 @@ class Product_Permutation(db.Model, Store_Base):
return a
"""
class Permutation_Product_Variation_Link(db.Model):
id_permutation = db.Column(db.Integer)
id_product = db.Column(db.Integer)
id_category = db.Column(db.Integer)
id_variation = db.Column(db.Integer)
def from_DB_get_many_product_catalogue(query_row):
_m = 'Permutation_Product_Variation_Link.from_DB_get_many_product_catalogue'
v_arg_type = 'class attribute'
link = Permutation_Product_Variation_Link()
link.id_permutation = query_row[0]
link.id_product = query_row[1]
link.id_category = query_row[2]
link.id_variation = query_row[3]
return link
"""
class Product_Permutation_Temp(db.Model, Store_Base):
__tablename__: ClassVar[str] = 'Shop_Product_Permutation_Temp'
@@ -588,30 +493,4 @@ class Product_Permutation_Temp(db.Model, Store_Base):
active: {self.active}
guid: {self.guid}
'''
"""
def to_json(self):
return {
self.ATTR_ID_PRODUCT_PERMUTATION: int(self.id_permutation),
self.ATTR_ID_PRODUCT: int(self.id_product),
self.FLAG_DESCRIPTION: self.description,
Product_Permutation.FLAG_COST_LOCAL: float(self.cost_local),
Product_Permutation.FLAG_CURRENCY_COST: int(self.id_currency_cost),
Product_Permutation.FLAG_PROFIT_LOCAL_MIN: float(self.profit_local_min),
Product_Permutation.FLAG_LATENCY_MANUFACTURE: int(self.latency_manufacture),
Product_Permutation.FLAG_UNIT_MEASUREMENT_QUANTITY: int(self.id_unit_measurement_quantity),
Product_Permutation.FLAG_COUNT_UNIT_MEASUREMENT_PER_QUANTITY_STEP: float(self.count_unit_measurement_per_quantity_step),
self.FLAG_QUANTITY_MIN: float(self.quantity_min),
self.FLAG_QUANTITY_MAX: float(self.quantity_max),
Product_Permutation.FLAG_QUANTITY_STOCK: float(self.quantity_stock),
Product_Permutation.FLAG_IS_SUBSCRIPTION: bool(self.is_subscription),
Product_Permutation.FLAG_UNIT_MEASUREMENT_INTERVAL_RECURRENCE: int(self.id_unit_measurement_interval_recurrence) if self.id_unit_measurement_interval_recurrence != '' else None,
Product_Permutation.FLAG_COUNT_UNIT_MEASUREMENT_INTERVAL_RECURRENCE: float(self.count_interval_recurrence) if self.count_interval_recurrence != '' else None,
Product_Permutation.FLAG_ID_STRIPE_PRODUCT: self.id_stripe_product,
Product_Permutation.FLAG_DOES_EXPIRE_FASTER_ONCE_UNSEALED: bool(self.does_expire_faster_once_unsealed),
Product_Permutation.FLAG_UNIT_MEASUREMENT_INTERVAL_EXPIRATION_UNSEALED: int(self.id_unit_measurement_interval_expiration_unsealed) if self.id_unit_measurement_interval_expiration_unsealed != '' else None,
Product_Permutation.FLAG_COUNT_UNIT_MEASUREMENT_INTERVAL_EXPIRATION_UNSEALED: float(self.count_interval_expiration_unsealed) if self.count_interval_expiration_unsealed != '' else None,
self.FLAG_ACTIVE: bool(self.active),
self.FLAG_GUID: self.guid
}
"""

17
business_objects/store/product_price.py
View File

@@ -27,13 +27,6 @@ class Product_Price(db.Model, Store_Base):
id_permutation = db.Column(db.Integer)
id_product = db.Column(db.Integer)
id_category = db.Column(db.Integer)
"""
id_currency = db.Column(db.Integer)
code_currency = db.Column(db.String(50))
name_currency = db.Column(db.String(255))
symbol_currency = db.Column(db.String(50))
"""
# id_region = db.Column(db.Integer)
value_local_VAT_incl = db.Column(db.Float)
value_local_VAT_excl = db.Column(db.Float)
display_order = db.Column(db.Float)
@@ -45,20 +38,12 @@ class Product_Price(db.Model, Store_Base):
self.delivery_region = None
@classmethod
def from_DB_get_many_product_catalogue(cls, query_row):
# _m = 'Product_Price.from_DB_get_many_product_catalogue'
price = cls()
price.id_price = query_row[0]
price.id_permutation = query_row[1]
price.id_product = query_row[2]
price.id_category = query_row[3]
price.currency = Currency.from_DB_get_many_product_price_and_discount_and_delivery_region(query_row)
"""
price.id_currency = query_row[4]
price.code_currency = query_row[5]
price.name_currency = query_row[6]
price.symbol_currency = query_row[7]
"""
# price.id_region = query_row[8]
price.value_local_VAT_incl = query_row[9]
price.value_local_VAT_excl = query_row[10]
price.display_order = query_row[11]
@@ -85,7 +70,6 @@ class Product_Price(db.Model, Store_Base):
self.ATTR_ID_PRODUCT: self.id_product,
self.ATTR_ID_PRODUCT_CATEGORY: self.id_category,
self.FLAG_CURRENCY: self.currency.to_json(),
# Region.ATTR_ID_REGION_DELIVERY: self.id_region,
self.FLAG_VALUE_LOCAL_VAT_INCL: self.value_local_VAT_incl,
self.FLAG_VALUE_LOCAL_VAT_EXCL: self.value_local_VAT_excl,
self.FLAG_DISPLAY_ORDER: self.display_order
@@ -99,7 +83,6 @@ class Product_Price(db.Model, Store_Base):
price.id_product = json[cls.ATTR_ID_PRODUCT]
price.id_category = json[cls.ATTR_ID_PRODUCT_CATEGORY]
price.currency = Currency.from_json(json)
# price.id_region = json[Region.ATTR_ID_REGION_DELIVERY]
price.value_local_VAT_incl = json[cls.FLAG_VALUE_LOCAL_VAT_INCL]
price.value_local_VAT_excl = json[cls.FLAG_VALUE_LOCAL_VAT_EXCL]
price.display_order = json[cls.FLAG_DISPLAY_ORDER]