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

feat(JavaScript): Updated architecture for TableBasePage object with static row ID attribute attached for adding ID against each row added to DOM

Browse Source
This commit is contained in:
teddy
2024-10-18 22:25:07 +01:00
parent 8fcfcf0ef4
commit 002551c0a9
112 changed files with 7280 additions and 3608 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
datastores/__pycache__/datastore_store_stock_item.cpython-312.pyc
View File

Binary file not shown.

132
datastores/datastore_store_manufacturing_purchase_order.py Normal file
View File

@@ -0,0 +1,132 @@
"""
Project: PARTS Website
Author: Edward Middleton-Smith
Precision And Research Technology Systems Limited
Technology: DataStores
Feature: Store Manufacturing Purchase Order Purchase Order DataStore
Description:
Datastore for Store Manufacturing Purchase Order Purchase Orders
"""
# internal
# from routes import bp_home
import lib.argument_validation as av
from business_objects.sql_error import SQL_Error
from business_objects.store.manufacturing_purchase_order import Manufacturing_Purchase_Order, Manufacturing_Purchase_Order_Product_Link, Parameters_Manufacturing_Purchase_Order, Manufacturing_Purchase_Order_Temp, Manufacturing_Purchase_Order_Product_Link_Temp
from datastores.datastore_store_base import DataStore_Store_Base
from helpers.helper_db_mysql import Helper_DB_MySQL
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_Manufacturing_Purchase_Order(DataStore_Store_Base):
def __init__(self):
super().__init__()
def get_many_manufacturing_purchase_order(self, parameters_manufacturing_purchase_order):
_m = 'DataStore_Store_Manufacturing_Purchase_Order.get_many_manufacturing_purchase_order'
av.val_instance(parameters_manufacturing_purchase_order, 'parameters_manufacturing_purchase_order', _m, Parameters_Manufacturing_Purchase_Order)
argument_dict = parameters_manufacturing_purchase_order.to_json()
user = self.get_user_session()
argument_dict = {
'a_id_user': user.id_user
, **argument_dict
, 'a_debug': 0
}
print(f'argument_dict: {argument_dict}')
print('executing p_shop_get_many_manufacturing_purchase_order')
result = self.db_procedure_execute('p_shop_get_many_manufacturing_purchase_order', argument_dict)
cursor = result.cursor
print('data received')
# Manufacturing_Purchase_Orders
result_set_1 = cursor.fetchall()
print(f'raw manufacturing_purchase_orders: {result_set_1}')
manufacturing_purchase_orders = []
for row in result_set_1:
new_manufacturing_purchase_order = Manufacturing_Purchase_Order.from_DB_manufacturing_purchase_order(row)
manufacturing_purchase_orders.append(new_manufacturing_purchase_order)
# Manufacturing_Purchase_Orders Items
result_set_1 = cursor.fetchall()
print(f'raw manufacturing_purchase_order_product_links: {result_set_1}')
order_product_links = []
for row in result_set_1:
new_link = Manufacturing_Purchase_Order_Product_Link.from_DB_manufacturing_purchase_order(row)
manufacturing_purchase_orders.append(new_manufacturing_purchase_order)
# 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}")
DataStore_Store_Manufacturing_Purchase_Order.db_cursor_clear(cursor)
return manufacturing_purchase_orders, errors
@classmethod
def save_manufacturing_purchase_orders(cls, comment, manufacturing_purchase_orders):
_m = 'DataStore_Store_Manufacturing_Purchase_Order.save_manufacturing_purchase_orders'
av.val_str(comment, 'comment', _m)
guid = Helper_DB_MySQL.create_guid_str()
now = datetime.now()
user = cls.get_user_session()
rows_order = []
for manufacturing_purchase_order in manufacturing_purchase_orders:
row = Manufacturing_Purchase_Order_Temp.from_manufacturing_purchase_order(manufacturing_purchase_order)
row.guid = guid
rows_order.append(row)
print(f'order rows: {rows_order}')
DataStore_Store_Base.upload_bulk(Manufacturing_Purchase_Order_Temp.__tablename__, rows_order, 1000)
print('bulk uploaded orders')
rows_link = []
for manufacturing_purchase_order in manufacturing_purchase_orders:
for link in manufacturing_purchase_order.items:
row = Manufacturing_Purchase_Order_Product_Link_Temp.from_manufacturing_purchase_order_product_link(link)
row.guid = guid
rows_link.append(row)
print(f'link rows: {rows_link}')
DataStore_Store_Base.upload_bulk(Manufacturing_Purchase_Order_Product_Link_Temp.__tablename__, rows_link, 1000)
print('bulk uploaded links')
argument_dict_list = {
'a_comment': comment,
'a_guid': guid,
'a_id_user': user.id_user,
'a_debug': 0
}
result = cls.db_procedure_execute('p_shop_save_manufacturing_purchase_order', argument_dict_list)
print('saved manufacturing purchase orders')
# Errors
cursor = result.cursor
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]
for error in errors:
print(f"Error [{error.code}]: {error.msg}")
DataStore_Store_Manufacturing_Purchase_Order.db_cursor_clear(cursor)
return errors

7
datastores/datastore_store_stock_item.py
View File

@@ -47,10 +47,6 @@ class DataStore_Store_Stock_Item(DataStore_Store_Base):
av.val_instance(parameters_stock_item, 'parameters_stock_item', _m, Parameters_Stock_Item)
argument_dict = parameters_stock_item.to_json()
user = self.get_user_session()
"""
argument_dict['a_id_user'] = user.id_user # 'auth0|6582b95c895d09a70ba10fef' # id_user
argument_dict['a_debug'] = 0
"""
argument_dict = {
'a_id_user': user.id_user
, **argument_dict
@@ -64,11 +60,10 @@ class DataStore_Store_Stock_Item(DataStore_Store_Base):
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, category_list)
DataStore_Store_Stock_Item.db_cursor_clear(cursor)
return category_list, errors # categories, category_index
return category_list, errors
def input_many_stock_item(cursor, category_list):

93
datastores/datastore_store_supplier.py
View File

@@ -4,20 +4,20 @@ Author: Edward Middleton-Smith
Precision And Research Technology Systems Limited
Technology: DataStores
Feature: Store Stock Item DataStore
Feature: Store Supplier DataStore
Description:
Datastore for Store Stock Items
Datastore for Store Suppliers
"""
# internal
# from routes import bp_home
import lib.argument_validation as av
from business_objects.sql_error import SQL_Error
from business_objects.store.supplier_address import Supplier_Address, Supplier_Address_Temp
from business_objects.store.supplier import Supplier, Parameters_Supplier, Supplier_Temp
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
@@ -30,54 +30,46 @@ from pydantic import BaseModel, ConfigDict
from typing import ClassVar
from datetime import datetime
# db = SQLAlchemy()
class DataStore_Store_Supplier(DataStore_Store_Base):
# Global constants
# Attributes
def __init__(self):
super().__init__()
# Stock Items
def get_many_supplier(self, parameters_supplier, category_list):
# redundant argument validation?
def get_many_supplier(self, parameters_supplier):
_m = 'DataStore_Store_Supplier.get_many_supplier'
av.val_instance(parameters_supplier, 'parameters_supplier', _m, Parameters_Supplier)
argument_dict = parameters_supplier.to_json()
user = self.get_user_session()
"""
argument_dict['a_id_user'] = user.id_user # 'auth0|6582b95c895d09a70ba10fef' # id_user
argument_dict['a_debug'] = 0
"""
argument_dict = {
'a_id_user': user.id_user
, **argument_dict
, 'a_debug': 0
}
ids_permutation = category_list.get_csv_ids_permutation()
print(f'ids_permutation: {ids_permutation}')
argument_dict['a_ids_product_permutation'] = ids_permutation
print(f'argument_dict: {argument_dict}')
print('executing p_shop_get_many_supplier')
result = self.db_procedure_execute('p_shop_get_many_supplier', argument_dict)
cursor = result.cursor
print('data received')
# categories, category_index = DataStore_Store_Supplier.input_many_product(cursor)
category_list, errors = DataStore_Store_Supplier.input_many_supplier(cursor, category_list)
DataStore_Store_Supplier.db_cursor_clear(cursor)
return category_list, errors # categories, category_index
def input_many_supplier(cursor, category_list):
_m = 'DataStore_Store_Supplier.input_many_supplier'
# Suppliers
result_set_1 = cursor.fetchall()
print(f'raw categories: {result_set_1}')
print(f'raw suppliers: {result_set_1}')
suppliers = []
supplier_indexes = {}
for row in result_set_1:
new_supplier = Supplier.from_DB_supplier(row)
category_list.add_supplier(new_supplier) # , row)
supplier_indexes[new_supplier.id_supplier] = len(suppliers)
suppliers.append(new_supplier)
# Supplier Addresses
cursor.nextset()
result_set_1 = cursor.fetchall()
print(f'raw supplier addresses: {result_set_1}')
for row in result_set_1:
new_address = Supplier_Address.from_DB_supplier(row)
index_supplier = supplier_indexes[new_address.id_supplier]
suppliers[index_supplier].addresses.append(new_address)
# Errors
cursor.nextset()
@@ -88,44 +80,42 @@ class DataStore_Store_Supplier(DataStore_Store_Base):
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}")
"""
if len(errors) > 0:
for error in errors:
if error.code == 'PRODUCT_AVAILABILITY':
ids_permutation_unavailable = DataStore_Store_Supplier.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_Supplier.db_cursor_clear(cursor)
return category_list, errors # categories, category_index
return suppliers, errors
@classmethod
def save_suppliers(cls, comment, suppliers):
_m = 'DataStore_Store_Supplier.save_suppliers'
print(f'{_m}\n{suppliers}')
av.val_str(comment, 'comment', _m)
guid = Helper_DB_MySQL.create_guid_str()
now = datetime.now()
user = cls.get_user_session()
rows = []
for supplier in suppliers:
# row = permutation.to_temporary_record()
row = Supplier_Temp.from_supplier(supplier)
row.guid = guid
rows.append(row)
rows.append(row)
print(f'rows: {rows}')
DataStore_Store_Base.upload_bulk(Supplier_Temp.__tablename__, rows, 1000)
print('bulk uploaded')
print('bulk uploaded suppliers')
rows = []
for supplier in suppliers:
print(f'supplier: {supplier}')
for supplier_address in supplier.addresses:
row = Supplier_Address_Temp.from_supplier_address(supplier_address)
row.guid = guid
rows.append(row)
print(f'rows: {rows}')
DataStore_Store_Base.upload_bulk(Supplier_Address_Temp.__tablename__, rows, 1000)
print('bulk uploaded supplier addresses')
argument_dict_list = {
'a_comment': comment,
@@ -134,7 +124,7 @@ class DataStore_Store_Supplier(DataStore_Store_Base):
'a_debug': 0
}
result = cls.db_procedure_execute('p_shop_save_supplier', argument_dict_list)
print('saved product permutations')
print('saved suppliers')
# Errors
cursor = result.cursor
@@ -146,5 +136,6 @@ class DataStore_Store_Supplier(DataStore_Store_Base):
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}")
DataStore_Store_Supplier.db_cursor_clear(cursor)
return errors

129
datastores/datastore_store_supplier_purchase_order.py Normal file
View File

@@ -0,0 +1,129 @@
"""
Project: PARTS Website
Author: Edward Middleton-Smith
Precision And Research Technology Systems Limited
Technology: DataStores
Feature: Store Supplier Purchase Order Purchase Order DataStore
Description:
Datastore for Store Supplier Purchase Order Purchase Orders
"""
# internal
# from routes import bp_home
import lib.argument_validation as av
from business_objects.sql_error import SQL_Error
from business_objects.store.supplier_purchase_order import Supplier_Purchase_Order, Supplier_Purchase_Order_Product_Link, Parameters_Supplier_Purchase_Order, Supplier_Purchase_Order_Temp, Supplier_Purchase_Order_Product_Link_Temp
from datastores.datastore_store_base import DataStore_Store_Base
from helpers.helper_db_mysql import Helper_DB_MySQL
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_Supplier_Purchase_Order(DataStore_Store_Base):
def __init__(self):
super().__init__()
def get_many_supplier_purchase_order(self, parameters_supplier_purchase_order):
_m = 'DataStore_Store_Supplier_Purchase_Order.get_many_supplier_purchase_order'
av.val_instance(parameters_supplier_purchase_order, 'parameters_supplier_purchase_order', _m, Parameters_Supplier_Purchase_Order)
argument_dict = parameters_supplier_purchase_order.to_json()
user = self.get_user_session()
argument_dict = {
'a_id_user': user.id_user
, **argument_dict
, 'a_debug': 0
}
print(f'argument_dict: {argument_dict}')
print('executing p_shop_get_many_supplier_purchase_order')
result = self.db_procedure_execute('p_shop_get_many_supplier_purchase_order', argument_dict)
cursor = result.cursor
print('data received')
# Supplier_Purchase_Orders
result_set_1 = cursor.fetchall()
print(f'raw supplier_purchase_orders: {result_set_1}')
supplier_purchase_orders = []
for row in result_set_1:
new_supplier_purchase_order = Supplier_Purchase_Order.from_DB_supplier_purchase_order(row)
supplier_purchase_orders.append(new_supplier_purchase_order) # , row)
# 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}")
DataStore_Store_Supplier_Purchase_Order.db_cursor_clear(cursor)
return supplier_purchase_orders, errors
@classmethod
def save_supplier_purchase_orders(cls, comment, supplier_purchase_orders):
_m = 'DataStore_Store_Supplier_Purchase_Order.save_supplier_purchase_orders'
av.val_str(comment, 'comment', _m)
guid = Helper_DB_MySQL.create_guid_str()
now = datetime.now()
user = cls.get_user_session()
rows_order = []
for supplier_purchase_order in supplier_purchase_orders:
row = Supplier_Purchase_Order_Temp.from_supplier_purchase_order(supplier_purchase_order)
row.guid = guid
rows_order.append(row)
print(f'order rows: {rows_order}')
DataStore_Store_Base.upload_bulk(Supplier_Purchase_Order_Temp.__tablename__, rows_order, 1000)
print('bulk uploaded orders')
rows_link = []
for supplier_purchase_order in supplier_purchase_orders:
for link in supplier_purchase_order.items:
row = Supplier_Purchase_Order_Product_Link_Temp.from_supplier_purchase_order_product_link(link)
row.guid = guid
rows_link.append(row)
print(f'link rows: {rows_link}')
DataStore_Store_Base.upload_bulk(Supplier_Purchase_Order_Product_Link_Temp.__tablename__, rows_link, 1000)
print('bulk uploaded links')
argument_dict_list = {
'a_comment': comment,
'a_guid': guid,
'a_id_user': user.id_user,
'a_debug': 0
}
result = cls.db_procedure_execute('p_shop_save_supplier_purchase_order', argument_dict_list)
print('saved supplier purchase orders')
# Errors
cursor = result.cursor
cursor.nextset()
result_set_e = cursor.fetchall()
print(f'raw errors: {result_set_e}')
errors = []
warnings = []
if len(result_set_e) > 0:
for row in result_set_e:
new_error = SQL_Error.from_DB_record(row)
if new_error.code == 'WARNING':
warnings.append(new_error)
else:
errors.append(new_error)
print(f"Error [{new_error.code}]: {new_error.msg}")
cls.db_cursor_clear(cursor)
return errors, warnings