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

Fix: Removal of filter methods from controllers.

Browse Source
This commit is contained in:
teddy
2024-11-17 15:17:57 +00:00
parent a2af292726
commit 197f6ec5bc
44 changed files with 1317 additions and 927 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
controllers/__pycache__/user.cpython-312.pyc
View File

Binary file not shown.

32
controllers/store/manufacturing_purchase_order.py
View File

@@ -42,38 +42,6 @@ def manufacturing_purchase_orders():
return redirect(url_for('routes_core.home'))
return render_template('pages/store/_manufacturing_purchase_orders.html', model = model, datetime = datetime)
@routes_store_manufacturing_purchase_order.route(Model_View_Store_Manufacturing_Purchase_Order.HASH_GET_STORE_MANUFACTURING_PURCHASE_ORDER, methods=['POST'])
def filter_manufacturing_purchase_order():
data = Helper_App.get_request_data(request)
try:
form_filters = Filters_Manufacturing_Purchase_Order.from_json(data)
if not form_filters.validate_on_submit():
error_keys = list(form_filters.errors.keys())
try:
error_keys.remove(Manufacturing_Purchase_Order.ATTR_ID_PRODUCT_CATEGORY)
except:
pass
try:
error_keys.remove(Manufacturing_Purchase_Order.ATTR_ID_PRODUCT)
except:
pass
if error_keys:
return jsonify({
Model_View_Store_Manufacturing_Purchase_Order.FLAG_STATUS: Model_View_Store_Manufacturing_Purchase_Order.FLAG_FAILURE,
Model_View_Store_Manufacturing_Purchase_Order.FLAG_MESSAGE: f'Form invalid.\n{form_filters.errors}'
})
model = Model_View_Store_Manufacturing_Purchase_Order(form_filters_old = form_filters)
if not model.is_user_logged_in:
raise Exception('User not logged in.')
return jsonify({
Model_View_Store_Manufacturing_Purchase_Order.FLAG_STATUS: Model_View_Store_Manufacturing_Purchase_Order.FLAG_SUCCESS,
Model_View_Store_Manufacturing_Purchase_Order.FLAG_DATA: model.convert_list_objects_to_json(model.manufacturing_purchase_orders)
})
except Exception as e:
return jsonify({
Model_View_Store_Manufacturing_Purchase_Order.FLAG_STATUS: Model_View_Store_Manufacturing_Purchase_Order.FLAG_FAILURE,
Model_View_Store_Manufacturing_Purchase_Order.FLAG_MESSAGE: f'Bad data received by controller.\n{e}'
})
@routes_store_manufacturing_purchase_order.route(Model_View_Store_Manufacturing_Purchase_Order.HASH_SAVE_STORE_MANUFACTURING_PURCHASE_ORDER, methods=['POST'])
def save_manufacturing_purchase_order():

95
controllers/store/product.py
View File

@@ -28,79 +28,6 @@ from urllib.parse import quote, urlparse, parse_qs
routes_store_product = Blueprint('routes_store_product', __name__)
"""
@routes_store_product.route(Model_View_Store_Product.HASH_PAGE_STORE_PRODUCTS, methods=['GET'])
def products():
Helper_App.console_log('products')
Helper_App.console_log(f'request.args={request.args}')
user = DataStore_Store_Product.get_user_session()
filters = Parameters_Product.get_default(user.id_user)
have_changed_filters = False
arg_filter_is_not_empty = request.args.get(Model_View_Store_Product.FLAG_IS_NOT_EMPTY, None)
have_changed_filters = have_changed_filters or arg_filter_is_not_empty is None
Helper_App.console_log(f'arg_filter_is_not_empty={arg_filter_is_not_empty}')
filters.is_not_empty = filters.is_not_empty if arg_filter_is_not_empty is None else av.input_bool(arg_filter_is_not_empty, 'is_not_empty', 'filter')
arg_filter_active = request.args.get(Model_View_Store_Product.FLAG_ACTIVE, None)
have_changed_filters = have_changed_filters or arg_filter_active is None
Helper_App.console_log(f'arg_filter_active={arg_filter_active}')
filters.active = filters.active if arg_filter_active is None else av.input_bool(arg_filter_active, 'active', 'filter')
if have_changed_filters:
Helper_App.console_log('redirecting')
return redirect(url_for('routes_store_product.products', **filters.to_json()))
model = Model_View_Store_Product(filters)
return render_template('pages/store/_products.html', model = model)
@routes_store_product.route(Model_View_Store_Product.HASH_GET_STORE_PRODUCT, methods=['POST'])
def filter():
data = Helper_App.get_request_data(request)
# form_filters = None
try:
form_filters = get_Filters_Product(data)
if not form_filters.validate_on_submit():
return jsonify({Model_View_Store_Product.FLAG_STATUS: Model_View_Store_Product.FLAG_FAILURE, Model_View_Store_Product.FLAG_MESSAGE: f'Form invalid.\n{form_filters.errors}'})
# ToDo: manually validate category, product
filters_form = Parameters_Product.from_form_filters_product(form_filters)
model = Model_View_Store_Product(filters = filters_form)
return jsonify({Model_View_Store_Product.FLAG_STATUS: Model_View_Store_Product.FLAG_SUCCESS, 'Success': True, Model_View_Store_Product.FLAG_DATA: model.category_list.to_json()})
except Exception as e:
return jsonify({Model_View_Store_Product.FLAG_STATUS: Model_View_Store_Product.FLAG_FAILURE, Model_View_Store_Product.FLAG_MESSAGE: f'Bad data received by controller.\n{e}'})
def get_Filters_Product(data_request):
data_form = data_request[Model_View_Store_Product.FLAG_FORM]
form_filters = Filters_Product(**data_form)
form_filters.is_not_empty.data = av.input_bool(data_form['is_not_empty'], 'is_not_empty', 'filter')
form_filters.active.data = av.input_bool(data_form['active'], 'active', 'filter')
return form_filters
@routes_store_product.route(Model_View_Store_Product.HASH_SAVE_STORE_PRODUCT, methods=['POST'])
def save():
data = Helper_App.get_request_data(request)
# form_filters = None
Helper_App.console_log(f'data={data}')
try:
form_filters = get_Filters_Product(data)
if not form_filters.validate_on_submit():
return jsonify({Model_View_Store_Product.FLAG_STATUS: Model_View_Store_Product.FLAG_FAILURE, Model_View_Store_Product.FLAG_MESSAGE: f'Filters form invalid.\n{form_filters.errors}'})
filters_form = Parameters_Product.from_form(form_filters)
categories = data[Model_View_Store_Product.FLAG_PRODUCT]
if len(categories) == 0:
return jsonify({Model_View_Store_Product.FLAG_STATUS: Model_View_Store_Product.FLAG_FAILURE, Model_View_Store_Product.FLAG_MESSAGE: f'No categories.'})
objsCategory = []
for category in categories:
objsCategory.append(Product.from_json(category))
# model_save = Model_View_Store_Product() # filters_product=filters_form)
Helper_App.console_log(f'objsCategory={objsCategory}')
Model_View_Store_Product.save_categories(data.get('comment', 'No comment'), objsCategory)
model_return = Model_View_Store_Product(filters=filters_form)
Helper_App.console_log('nips')
return jsonify({Model_View_Store_Product.FLAG_STATUS: Model_View_Store_Product.FLAG_SUCCESS, 'Success': True, Model_View_Store_Product.FLAG_DATA: model_return.category_list.to_json()})
except Exception as e:
return jsonify({Model_View_Store_Product.FLAG_STATUS: Model_View_Store_Product.FLAG_FAILURE, Model_View_Store_Product.FLAG_MESSAGE: f'Bad data received by controller.\n{e}'})
"""
@routes_store_product.route(Model_View_Store_Product.HASH_PAGE_STORE_PRODUCTS, methods=['GET'])
def products():
Helper_App.console_log('products')
@@ -116,28 +43,6 @@ def products():
return redirect(url_for('routes_core.home'))
return render_template('pages/store/_products.html', model = model)
@routes_store_product.route(Model_View_Store_Product.HASH_GET_STORE_PRODUCT, methods=['POST'])
def filter_product():
data = Helper_App.get_request_data(request)
try:
form_filters = Filters_Product.from_json(data)
if not form_filters.validate_on_submit():
return jsonify({
Model_View_Store_Product.FLAG_STATUS: Model_View_Store_Product.FLAG_FAILURE,
Model_View_Store_Product.FLAG_MESSAGE: f'Form invalid.\n{form_filters.errors}'
})
model = Model_View_Store_Product(form_filters_old = form_filters)
if not model.is_user_logged_in:
raise Exception('User not logged in')
return jsonify({
Model_View_Store_Product.FLAG_STATUS: Model_View_Store_Product.FLAG_SUCCESS,
Model_View_Store_Product.FLAG_DATA: model.category_list.to_json()
})
except Exception as e:
return jsonify({
Model_View_Store_Product.FLAG_STATUS: Model_View_Store_Product.FLAG_FAILURE,
Model_View_Store_Product.FLAG_MESSAGE: f'Bad data received by controller.\n{e}'
})
@routes_store_product.route(Model_View_Store_Product.HASH_SAVE_STORE_PRODUCT, methods=['POST'])
def save_product():

26
controllers/store/product_category.py
View File

@@ -59,32 +59,6 @@ def categories():
return redirect(url_for('routes_core.home'))
return render_template('pages/store/_product_categories.html', model = model)
@routes_store_product_category.route(Model_View_Store_Product_Category.HASH_GET_STORE_PRODUCT_CATEGORY, methods=['POST'])
def filter_category():
data = Helper_App.get_request_data(request)
# form_filters = None
try:
form_filters = Filters_Product_Category.from_json(data)
if not form_filters.validate_on_submit():
return jsonify({
Model_View_Store_Product_Category.FLAG_STATUS: Model_View_Store_Product_Category.FLAG_FAILURE,
Model_View_Store_Product_Category.FLAG_MESSAGE: f'Form invalid.\n{form_filters.errors}'
})
# ToDo: manually validate category, product
# filters_form = Filters_Product_Category.from_form(form_filters)
model = Model_View_Store_Product_Category(form_filters_old = form_filters)
if not model.is_user_logged_in:
raise Exception('User not logged in')
return jsonify({
Model_View_Store_Product_Category.FLAG_STATUS: Model_View_Store_Product_Category.FLAG_SUCCESS,
Model_View_Store_Product_Category.FLAG_DATA: model.category_list.to_json()
})
except Exception as e:
return jsonify({
Model_View_Store_Product_Category.FLAG_STATUS: Model_View_Store_Product_Category.FLAG_FAILURE,
Model_View_Store_Product_Category.FLAG_MESSAGE: f'Bad data received by controller.\n{e}'
})
@routes_store_product_category.route(Model_View_Store_Product_Category.HASH_SAVE_STORE_PRODUCT_CATEGORY, methods=['POST'])
def save_category():
data = Helper_App.get_request_data(request)

22
controllers/store/product_permutation.py
View File

@@ -46,28 +46,6 @@ def permutations():
return redirect(url_for('routes_core.home'))
return render_template('pages/store/_product_permutations.html', model = model)
@routes_store_product_permutation.route(Model_View_Store_Product_Permutation.HASH_GET_STORE_PRODUCT_PERMUTATION, methods=['POST'])
def filter_permutation():
data = Helper_App.get_request_data(request)
try:
form_filters = Filters_Product_Permutation.from_json(data)
if not form_filters.validate_on_submit():
return jsonify({
Model_View_Store_Product_Permutation.FLAG_STATUS: Model_View_Store_Product_Permutation.FLAG_FAILURE,
Model_View_Store_Product_Permutation.FLAG_MESSAGE: f'Form invalid.\n{form_filters.errors}'
})
model = Model_View_Store_Product_Permutation(form_filters_old = form_filters)
if not model.is_user_logged_in:
raise Exception('User not logged in')
return jsonify({
Model_View_Store_Product_Permutation.FLAG_STATUS: Model_View_Store_Product_Permutation.FLAG_SUCCESS,
Model_View_Store_Product_Permutation.FLAG_DATA: model.category_list.to_json()
})
except Exception as e:
return jsonify({
Model_View_Store_Product_Permutation.FLAG_STATUS: Model_View_Store_Product_Permutation.FLAG_FAILURE,
Model_View_Store_Product_Permutation.FLAG_MESSAGE: f'Bad data received by controller.\n{e}'
})
@routes_store_product_permutation.route(Model_View_Store_Product_Permutation.HASH_SAVE_STORE_PRODUCT_PERMUTATION, methods=['POST'])
def save_permutation():

22
controllers/store/product_variation.py
View File

@@ -44,28 +44,6 @@ def product_variations():
return redirect(url_for('routes_core.home'))
return render_template('pages/store/_product_variations.html', model = model)
@routes_store_product_variation.route(Model_View_Store_Product_Variation.HASH_GET_STORE_PRODUCT_VARIATION, methods=['POST'])
def filter_product_variation():
data = Helper_App.get_request_data(request)
try:
form_filters = Filters_Product_Variation.from_json(data)
if not form_filters.validate_on_submit():
return jsonify({
Model_View_Store_Product_Variation.FLAG_STATUS: Model_View_Store_Product_Variation.FLAG_FAILURE,
Model_View_Store_Product_Variation.FLAG_MESSAGE: f'Form invalid.\n{form_filters.errors}'
})
model = Model_View_Store_Product_Variation(form_filters_old = form_filters)
if not model.is_user_logged_in:
raise Exception('User not logged in')
return jsonify({
Model_View_Store_Product_Variation.FLAG_STATUS: Model_View_Store_Product_Variation.FLAG_SUCCESS,
Model_View_Store_Product_Variation.FLAG_DATA: model.convert_list_objects_to_json(model.variation_types)
})
except Exception as e:
return jsonify({
Model_View_Store_Product_Variation.FLAG_STATUS: Model_View_Store_Product_Variation.FLAG_FAILURE,
Model_View_Store_Product_Variation.FLAG_MESSAGE: f'Bad data received by controller.\n{e}'
})
@routes_store_product_variation.route(Model_View_Store_Product_Variation.HASH_SAVE_STORE_PRODUCT_VARIATION, methods=['POST'])
def save_product_variation():

36
controllers/store/stock_item.py
View File

@@ -44,42 +44,6 @@ def stock_items():
return redirect(url_for('routes_core.home'))
return render_template('pages/store/_stock_items.html', model = model, datetime = datetime)
@routes_store_stock_item.route(Model_View_Store_Stock_Item.HASH_GET_STORE_STOCK_ITEM, methods=['POST'])
def filter_stock_item():
data = Helper_App.get_request_data(request)
try:
form_filters = Filters_Stock_Item.from_json(data)
if not form_filters.validate_on_submit():
error_keys = list(form_filters.errors.keys())
try:
error_keys.remove(Stock_Item.ATTR_ID_PRODUCT_CATEGORY)
"""
if not av.val_int(form_filters.id_product_category.data):
form_filters.errors[Stock_Item.ATTR_ID_PRODUCT_CATEGORY] = ['Invalid category.']
"""
except:
pass
try:
error_keys.remove(Stock_Item.ATTR_ID_PRODUCT)
except:
pass
if error_keys:
return jsonify({
Model_View_Store_Stock_Item.FLAG_STATUS: Model_View_Store_Stock_Item.FLAG_FAILURE,
Model_View_Store_Stock_Item.FLAG_MESSAGE: f'Form invalid.\n{form_filters.errors}'
})
model = Model_View_Store_Stock_Item(filters_stock_item = form_filters)
if not model.is_user_logged_in:
raise Exception('User not logged in.')
return jsonify({
Model_View_Store_Stock_Item.FLAG_STATUS: Model_View_Store_Stock_Item.FLAG_SUCCESS,
Model_View_Store_Stock_Item.FLAG_DATA: model.category_list.to_json()
})
except Exception as e:
return jsonify({
Model_View_Store_Stock_Item.FLAG_STATUS: Model_View_Store_Stock_Item.FLAG_FAILURE,
Model_View_Store_Stock_Item.FLAG_MESSAGE: f'Bad data received by controller.\n{e}'
})
@routes_store_stock_item.route(Model_View_Store_Stock_Item.HASH_SAVE_STORE_STOCK_ITEM, methods=['POST'])
def save_stock_item():

32
controllers/store/supplier.py
View File

@@ -42,38 +42,6 @@ def suppliers():
return redirect(url_for('routes_core.home'))
return render_template('pages/store/_suppliers.html', model = model, datetime = datetime)
@routes_store_supplier.route(Model_View_Store_Supplier.HASH_GET_STORE_SUPPLIER, methods=['POST'])
def filter_supplier():
data = Helper_App.get_request_data(request)
try:
form_filters = Filters_Supplier.from_json(data)
if not form_filters.validate_on_submit():
error_keys = list(form_filters.errors.keys())
try:
error_keys.remove(Supplier.ATTR_ID_PRODUCT_CATEGORY)
except:
pass
try:
error_keys.remove(Supplier.ATTR_ID_PRODUCT)
except:
pass
if error_keys:
return jsonify({
Model_View_Store_Supplier.FLAG_STATUS: Model_View_Store_Supplier.FLAG_FAILURE,
Model_View_Store_Supplier.FLAG_MESSAGE: f'Form invalid.\n{form_filters.errors}'
})
model = Model_View_Store_Supplier(form_filters_old = form_filters)
if not model.is_user_logged_in:
raise Exception('User not logged in.')
return jsonify({
Model_View_Store_Supplier.FLAG_STATUS: Model_View_Store_Supplier.FLAG_SUCCESS,
Model_View_Store_Supplier.FLAG_DATA: {supplier.id_supplier: supplier.to_json() for supplier in model.suppliers}
})
except Exception as e:
return jsonify({
Model_View_Store_Supplier.FLAG_STATUS: Model_View_Store_Supplier.FLAG_FAILURE,
Model_View_Store_Supplier.FLAG_MESSAGE: f'Bad data received by controller.\n{e}'
})
@routes_store_supplier.route(Model_View_Store_Supplier.HASH_SAVE_STORE_SUPPLIER, methods=['POST'])
def save_supplier():

32
controllers/store/supplier_purchase_order.py
View File

@@ -42,38 +42,6 @@ def supplier_purchase_orders():
return redirect(url_for('routes_core.home'))
return render_template('pages/store/_supplier_purchase_orders.html', model = model, datetime = datetime)
@routes_store_supplier_purchase_order.route(Model_View_Store_Supplier_Purchase_Order.HASH_GET_STORE_SUPPLIER_PURCHASE_ORDER, methods=['POST'])
def filter_supplier_purchase_order():
data = Helper_App.get_request_data(request)
try:
form_filters = Filters_Supplier_Purchase_Order.from_json(data)
if not form_filters.validate_on_submit():
error_keys = list(form_filters.errors.keys())
try:
error_keys.remove(Supplier_Purchase_Order.ATTR_ID_PRODUCT_CATEGORY)
except:
pass
try:
error_keys.remove(Supplier_Purchase_Order.ATTR_ID_PRODUCT)
except:
pass
if error_keys:
return jsonify({
Model_View_Store_Supplier_Purchase_Order.FLAG_STATUS: Model_View_Store_Supplier_Purchase_Order.FLAG_FAILURE,
Model_View_Store_Supplier_Purchase_Order.FLAG_MESSAGE: f'Form invalid.\n{form_filters.errors}'
})
model = Model_View_Store_Supplier_Purchase_Order(form_filters_old = form_filters)
if not model.is_user_logged_in:
raise Exception('User not logged in.')
return jsonify({
Model_View_Store_Supplier_Purchase_Order.FLAG_STATUS: Model_View_Store_Supplier_Purchase_Order.FLAG_SUCCESS,
Model_View_Store_Supplier_Purchase_Order.FLAG_DATA: model.convert_list_objects_to_dict_json_by_attribute_key_default(model.supplier_purchase_orders)
})
except Exception as e:
return jsonify({
Model_View_Store_Supplier_Purchase_Order.FLAG_STATUS: Model_View_Store_Supplier_Purchase_Order.FLAG_FAILURE,
Model_View_Store_Supplier_Purchase_Order.FLAG_MESSAGE: f'Bad data received by controller.\n{e}'
})
@routes_store_supplier_purchase_order.route(Model_View_Store_Supplier_Purchase_Order.HASH_SAVE_STORE_SUPPLIER_PURCHASE_ORDER, methods=['POST'])
def save_supplier_purchase_order():

19
controllers/user.py
View File

@@ -14,7 +14,7 @@ Initializes the Flask application, sets the configuration based on the environme
# internal
from models.model_view_base import Model_View_Base
from models.model_view_user import Model_View_User
from business_objects.user import User, User_Filters
from business_objects.user import User, Parameters_User
from datastores.datastore_user import DataStore_User
from helpers.helper_app import Helper_App
import lib.argument_validation as av
@@ -154,9 +154,9 @@ def login_callback():
Helper_App.console_log(f'user ID: {id_user}')
"""
user = User.from_json_auth0(token) # datastore_user.get_user_auth0()
user_filters = User_Filters.from_user(user)
filters = Parameters_User.from_user(user)
datastore_user = DataStore_User()
users, errors = datastore_user.get_many_user(user_filters, user)
users, errors = datastore_user.get_many_user(filters, user)
try:
user = users[0]
Helper_App.console_log('User logged in')
@@ -166,7 +166,7 @@ def login_callback():
session[Model_View_Base.FLAG_USER] = user_json
Helper_App.console_log(f'user stored on session')
except:
Helper_App.console_log(f'User not found: {user_filters}\nDatabase query error: {errors}')
Helper_App.console_log(f'User not found: {Parameters_User}\nDatabase query error: {errors}')
try:
hash_callback = token.get('hash_callback')
@@ -231,7 +231,16 @@ def logout_callback():
@routes_user.route("/user")
def user():
try:
model = Model_View_User(current_app, db)
model = Model_View_User()
for currency in model.currencies:
if currency.id_currency == model.user.id_currency_default:
model.user.currency_default = currency
break
for region in model.regions:
if region.id_region == model.user.id_region_default:
model.user.region_default = region
break
model.users = [model.user]
if not model.is_user_logged_in:
# return redirect(url_for('routes_user.login', data = jsonify({ Model_View_User.FLAG_CALLBACK: Model_View_User.HASH_PAGE_USER_ACCOUNT })))
return redirect(url_for('routes_core.home'))