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

1. PostgreSQL copy of all MySQL created and tested.\n 2. Purchase Orders and Sales Orders and stock level management added to MySQL, PostgreSQL, and server and front end code.

Browse Source
This commit is contained in:
teddy
2024-07-05 20:34:11 +01:00
parent 3a2a164213
commit 6f4e329258
3049 changed files with 535753 additions and 3022 deletions
Download Patch File Download Diff File Expand all files Collapse all files

824
static/MySQL/deprecated/000_init_tables_authentication.sql Normal file
View File

@@ -0,0 +1,824 @@
/* Store */
USE PARTSLTD_PROD;
# Drop dependencies
# DROP PROCEDURE IF EXISTS p_shop_user_eval;
DROP TABLE IF EXISTS User_Eval_Temp;
# Delete old tables
DROP TABLE IF EXISTS Shop_Address_Audit;
DROP TABLE IF EXISTS Shop_Address;
DROP TABLE IF EXISTS Shop_User_Role_Link_Audit;
DROP TABLE IF EXISTS Shop_User_Role_Link;
DROP TABLE IF EXISTS Shop_User_Audit;
DROP TABLE IF EXISTS Shop_User;
DROP TABLE IF EXISTS Shop_Role_Permission_Link_Audit;
DROP TABLE IF EXISTS Shop_Role_Permission_Link;
DROP TABLE IF EXISTS Shop_Role_Audit;
DROP TABLE IF EXISTS Shop_Role;
DROP TABLE IF EXISTS Shop_Permission_Audit;
DROP TABLE IF EXISTS Shop_Permission;
DROP TABLE IF EXISTS Shop_Permission_Group_Audit;
DROP TABLE IF EXISTS Shop_Permission_Group;
DROP TABLE IF EXISTS Shop_Access_Level_Audit;
DROP TABLE IF EXISTS Shop_Access_Level;
DROP TABLE IF EXISTS Shop_User_Change_Set;
# User Change Sets
CREATE TABLE Shop_User_Change_Set (
id_change_set INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
comment VARCHAR(500),
updated_last_on DATETIME,
updated_last_by VARCHAR(100)
);
DELIMITER //
CREATE TRIGGER before_insert_Shop_User_Change_Set
BEFORE INSERT ON Shop_User_Change_Set
FOR EACH ROW
BEGIN
IF NEW.updated_last_on <=> NULL THEN
SET NEW.updated_last_on = NOW();
END IF;
IF NEW.updated_last_by <=> NULL THEN
SET NEW.updated_last_by = CURRENT_USER();
END IF;
END //
DELIMITER ;
SELECT * FROM Shop_User_Change_Set;
# Access Levels
CREATE TABLE Shop_Access_Level (
id_access_level INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
code VARCHAR(50),
name VARCHAR(255),
priority INT NOT NULL,
active BIT NOT NULL DEFAULT 1,
display_order INT NOT NULL,
created_on DATETIME,
created_by VARCHAR(100),
id_change_set INT,
CONSTRAINT FK_Shop_Access_Level_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
);
DELIMITER //
CREATE TRIGGER before_insert_Shop_Access_Level
BEFORE INSERT ON Shop_Access_Level
FOR EACH ROW
BEGIN
IF NEW.created_on <=> NULL THEN
SET NEW.created_on = NOW();
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by = CURRENT_USER();
END IF;
END //
DELIMITER ;
CREATE TABLE Shop_Access_Level_Audit (
id_audit INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_access_level INT NOT NULL,
CONSTRAINT FK_Shop_Access_Level_Audit_id_access_level
FOREIGN KEY (id_access_level)
REFERENCES Shop_Access_Level(id_access_level)
ON UPDATE RESTRICT,
name_field VARCHAR(50),
value_prev VARCHAR(500),
value_new VARCHAR(500),
id_change_set INT NOT NULL,
CONSTRAINT FK_Shop_Access_Level_Audit_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
);
DELIMITER //
CREATE TRIGGER before_update_Shop_Access_Level
BEFORE UPDATE ON Shop_Access_Level
FOR EACH ROW
BEGIN
INSERT INTO Shop_Access_Level_Audit (
id_access_level,
name_field,
value_prev,
value_new,
id_change_set
)
# Changed code
SELECT NEW.id_access_level, 'code', OLD.code, NEW.code, NEW.id_change_set
WHERE NOT (OLD.code <=> NEW.code)
UNION
# Changed name
SELECT NEW.id_access_level, 'name', OLD.name, NEW.name, NEW.id_change_set
WHERE NOT (OLD.name <=> NEW.name)
UNION
# Changed priority
SELECT NEW.id_access_level, 'priority', CONVERT(OLD.priority, CHAR), CONVERT(NEW.priority, CHAR), NEW.id_change_set
WHERE NOT (OLD.priority <=> NEW.priority)
UNION
# Changed active
SELECT NEW.id_access_level, 'active', CONVERT(CONVERT(OLD.active, SIGNED), CHAR), CONVERT(CONVERT(NEW.active, SIGNED), CHAR), NEW.id_change_set
WHERE NOT (OLD.active <=> NEW.active)
;
END //
DELIMITER ;
INSERT INTO Shop_Access_Level (
display_order, code, name, priority
)
VALUES
(1, 'VIEW', 'View', 3),
(2, 'EDIT', 'Edit', 2),
(3, 'ADMIN', 'Admin', 1)
;
SELECT * FROM Shop_Access_Level;
SELECT * FROM Shop_Access_Level_Audit;
# Permission Groups
CREATE TABLE Shop_Permission_Group (
id_group INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
code VARCHAR(50),
name VARCHAR(255),
active BIT NOT NULL DEFAULT 1,
display_order INT NOT NULL,
created_on DATETIME,
created_by VARCHAR(100),
id_change_set INT,
CONSTRAINT FK_Shop_Permission_Group_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
ON UPDATE RESTRICT
);
DELIMITER //
CREATE TRIGGER before_insert_Shop_Permission_Group
BEFORE INSERT ON Shop_Permission_Group
FOR EACH ROW
BEGIN
IF NEW.created_on <=> NULL THEN
SET NEW.created_on = NOW();
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by = CURRENT_USER();
END IF;
END //
DELIMITER ;
CREATE TABLE Shop_Permission_Group_Audit (
id_audit INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_group INT NOT NULL,
CONSTRAINT FK_Shop_Permission_Group_Audit_id_group
FOREIGN KEY (id_group)
REFERENCES Shop_Permission_Group(id_group)
ON UPDATE RESTRICT,
name_field VARCHAR(50),
value_prev VARCHAR(500),
value_new VARCHAR(500),
id_change_set INT NOT NULL,
CONSTRAINT FK_Shop_Permission_Group_Audit_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
ON UPDATE RESTRICT
);
DELIMITER //
CREATE TRIGGER before_update_Shop_Permission_Group
BEFORE UPDATE ON Shop_Permission_Group
FOR EACH ROW
BEGIN
INSERT INTO Shop_Permission_Group_Audit (
id_group,
name_field,
value_prev,
value_new,
id_change_set
)
# Changed code
SELECT NEW.id_group, 'code', OLD.code, NEW.code, NEW.id_change_set
WHERE NOT OLD.code <=> NEW.code
UNION
# Changed name
SELECT NEW.id_group, 'name', OLD.name, NEW.name, NEW.id_change_set
WHERE NOT OLD.name <=> NEW.name
UNION
# Changed active
SELECT NEW.id_group, 'active', CONVERT(CONVERT(OLD.active, SIGNED), CHAR), CONVERT(CONVERT(NEW.active, SIGNED), CHAR), NEW.id_change_set
WHERE NOT (OLD.active <=> NEW.active)
;
END //
DELIMITER ;
INSERT INTO Shop_Permission_Group (
display_order, code, name
)
VALUES
(1, 'STORE', 'Store Home')
;
SELECT * FROM Shop_Permission_Group;
SELECT * FROM Shop_Permission_Group_Audit;
# Permissions
CREATE TABLE Shop_Permission (
id_permission INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
code VARCHAR(50),
name VARCHAR(255),
id_permission_group INT NOT NULL,
CONSTRAINT FK_Shop_Permission_id_permission_group
FOREIGN KEY (id_permission_group)
REFERENCES Shop_Permission_Group(id_group)
ON UPDATE RESTRICT,
required_access_level INT NOT NULL,
CONSTRAINT FK_Shop_Permission_id_access_level
FOREIGN KEY (required_access_level)
REFERENCES Shop_Access_Level(id_access_level),
active BIT NOT NULL DEFAULT 1,
display_order INT NOT NULL,
created_on DATETIME,
created_by VARCHAR(100),
id_change_set INT,
CONSTRAINT FK_Shop_Permission_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
);
DELIMITER //
CREATE TRIGGER before_insert_Shop_Permission
BEFORE INSERT ON Shop_Permission
FOR EACH ROW
BEGIN
IF NEW.created_on <=> NULL THEN
SET NEW.created_on = NOW();
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by = CURRENT_USER();
END IF;
END //
DELIMITER ;
CREATE TABLE Shop_Permission_Audit (
id_audit INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_permission INT NOT NULL,
CONSTRAINT FK_Shop_Permission_Audit_id_permission
FOREIGN KEY (id_permission)
REFERENCES Shop_Permission(id_permission)
ON UPDATE RESTRICT,
name_field VARCHAR(50),
value_prev VARCHAR(500),
value_new VARCHAR(500),
id_change_set INT NOT NULL,
CONSTRAINT FK_Shop_Permission_Audit_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
ON UPDATE RESTRICT
);
DELIMITER //
CREATE TRIGGER before_update_Shop_Permission
BEFORE UPDATE ON Shop_Permission
FOR EACH ROW
BEGIN
INSERT INTO Shop_Permission_Audit (
id_permission,
name_field,
value_prev,
value_new,
id_change_set
)
# Changed code
SELECT NEW.id_permission, 'code', OLD.code, NEW.code, NEW.id_change_set
WHERE NOT OLD.code <=> NEW.code
UNION
# Changed name
SELECT NEW.id_permission, 'name', OLD.name, NEW.name, NEW.id_change_set
WHERE NOT OLD.name <=> NEW.name
UNION
# Changed id_permission_group
SELECT NEW.id_permission, 'id_permission_group', CONVERT(OLD.id_permission_group, CHAR), CONVERT(NEW.id_permission_group, CHAR), NEW.id_change_set
WHERE NOT OLD.id_permission_group <=> NEW.id_permission_group
UNION
# Changed required_access_level
SELECT NEW.id_permission, 'required_access_level', CONVERT(OLD.required_access_level, CHAR), CONVERT(NEW.required_access_level, CHAR), NEW.id_change_set
WHERE NOT OLD.required_access_level <=> NEW.required_access_level
UNION
# Changed active
SELECT NEW.id_permission, 'active', CONVERT(CONVERT(OLD.active, SIGNED), CHAR), CONVERT(CONVERT(NEW.active, SIGNED), CHAR), NEW.id_change_set
WHERE NOT (OLD.active <=> NEW.active)
;
END //
DELIMITER ;
INSERT INTO Shop_Permission (
display_order, code, name, id_permission_group, required_access_level
)
VALUES
(1, 'STORE_PRODUCT', 'Store Product Page', 1, 1),
(2, 'STORE_SERVICES', 'Store Services Page', 1, 1),
(3, 'CONTACT_US', 'Contact Us Page', 1, 1)
;
SELECT * FROM Shop_Permission;
SELECT * FROM Shop_Permission_Audit;
# Roles
CREATE TABLE Shop_Role (
id_role INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
code VARCHAR(50),
name VARCHAR(255),
active BIT NOT NULL DEFAULT 1,
display_order INT NOT NULL,
created_on DATETIME,
created_by VARCHAR(100),
id_change_set INT,
CONSTRAINT FK_Shop_Role_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
);
DELIMITER //
CREATE TRIGGER before_insert_Shop_Role
BEFORE INSERT ON Shop_Role
FOR EACH ROW
BEGIN
IF NEW.created_on <=> NULL THEN
SET NEW.created_on = NOW();
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by = CURRENT_USER();
END IF;
END //
DELIMITER ;
CREATE TABLE Shop_Role_Audit (
id_audit INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_role INT NOT NULL,
CONSTRAINT FK_Shop_Role_Audit_id_role
FOREIGN KEY (id_role)
REFERENCES Shop_Role(id_role)
ON UPDATE RESTRICT,
name_field VARCHAR(50),
value_prev VARCHAR(500),
value_new VARCHAR(500),
id_change_set INT NOT NULL,
CONSTRAINT FK_Shop_Role_Audit_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
ON UPDATE RESTRICT
);
DELIMITER //
CREATE TRIGGER before_update_Shop_Role
BEFORE UPDATE ON Shop_Role
FOR EACH ROW
BEGIN
INSERT INTO Shop_Role_Audit (
id_role,
name_field,
value_prev,
value_new,
id_change_set
)
# Changed code
SELECT NEW.id_role, 'code', OLD.code, NEW.code, NEW.id_change_set
WHERE NOT OLD.code <=> NEW.code
UNION
# Changed name
SELECT NEW.id_role, 'name', OLD.name, NEW.name, NEW.id_change_set
WHERE NOT OLD.name <=> NEW.name
UNION
# Changed active
SELECT NEW.id_role, 'active', CONVERT(CONVERT(OLD.active, SIGNED), CHAR), CONVERT(CONVERT(NEW.active, SIGNED), CHAR), NEW.id_change_set
WHERE NOT (OLD.active <=> NEW.active)
;
END //
DELIMITER ;
INSERT INTO Shop_Role (
display_order,
code,
name
)
VALUES
(1, 'DIRECTOR', 'Director'),
(2, 'USER', 'User')
;
SELECT * FROM Shop_Role;
SELECT * FROM Shop_Role_Audit;
# Role Permission link
CREATE TABLE Shop_Role_Permission_Link (
id_link INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_role INT,
CONSTRAINT FK_Shop_Role_Permission_Link_id_role
FOREIGN KEY (id_role)
REFERENCES Shop_Role(id_role)
ON UPDATE RESTRICT,
id_permission INT,
CONSTRAINT FK_Shop_Role_Permission_Link_id_permission
FOREIGN KEY (id_permission)
REFERENCES Shop_Permission(id_permission)
ON UPDATE RESTRICT,
id_access_level INT,
CONSTRAINT FK_Shop_Role_Permission_Link_id_access_level
FOREIGN KEY (id_access_level)
REFERENCES Shop_Access_Level(id_access_level)
ON UPDATE RESTRICT,
active BIT NOT NULL DEFAULT 1,
created_on DATETIME,
created_by VARCHAR(100),
id_change_set INT,
CONSTRAINT FK_Shop_Role_Permission_Link_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
);
DELIMITER //
CREATE TRIGGER before_insert_Shop_Role_Permission_Link
BEFORE INSERT ON Shop_Role_Permission_Link
FOR EACH ROW
BEGIN
IF NEW.created_on <=> NULL THEN
SET NEW.created_on = NOW();
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by = CURRENT_USER();
END IF;
END //
DELIMITER ;
CREATE TABLE Shop_Role_Permission_Link_Audit (
id_audit INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_link INT NOT NULL,
CONSTRAINT FK_Shop_Role_Permission_Link_Audit_id_link
FOREIGN KEY (id_link)
REFERENCES Shop_Role_Permission_Link(id_link)
ON UPDATE RESTRICT,
name_field VARCHAR(50),
value_prev VARCHAR(500),
value_new VARCHAR(500),
id_change_set INT NOT NULL,
CONSTRAINT FK_Shop_Role_Permission_Link_Audit_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
ON UPDATE RESTRICT
);
DELIMITER //
CREATE TRIGGER before_update_Shop_Role_Permission_Link
BEFORE UPDATE ON Shop_Role_Permission_Link
FOR EACH ROW
BEGIN
INSERT INTO Shop_Role_Permission_Link_Audit (
id_link,
name_field,
value_prev,
value_new,
id_change_set
)
# Changed id_role
SELECT NEW.id_link, 'id_role', CONVERT(OLD.id_role, CHAR), CONVERT(NEW.id_role, CHAR), NEW.id_change_set
WHERE NOT OLD.id_role <=> NEW.id_role
UNION
# Changed id_permission
SELECT NEW.id_link, 'id_permission', CONVERT(OLD.id_permission, CHAR), CONVERT(NEW.id_permission, CHAR), NEW.id_change_set
WHERE NOT OLD.id_permission <=> NEW.id_permission
UNION
# Changed id_access_level
SELECT NEW.id_link, 'id_access_level', CONVERT(OLD.id_access_level, CHAR), CONVERT(NEW.id_access_level, CHAR), NEW.id_change_set
WHERE NOT OLD.id_access_level <=> NEW.id_access_level
UNION
# Changed active
SELECT NEW.id_link, 'active', CONVERT(CONVERT(OLD.active, SIGNED), CHAR), CONVERT(CONVERT(NEW.active, SIGNED), CHAR), NEW.id_change_set
WHERE NOT (OLD.active <=> NEW.active)
;
END //
DELIMITER ;
INSERT INTO Shop_Role_Permission_Link (
id_role, id_permission, id_access_level
)
VALUES
(1, 1, 3),
(1, 2, 3),
(1, 3, 3),
(2, 1, 1),
(2, 2, 1),
(2, 3, 1)
;
SELECT * FROM Shop_Role_Permission_Link;
SELECT * FROM Shop_Role_Permission_Link_Audit;
# Users
CREATE TABLE Shop_User (
id_user INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(255),
is_super_user BIT NOT NULL DEFAULT 0,
active BIT NOT NULL DEFAULT 1,
created_on DATETIME,
created_by VARCHAR(100),
id_change_set INT,
CONSTRAINT FK_Shop_User_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
);
DELIMITER //
CREATE TRIGGER before_insert_Shop_User
BEFORE INSERT ON Shop_User
FOR EACH ROW
BEGIN
IF NEW.created_on <=> NULL THEN
SET NEW.created_on = NOW();
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by = CURRENT_USER();
END IF;
END //
DELIMITER ;
CREATE TABLE Shop_User_Audit (
id_audit INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_user INT NOT NULL,
CONSTRAINT FK_Shop_User_Audit_id_user
FOREIGN KEY (id_user)
REFERENCES Shop_User(id_user)
ON UPDATE RESTRICT,
name_field VARCHAR(50),
value_prev VARCHAR(500),
value_new VARCHAR(500),
id_change_set INT NOT NULL,
CONSTRAINT FK_Shop_User_Audit_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
ON UPDATE RESTRICT
);
DELIMITER //
CREATE TRIGGER before_update_Shop_User
BEFORE UPDATE ON Shop_User
FOR EACH ROW
BEGIN
INSERT INTO Shop_User_Audit (
id_user,
name_field,
value_prev,
value_new,
id_change_set
)
# Changed name
SELECT NEW.id_user, 'name', OLD.name, NEW.name, NEW.id_change_set
WHERE NOT (OLD.name <=> NEW.name)
UNION
# Changed is_super_user
SELECT NEW.id_user, 'is_super_user', CONVERT(CONVERT(OLD.is_super_user, SIGNED), CHAR), CONVERT(CONVERT(NEW.is_super_user, SIGNED), CHAR), NEW.id_change_set
WHERE NOT (OLD.is_super_user <=> NEW.is_super_user)
UNION
# Changed active
SELECT NEW.id_user, 'active', CONVERT(CONVERT(OLD.active, SIGNED), CHAR), CONVERT(CONVERT(NEW.active, SIGNED), CHAR), NEW.id_change_set
WHERE NOT (OLD.active <=> NEW.active)
;
END //
DELIMITER ;
INSERT INTO Shop_User (
name,
is_super_user
)
VALUES (
'Teddy',
1
);
SELECT * FROM Shop_User;
SELECT * FROM Shop_User_Audit;
# User Role link
CREATE TABLE Shop_User_Role_Link (
id_link INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_user INT,
CONSTRAINT FK_Shop_User_Role_Link_id_user
FOREIGN KEY (id_user)
REFERENCES Shop_User(id_user)
ON UPDATE RESTRICT,
id_role INT,
CONSTRAINT FK_Shop_User_Role_Link_id_role
FOREIGN KEY (id_role)
REFERENCES Shop_Role(id_role)
ON UPDATE RESTRICT,
active BIT NOT NULL DEFAULT 1,
created_on DATETIME,
created_by VARCHAR(100),
id_change_set INT,
CONSTRAINT FK_Shop_User_Role_Link_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
);
DELIMITER //
CREATE TRIGGER before_insert_Shop_User_Role_Link
BEFORE INSERT ON Shop_User_Role_Link
FOR EACH ROW
BEGIN
IF NEW.created_on <=> NULL THEN
SET NEW.created_on = NOW();
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by = CURRENT_USER();
END IF;
END //
DELIMITER ;
CREATE TABLE Shop_User_Role_Link_Audit (
id_audit INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_link INT NOT NULL,
CONSTRAINT FK_Shop_User_Role_Link_Audit_id_link
FOREIGN KEY (id_link)
REFERENCES Shop_User_Role_Link(id_link)
ON UPDATE RESTRICT,
name_field VARCHAR(50),
value_prev VARCHAR(500),
value_new VARCHAR(500),
id_change_set INT NOT NULL,
CONSTRAINT FK_Shop_User_Role_Link_Audit_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
ON UPDATE RESTRICT
);
DELIMITER //
CREATE TRIGGER before_update_Shop_User_Role_Link
BEFORE UPDATE ON Shop_User_Role_Link
FOR EACH ROW
BEGIN
INSERT INTO Shop_User_Role_Link_Audit (
id_link,
name_field,
value_prev,
value_new,
id_change_set
)
# Changed active
SELECT NEW.id_link, 'active', CONVERT(CONVERT(OLD.active, SIGNED), CHAR), CONVERT(CONVERT(NEW.active, SIGNED), CHAR), NEW.id_change_set
WHERE NOT (OLD.active <=> NEW.active)
;
END //
DELIMITER ;
INSERT INTO Shop_User_Role_Link (
id_user, id_role
)
VALUES
(1, 1)
;
SELECT * FROM Shop_User_Role_Link;
SELECT * FROM Shop_User_Role_Link_Audit;
# Addresses
CREATE TABLE Shop_Address (
id_address INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_user INT NOT NULL,
CONSTRAINT FK_Shop_Address_id_user
FOREIGN KEY (id_user)
REFERENCES Shop_User(id_user)
ON UPDATE RESTRICT,
region VARCHAR(100) NOT NULL,
name_full VARCHAR(255) NOT NULL,
phone_number VARCHAR(20) NOT NULL,
postcode VARCHAR(20) NOT NULL,
address_line_1 VARCHAR(100) NOT NULL,
address_line_2 VARCHAR(100) NOT NULL,
city VARCHAR(50) NOT NULL,
county VARCHAR(100) NOT NULL,
active BIT NOT NULL DEFAULT 1,
created_on DATETIME,
created_by VARCHAR(100),
id_change_set INT,
CONSTRAINT FK_Shop_Address_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
);
DELIMITER //
CREATE TRIGGER before_insert_Shop_Address
BEFORE INSERT ON Shop_Address
FOR EACH ROW
BEGIN
IF NEW.created_on <=> NULL THEN
SET NEW.created_on = NOW();
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by = CURRENT_USER();
END IF;
END //
DELIMITER ;
CREATE TABLE Shop_Address_Audit (
id_audit INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_address INT NOT NULL,
CONSTRAINT FK_Shop_Address_Audit_id_address
FOREIGN KEY (id_address)
REFERENCES Shop_Address(id_address)
ON UPDATE RESTRICT,
name_field VARCHAR(50),
value_prev VARCHAR(500),
value_new VARCHAR(500),
id_change_set INT NOT NULL,
CONSTRAINT FK_Shop_Address_Audit_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
ON UPDATE RESTRICT
);
DELIMITER //
CREATE TRIGGER before_update_Shop_Address
BEFORE UPDATE ON Shop_Address
FOR EACH ROW
BEGIN
INSERT INTO Shop_Address_Audit (
id_address,
name_field,
value_prev,
value_new,
id_change_set
)
# Changed region
SELECT NEW.id_address, 'region', OLD.region, NEW.region, NEW.id_change_set
WHERE NOT OLD.region <=> NEW.region
UNION
# Changed name_full
SELECT NEW.id_address, 'name_full', OLD.name_full, NEW.name_full, NEW.id_change_set
WHERE NOT OLD.name_full <=> NEW.name_full
UNION
# Changed phone_number
SELECT NEW.id_address, 'phone_number', OLD.phone_number, NEW.phone_number, NEW.id_change_set
WHERE NOT OLD.phone_number <=> NEW.phone_number
UNION
# Changed postcode
SELECT NEW.id_address, 'postcode', OLD.postcode, NEW.postcode, NEW.id_change_set
WHERE NOT OLD.postcode <=> NEW.postcode
UNION
# Changed address_line_1
SELECT NEW.id_address, 'address_line_1', OLD.address_line_1, NEW.address_line_1, NEW.id_change_set
WHERE NOT OLD.address_line_1 <=> NEW.address_line_1
UNION
# Changed address_line_2
SELECT NEW.id_address, 'address_line_2', OLD.address_line_2, NEW.address_line_2, NEW.id_change_set
WHERE NOT OLD.address_line_2 <=> NEW.address_line_2
UNION
# Changed city
SELECT NEW.id_address, 'city', OLD.city, NEW.city, NEW.id_change_set
WHERE NOT OLD.city <=> NEW.city
UNION
# Changed county
SELECT NEW.id_address, 'county', OLD.county, NEW.county, NEW.id_change_set
WHERE NOT OLD.county <=> NEW.county
UNION
# Changed active
SELECT NEW.id_address, 'active', CONVERT(CONVERT(OLD.active, SIGNED), CHAR), CONVERT(CONVERT(NEW.active, SIGNED), CHAR), NEW.id_change_set
WHERE NOT (OLD.active <=> NEW.active)
;
END //
DELIMITER ;
INSERT INTO Shop_Address (
id_user, region, name_full, phone_number, postcode, address_line_1, address_line_2, city, county
)
SELECT U.id_user, 'United Kingdom', U.name, '07375 571430', 'NN6 6EB', 'The Laurels', 'Cold Ashby Road', 'Cold Ashby', 'Northamptonshire'
FROM Shop_User U;
SELECT * FROM Shop_Address;
SELECT * FROM Shop_Address_Audit;

1520
static/MySQL/deprecated/000_init_tables_product.sql Normal file
View File

File diff suppressed because it is too large Load Diff

28
static/MySQL/deprecated/113.1_tbl_Shop_Product_Variation_Type_Link.sql Normal file
View File

@@ -0,0 +1,28 @@
# Product Variation Type Link
USE PARTSLTD_PROD;
SELECT CONCAT('WARNING: Table ', TABLE_NAME, ' already exists.') AS msg_warning FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'Shop_Product_Variation_Type_Link';
CREATE TABLE IF NOT EXISTS Shop_Product_Variation_Type_Link (
id_link INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_product INT NOT NULL,
CONSTRAINT FK_Shop_Product_Variation_Type_Link_id_product
FOREIGN KEY (id_product)
REFERENCES Shop_Product(id_product)
ON UPDATE RESTRICT,
id_variation_type INT NOT NULL,
CONSTRAINT FK_Shop_Product_Variation_Type_Link_id_variation_type
FOREIGN KEY (id_variation_type)
REFERENCES Shop_Variation_Type(id_type)
ON UPDATE RESTRICT,
active BIT NOT NULL DEFAULT 1,
display_order INT NOT NULL,
created_on DATETIME,
created_by VARCHAR(100),
id_change_set INT,
CONSTRAINT FK_Shop_Product_Variation_Type_Link_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_Product_Change_Set(id_change_set)
);

23
static/MySQL/deprecated/113.2_tbl_Shop_Product_Variation_Type_Link_Audit.sql Normal file
View File

@@ -0,0 +1,23 @@
# Product Variation Type Link Audits
USE PARTSLTD_PROD;
SELECT CONCAT('WARNING: Table ', TABLE_NAME, ' already exists.') AS msg_warning FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'Shop_Product_Variation_Type_Link_Audit';
CREATE TABLE IF NOT EXISTS Shop_Product_Variation_Type_Link_Audit (
id_audit INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_link INT NOT NULL,
CONSTRAINT FK_Shop_Product_Variation_Type_Link_Audit_id_link
FOREIGN KEY (id_link)
REFERENCES Shop_Product_Variation_Type_Link(id_link)
ON UPDATE RESTRICT,
name_field VARCHAR(50),
value_prev VARCHAR(500),
value_new VARCHAR(500),
id_change_set INT NOT NULL,
CONSTRAINT FK_Shop_Product_Variation_Type_Link_Audit_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_Product_Change_Set(id_change_set)
ON UPDATE RESTRICT
);

35
static/MySQL/deprecated/116_tbl_Shop_Product_Variation_Link.sql Normal file
View File

@@ -0,0 +1,35 @@
# Product Variation Link
USE PARTSLTD_PROD;
SELECT CONCAT('WARNING: Table ', TABLE_NAME, ' already exists.') AS msg_warning FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'Shop_Product_Variation_Link';
CREATE TABLE IF NOT EXISTS Shop_Product_Variation_Link (
id_link INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_product INT NOT NULL,
CONSTRAINT FK_Shop_Product_Variation_Link_id_product
FOREIGN KEY (id_product)
REFERENCES Shop_Product(id_product)
ON UPDATE RESTRICT,
id_variation INT NOT NULL,
CONSTRAINT FK_Shop_Product_Variation_Link_id_variation
FOREIGN KEY (id_variation)
REFERENCES Shop_Variation(id_variation)
ON UPDATE RESTRICT,
/*
id_product_variation_type_link INT NOT NULL,
CONSTRAINT FK_Shop_Product_Variation_Link_id_product_variation_type_link
FOREIGN KEY (id_product_variation_type_link)
REFERENCES Shop_Product_Variation_Type_Link(id_link)
ON UPDATE RESTRICT,
*/
active BIT NOT NULL DEFAULT 1,
display_order INT NOT NULL,
created_on DATETIME,
created_by VARCHAR(100),
id_change_set INT,
CONSTRAINT FK_Shop_Product_Variation_Link_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_Product_Change_Set(id_change_set)
);

23
static/MySQL/deprecated/117.0_tbl_Shop_Product_Variation_Link_Audit.sql Normal file
View File

@@ -0,0 +1,23 @@
# Product Variation Link Audits
USE PARTSLTD_PROD;
SELECT CONCAT('WARNING: Table ', TABLE_NAME, ' already exists.') AS msg_warning FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'Shop_Product_Variation_Link_Audit';
CREATE TABLE IF NOT EXISTS Shop_Product_Variation_Link_Audit (
id_audit INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_link INT NOT NULL,
CONSTRAINT FK_Shop_Product_Variation_Link_Audit_id_link
FOREIGN KEY (id_link)
REFERENCES Shop_Product_Variation_Link(id_link)
ON UPDATE RESTRICT,
name_field VARCHAR(50),
value_prev VARCHAR(500),
value_new VARCHAR(500),
id_change_set INT NOT NULL,
CONSTRAINT FK_Shop_Product_Variation_Link_Audit_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_Product_Change_Set(id_change_set)
ON UPDATE RESTRICT
);

32
static/MySQL/deprecated/128_tbl_Shop_Product_Delivery_Region_Link.sql Normal file
View File

@@ -0,0 +1,32 @@
# Product Delivery Option Link
USE PARTSLTD_PROD;
SELECT CONCAT('WARNING: Table ', TABLE_NAME, ' already exists.') AS msg_warning FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'Shop_Product_Delivery_Region_Link';
CREATE TABLE IF NOT EXISTS Shop_Product_Delivery_Region_Link (
id_link INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_product INT NOT NULL,
CONSTRAINT FK_Shop_Product_Delivery_Region_Link_id_product
FOREIGN KEY (id_product)
REFERENCES Shop_Product(id_product)
ON UPDATE RESTRICT,
id_permutation INT,
CONSTRAINT FK_Shop_Product_Delivery_Region_Link_id_permutation
FOREIGN KEY (id_permutation)
REFERENCES Shop_Product_Permutation(id_permutation)
ON UPDATE RESTRICT,
id_region INT NOT NULL,
CONSTRAINT FK_Shop_Product_Delivery_Region_Link_id_region
FOREIGN KEY (id_region)
REFERENCES Shop_Delivery_Region(id_region)
ON UPDATE RESTRICT,
active BIT NOT NULL DEFAULT 1,
created_on DATETIME,
created_by VARCHAR(100),
id_change_set INT,
CONSTRAINT FK_Shop_Product_Delivery_Region_Link_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_Product_Change_Set(id_change_set)
);

23
static/MySQL/deprecated/129_tbl_Shop_Product_Delivery_Region_Link_Audit.sql Normal file
View File

@@ -0,0 +1,23 @@
# Product Delivery Region Link Audits
USE PARTSLTD_PROD;
SELECT CONCAT('WARNING: Table ', TABLE_NAME, ' already exists.') AS msg_warning FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'Shop_Product_Delivery_Region_Link_Audit';
CREATE TABLE IF NOT EXISTS Shop_Product_Delivery_Region_Link_Audit (
id_audit INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_link INT NOT NULL,
CONSTRAINT FK_Shop_Product_Delivery_Region_Link_Audit_id_link
FOREIGN KEY (id_link)
REFERENCES Shop_Product_Delivery_Region_Link(id_link)
ON UPDATE RESTRICT,
name_field VARCHAR(50),
value_prev VARCHAR(500),
value_new VARCHAR(500),
id_change_set INT NOT NULL,
CONSTRAINT FK_Shop_Product_Delivery_Region_Link_Audit_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_Product_Change_Set(id_change_set)
ON UPDATE RESTRICT
);

19
static/MySQL/deprecated/170_ish_tbl_ERP_Order.sql Normal file
View File

@@ -0,0 +1,19 @@
# ERP Order
USE PARTSLTD_PROD;
SELECT CONCAT('WARNING: Table ', TABLE_NAME, ' already exists.') AS msg_warning FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'ERP_Order';
CREATE TABLE IF NOT EXISTS ERP_Order (
id_order INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
code VARCHAR(50),
name VARCHAR(100),
extension VARCHAR(50),
created_on DATETIME,
created_by VARCHAR(100),
id_customer INT NOT NULL,
CONSTRAINT FK_ERP_Order_id_customer
FOREIGN KEY (id_customer)
REFERENCES ERP_Customer(id_customer)
);

39
static/MySQL/deprecated/171_tbl_Shop_User_Order.sql Normal file
View File

@@ -0,0 +1,39 @@
# User Order
USE PARTSLTD_PROD;
SELECT CONCAT('WARNING: Table ', TABLE_NAME, ' already exists.') AS msg_warning FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'Shop_User_Order';
CREATE TABLE IF NOT EXISTS Shop_User_Order (
id_order INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_user VARCHAR(200) NOT NULL,
CONSTRAINT FK_Shop_User_Order_id_user
FOREIGN KEY (id_user)
REFERENCES Shop_User(id_user)
ON UPDATE RESTRICT,
value_total FLOAT,
id_order_status INT NOT NULL,
CONSTRAINT FK_Shop_User_Order_id_order_status
FOREIGN KEY (id_order_status)
REFERENCES Shop_User_Order_Status(id_status),
id_checkout_session VARCHAR(200) NOT NULL,
id_currency INT NOT NULL,
CONSTRAINT FK_Shop_User_Order_id_currency
FOREIGN KEY (id_currency)
REFERENCES Shop_Currency(id_currency)
ON UPDATE RESTRICT,
active BIT NOT NULL DEFAULT 1,
created_on DATETIME,
created_by VARCHAR(100),
id_change_set_user INT,
CONSTRAINT FK_Shop_User_Order_id_change_set_user
FOREIGN KEY (id_change_set_user)
REFERENCES Shop_User_Change_Set(id_change_set)
/*
id_change_set_product INT,
CONSTRAINT FK_Shop_User_Basket_id_change_set_product
FOREIGN KEY (id_change_set_product)
REFERENCES Shop_Product_Change_Set(id_change_set)
*/
);

27
static/MySQL/deprecated/172_tbl_Shop_User_Order_Audit.sql Normal file
View File

@@ -0,0 +1,27 @@
# User Order Audits
USE PARTSLTD_PROD;
SELECT CONCAT('WARNING: Table ', TABLE_NAME, ' already exists.') AS msg_warning FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'Shop_User_Order_Audit';
CREATE TABLE IF NOT EXISTS Shop_User_Order_Audit (
id_audit INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_order INT NOT NULL,
CONSTRAINT FK_Shop_User_Order_Audit_id_order
FOREIGN KEY (id_order)
REFERENCES Shop_User_Order(id_order)
ON UPDATE RESTRICT,
name_field VARCHAR(50),
value_prev VARCHAR(500),
value_new VARCHAR(500),
id_change_set_user INT,
CONSTRAINT FK_Shop_User_Order_Audit_id_change_set_user
FOREIGN KEY (id_change_set_user)
REFERENCES Shop_User_Change_Set(id_change_set)
/*
id_change_set_product INT,
CONSTRAINT FK_Shop_User_Basket_Audit_id_change_set_product
FOREIGN KEY (id_change_set_product)
REFERENCES Shop_Product_Change_Set(id_change_set)
*/
);

33
static/MySQL/deprecated/173_tbl_Shop_User_Order_Product_Link.sql Normal file
View File

@@ -0,0 +1,33 @@
# User Order Product link
USE PARTSLTD_PROD;
SELECT CONCAT('WARNING: Table ', TABLE_NAME, ' already exists.') AS msg_warning FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'Shop_User_Order_Product_Link';
CREATE TABLE IF NOT EXISTS Shop_User_Order_Product_Link (
id_link INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_order INT NOT NULL,
CONSTRAINT FK_Shop_User_Order_Product_Link_id_order
FOREIGN KEY (id_order)
REFERENCES Shop_User_Order(id_order)
ON UPDATE RESTRICT,
id_product INT NOT NULL,
CONSTRAINT FK_Shop_User_Order_Product_Link_id_product
FOREIGN KEY (id_product)
REFERENCES Shop_Product(id_product)
ON UPDATE RESTRICT,
id_permutation INT NULL,
CONSTRAINT FK_Shop_User_Order_Product_Link_id_permutation
FOREIGN KEY (id_permutation)
REFERENCES Shop_Product_Permutation(id_permutation)
ON UPDATE RESTRICT,
quantity FLOAT NOT NULL,
active BIT NOT NULL DEFAULT 1,
created_on DATETIME,
created_by VARCHAR(100),
id_change_set INT,
CONSTRAINT FK_Shop_User_Order_Product_Link_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
);

22
static/MySQL/deprecated/174_tbl_Shop_User_Order_Product_Link_Audit.sql Normal file
View File

@@ -0,0 +1,22 @@
# User Order Product Link Audits
USE PARTSLTD_PROD;
SELECT CONCAT('WARNING: Table ', TABLE_NAME, ' already exists.') AS msg_warning FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'Shop_User_Order_Product_Link_Audit';
CREATE TABLE IF NOT EXISTS Shop_User_Order_Product_Link_Audit (
id_audit INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_link INT NOT NULL,
CONSTRAINT FK_Shop_User_Order_Product_Link_Audit_id_link
FOREIGN KEY (id_link)
REFERENCES Shop_User_Order_Product_Link(id_link)
ON UPDATE RESTRICT,
name_field VARCHAR(50),
value_prev VARCHAR(500),
value_new VARCHAR(500),
id_change_set INT NOT NULL,
CONSTRAINT FK_Shop_User_Order_Product_Link_Audit_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_User_Change_Set(id_change_set)
);

61
static/MySQL/deprecated/313.1_tri_Shop_Product_Variation_Type_Link.sql Normal file
View File

@@ -0,0 +1,61 @@
# Shop Product Variation Link
USE PARTSLTD_PROD;
DROP TRIGGER IF EXISTS before_insert_Shop_Product_Variation_Type_Link;
DROP TRIGGER IF EXISTS before_update_Shop_Product_Variation_Type_Link;
DELIMITER //
CREATE TRIGGER before_insert_Shop_Product_Variation_Type_Link
BEFORE INSERT ON Shop_Product_Variation_Type_Link
FOR EACH ROW
BEGIN
IF NEW.created_on <=> NULL THEN
SET NEW.created_on = NOW();
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by = CURRENT_USER();
END IF;
END //
DELIMITER ;
DELIMITER //
CREATE TRIGGER before_update_Shop_Product_Variation_Type_Link
BEFORE UPDATE ON Shop_Product_Variation_Type_Link
FOR EACH ROW
BEGIN
IF OLD.id_change_set <=> NEW.id_change_set THEN
SIGNAL SQLSTATE '45000'
SET MESSAGE_TEXT = 'New change Set ID must be provided.';
END IF;
INSERT INTO Shop_Product_Variation_Type_Link_Audit (
id_link,
name_field,
value_prev,
value_new,
id_change_set
)
/*
# Changed id_product
SELECT NEW.id_link, 'id_product', OLD.id_product, NEW.id_product, NEW.id_change_set
WHERE NOT OLD.id_product <=> NEW.id_product
UNION
# Changed id_variation
SELECT NEW.id_link, 'id_variation', OLD.id_variation, NEW.id_variation, NEW.id_change_set
WHERE NOT OLD.id_variation <=> NEW.id_variation
UNION
*/
# Changed active
SELECT NEW.id_link, 'active', CONVERT(CONVERT(OLD.active, SIGNED), CHAR), CONVERT(CONVERT(NEW.active, SIGNED), CHAR), NEW.id_change_set
WHERE NOT (OLD.active <=> NEW.active)
UNION
# Changed display_order
SELECT NEW.id_link, 'display_order', CONVERT(OLD.display_order, CHAR), CONVERT(NEW.display_order, CHAR), NEW.id_change_set
WHERE NOT (OLD.display_order <=> NEW.display_order)
;
END //
DELIMITER ;

61
static/MySQL/deprecated/316_tri_Shop_Product_Variation_Link.sql Normal file
View File

@@ -0,0 +1,61 @@
# Shop Product Variation Link
USE PARTSLTD_PROD;
DROP TRIGGER IF EXISTS before_insert_Shop_Product_Variation_Link;
DROP TRIGGER IF EXISTS before_update_Shop_Product_Variation_Link;
DELIMITER //
CREATE TRIGGER before_insert_Shop_Product_Variation_Link
BEFORE INSERT ON Shop_Product_Variation_Link
FOR EACH ROW
BEGIN
IF NEW.created_on <=> NULL THEN
SET NEW.created_on = NOW();
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by = CURRENT_USER();
END IF;
END //
DELIMITER ;
DELIMITER //
CREATE TRIGGER before_update_Shop_Product_Variation_Link
BEFORE UPDATE ON Shop_Product_Variation_Link
FOR EACH ROW
BEGIN
IF OLD.id_change_set <=> NEW.id_change_set THEN
SIGNAL SQLSTATE '45000'
SET MESSAGE_TEXT = 'New change Set ID must be provided.';
END IF;
INSERT INTO Shop_Product_Variation_Link_Audit (
id_link,
name_field,
value_prev,
value_new,
id_change_set
)
/*
# Changed id_product
SELECT NEW.id_link, 'id_product', OLD.id_product, NEW.id_product, NEW.id_change_set
WHERE NOT OLD.id_product <=> NEW.id_product
UNION
# Changed id_variation
SELECT NEW.id_link, 'id_variation', OLD.id_variation, NEW.id_variation, NEW.id_change_set
WHERE NOT OLD.id_variation <=> NEW.id_variation
UNION
*/
# Changed active
SELECT NEW.id_link, 'active', CONVERT(CONVERT(OLD.active, SIGNED), CHAR), CONVERT(CONVERT(NEW.active, SIGNED), CHAR), NEW.id_change_set
WHERE NOT (OLD.active <=> NEW.active)
UNION
# Changed display_order
SELECT NEW.id_link, 'display_order', CONVERT(OLD.display_order, CHAR), CONVERT(NEW.display_order, CHAR), NEW.id_change_set
WHERE NOT (OLD.display_order <=> NEW.display_order)
;
END //
DELIMITER ;

57
static/MySQL/deprecated/328_tri_Shop_Product_Delivery_Region_Link.sql Normal file
View File

@@ -0,0 +1,57 @@
# Shop Product Delivery Region Link
USE PARTSLTD_PROD;
DROP TRIGGER IF EXISTS before_insert_Shop_Product_Delivery_Region_Link;
DROP TRIGGER IF EXISTS before_update_Shop_Product_Delivery_Region_Link;
DELIMITER //
CREATE TRIGGER before_insert_Shop_Product_Delivery_Region_Link
BEFORE INSERT ON Shop_Product_Delivery_Region_Link
FOR EACH ROW
BEGIN
IF NEW.created_on <=> NULL THEN
SET NEW.created_on = NOW();
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by = CURRENT_USER();
END IF;
END //
DELIMITER ;
DELIMITER //
CREATE TRIGGER before_update_Shop_Product_Delivery_Region_Link
BEFORE UPDATE ON Shop_Product_Delivery_Region_Link
FOR EACH ROW
BEGIN
IF OLD.id_change_set <=> NEW.id_change_set THEN
SIGNAL SQLSTATE '45000'
SET MESSAGE_TEXT = 'New change Set ID must be provided.';
END IF;
INSERT INTO Shop_Product_Delivery_Region_Link_Audit (
id_link,
name_field,
value_prev,
value_new,
id_change_set
)
/*
# Changed id_product
SELECT NEW.id_link, 'id_product', CONVERT(OLD.id_product, CHAR), CONVERT(NEW.id_product, CHAR), NEW.id_change_set
WHERE NOT OLD.id_product <=> NEW.id_product
UNION
# Changed id_region
SELECT NEW.id_link, 'id_region', CONVERT(OLD.id_region, CHAR), CONVERT(NEW.id_region, CHAR), NEW.id_change_set
WHERE NOT OLD.id_region <=> NEW.id_region
UNION
*/
# Changed active
SELECT NEW.id_link, 'active', CONVERT(CONVERT(OLD.active, SIGNED), CHAR), CONVERT(CONVERT(NEW.active, SIGNED), CHAR), NEW.id_change_set
WHERE NOT (OLD.active <=> NEW.active)
;
END //
DELIMITER ;

67
static/MySQL/deprecated/371_tri_Shop_User_Order.sql Normal file
View File

@@ -0,0 +1,67 @@
# Shop Product Variation Link
USE PARTSLTD_PROD;
DROP TRIGGER IF EXISTS before_insert_Shop_User_Order;
DROP TRIGGER IF EXISTS before_update_Shop_User_Order;
DELIMITER //
CREATE TRIGGER before_insert_Shop_User_Order
BEFORE INSERT ON Shop_User_Order
FOR EACH ROW
BEGIN
IF NEW.created_on <=> NULL THEN
SET NEW.created_on = NOW();
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by = CURRENT_USER();
END IF;
END //
DELIMITER ;
DELIMITER //
CREATE TRIGGER before_update_Shop_User_Order
BEFORE UPDATE ON Shop_User_Order
FOR EACH ROW
BEGIN
IF OLD.id_change_set_user <=> NEW.id_change_set_user THEN
SIGNAL SQLSTATE '45000'
SET MESSAGE_TEXT = 'New change Set ID must be provided.';
END IF;
IF NOT (NEW.id_checkout_session <=> OLD.id_checkout_session) THEN
SIGNAL SQLSTATE '45000'
SET MESSAGE_TEXT = 'Checkout session ID must not change.';
END IF;
INSERT INTO Shop_User_Order_Audit (
id_order,
name_field,
value_prev,
value_new,
id_change_set_user
)
# Changed id_user
SELECT NEW.id_order, 'id_user', OLD.id_user, NEW.id_user, NEW.id_change_set_user
WHERE NOT OLD.id_user <=> NEW.id_user
UNION
# Changed value_total
SELECT NEW.id_order, 'value_total', CONVERT(OLD.value_total, CHAR), CONVERT(NEW.value_total, CHAR), NEW.id_change_set_user
WHERE NOT (OLD.value_total <=> NEW.value_total)
UNION
# Changed id_order_status
SELECT NEW.id_order, 'id_order_status', CONVERT(OLD.id_order_status, CHAR), CONVERT(NEW.id_order_status, CHAR), NEW.id_change_set_user
WHERE NOT (OLD.id_order_status <=> NEW.id_order_status)
UNION
# Changed id_checkout_session
SELECT NEW.id_order, 'id_checkout_session', OLD.id_checkout_session, NEW.id_checkout_session, NEW.id_change_set_user
WHERE NOT (OLD.id_checkout_session <=> NEW.id_checkout_session)
UNION
# Changed active
SELECT NEW.id_order, 'active', CONVERT(CONVERT(OLD.active, SIGNED), CHAR), CONVERT(CONVERT(NEW.active, SIGNED), CHAR), NEW.id_change_set_user
WHERE NOT (OLD.active <=> NEW.active)
;
END //
DELIMITER ;

55
static/MySQL/deprecated/373_tri_Shop_User_Order_Product_Link.sql Normal file
View File

@@ -0,0 +1,55 @@
# Shop User Order Product Link
USE PARTSLTD_PROD;
DROP TRIGGER IF EXISTS before_insert_Shop_User_Order_Product_Link;
DROP TRIGGER IF EXISTS before_update_Shop_User_Order_Product_Link;
DELIMITER //
CREATE TRIGGER before_insert_Shop_User_Order_Product_Link
BEFORE INSERT ON Shop_User_Order_Product_Link
FOR EACH ROW
BEGIN
IF NEW.created_on <=> NULL THEN
SET NEW.created_on = NOW();
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by = CURRENT_USER();
END IF;
END //
DELIMITER ;
DELIMITER //
CREATE TRIGGER before_update_Shop_User_Order_Product_Link
BEFORE UPDATE ON Shop_User_Order_Product_Link
FOR EACH ROW
BEGIN
IF OLD.id_change_set <=> NEW.id_change_set THEN
SIGNAL SQLSTATE '45000'
SET MESSAGE_TEXT = 'New change Set ID must be provided.';
END IF;
INSERT INTO Shop_User_Order_Product_Link_Audit (
id_link,
name_field,
value_prev,
value_new,
id_change_set
)
# Changed id_product
SELECT NEW.id_link, 'active', CONVERT(OLD.id_product, CHAR), CONVERT(NEW.id_product, CHAR), NEW.id_change_set
WHERE NOT (OLD.id_product <=> NEW.id_product)
UNION
# Changed quantity
SELECT NEW.id_link, 'quantity', CONVERT(OLD.quantity, CHAR), CONVERT(NEW.quantity, CHAR), NEW.id_change_set
WHERE NOT (OLD.quantity <=> NEW.quantity)
UNION
# Changed active
SELECT NEW.id_link, 'active', CONVERT(CONVERT(OLD.active, SIGNED), CHAR), CONVERT(CONVERT(NEW.active, SIGNED), CHAR), NEW.id_change_set
WHERE NOT (OLD.active <=> NEW.active)
;
END //
DELIMITER ;

657
static/MySQL/deprecated/706_p_shop_get_product.sql Normal file
View File

@@ -0,0 +1,657 @@
USE PARTSLTD_PROD;
/*
CALL p_shop_get_product (
'', # a_id_user
1, # a_id_product
'', # a_ids_image
0, # a_get_first_image_only
1 # a_get_all_images
)
*/
-- Clear previous proc
DROP PROCEDURE IF EXISTS p_shop_get_product;
DELIMITER //
CREATE PROCEDURE p_shop_get_product (
IN a_id_user VARCHAR(200),
IN a_id_product INT,
IN a_ids_permutation VARCHAR(4000),
IN a_ids_image VARCHAR(500),
IN a_get_first_image_only BIT,
IN a_get_all_images BIT
)
BEGIN
-- Argument redeclaration
-- Variable declaration
DECLARE v_has_filter_product BIT;
DECLARE v_id_product_search VARCHAR(10);
DECLARE v_has_filter_permutation BIT;
DECLARE v_has_product_permutations BIT;
DECLARE v_guid VARCHAR(36);
# DECLARE v_id_user VARCHAR(100);
DECLARE v_id_permission_product INT;
DECLARE v_ids_product_permission VARCHAR(500);
DECLARE v_id_access_level_view INT;
DECLARE v_has_filter_image BIT;
DECLARE v_now DATETIME;
DECLARE v_id_minimum INT;
DECLARE v_code_error_data VARCHAR(50);
SET v_guid := UUID();
SET v_code_error_data := (SELECT code FROM Shop_Msg_Error_Type WHERE id_type = 1);
SET v_id_access_level_view := (SELECT id_access_level FROM Shop_Access_Level WHERE code = 'VIEW');
-- Argument validation + default values
IF a_id_user IS NULL THEN
SET a_id_user = '';
ELSE
SET a_id_user = TRIM(a_id_user);
END IF;
IF a_ids_image IS NULL THEN
SET a_ids_image = '';
ELSE
SET a_ids_image = TRIM(a_ids_image);
END IF;
-- Temporary tables
DROP TABLE IF EXISTS tmp_Shop_Image;
DROP TABLE IF EXISTS tmp_Shop_Variation;
DROP TABLE IF EXISTS tmp_Shop_Product;
CREATE TABLE tmp_Shop_Product (
id_product INT NOT NULL,
CONSTRAINT FK_tmp_Shop_Product_id_product
FOREIGN KEY (id_product)
REFERENCES Shop_Product(id_product),
id_permutation INT NULL,
CONSTRAINT FK_tmp_Shop_Product_id_permutation
FOREIGN KEY (id_permutation)
REFERENCES Shop_Product_Permutation(id_permutation),
id_category INT NOT NULL,
CONSTRAINT FK_tmp_Shop_Product_id_category
FOREIGN KEY (id_category)
REFERENCES Shop_Category(id_category),
display_order INT,
can_view BIT,
can_edit BIT,
can_admin BIT
);
/*
CREATE TEMPORARY TABLE tmp_Shop_Variation (
id_variation INT NOT NULL,
id_product INT NOT NULL,
display_order INT NOT NULL
);
*/
CREATE TABLE tmp_Shop_Image (
id_product INT NOT NULL,
CONSTRAINT FK_tmp_Shop_Image_id_product
FOREIGN KEY (id_product)
REFERENCES Shop_Product(id_product),
id_permutation INT NULL,
CONSTRAINT FK_tmp_Shop_Image_id_permutation
FOREIGN KEY (id_permutation)
REFERENCES Shop_Product_Permutation(id_permutation),
id_image INT NOT NULL,
CONSTRAINT FK_tmp_Shop_Image_id_image
FOREIGN KEY (id_image)
REFERENCES Shop_Image(id_image),
display_order INT NOT NULL
);
CREATE TABLE IF NOT EXISTS tmp_Msg_Error (
display_order INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
guid VARCHAR(36) NOT NULL,
# code VARCHAR(50) NOT NULL,
# CONSTRAINT chk_tmp_Msg_Error_code CHECK (code IN (SELECT code FROM Shop_Msg_Error_Type)),
id_type INT NOT NULL,
CONSTRAINT FK_tmp_Msg_Error_id_type
FOREIGN KEY (id_type)
REFERENCES Shop_Msg_Error_Type(id_type),
msg VARCHAR(4000) NOT NULL
);
-- Parse filters
# SET v_id_product_search = CONCAT('%', CAST(a_id_product AS CHAR), '%');
# select v_id_product_search;
SET v_has_filter_image = '';
# Products
INSERT INTO tmp_Shop_Product (
id_product, id_category, display_order
)
SELECT P.id_product, P.id_category, P.display_order
FROM Shop_Product P
# WHERE P.id_product LIKE v_id_product_search
WHERE P.id_product = a_id_product
AND NOT P.has_variations
AND P.active
;
# Product Permutations
INSERT INTO tmp_Shop_Product (
id_product, id_category, id_permutation, display_order
)
SELECT PP.id_product, P.id_category, PP.id_permutation, PP.display_order
FROM Shop_Product_Permutation PP
INNER JOIN Shop_Product P
ON PP.id_product = P.id_product
AND P.has_variations
AND P.active
# WHERE PP.id_product LIKE v_id_product_search
WHERE PP.id_product = a_id_product
AND PP.active
;
SET a_id_product := (SELECT id_product FROM tmp_Shop_Product LIMIT 1);
-- SET v_has_filter_product = NOT ISNULL(a_id_product);
SET v_has_product_permutations = EXISTS (SELECT id_permutation FROM tmp_Shop_Product WHERE NOT ISNULL(id_permutation));
IF ISNULL(a_id_product) THEN # NOT v_has_filter_product
INSERT INTO tmp_Msg_Error (
guid,
code,
msg
)
VALUES (
v_guid,
v_code_error_data,
'Valid product ID not provided.'
)
;
END IF;
# Permutations
IF v_has_filter_permutation THEN
DELETE FROM tmp_Shop_Product
WHERE FIND_IN_SET(id_permutation, a_ids_permutation) = 0
;
IF NOT EXISTS (SELECT * FROM tmp_Shop_Product) THEN
INSERT INTO tmp_Msg_Error (
guid,
code,
msg
)
VALUES (
v_guid,
v_code_error_data,
'Permutation IDs not associated with product ID.'
)
;
END IF;
END IF;
/*
# Variations
INSERT INTO tmp_Shop_Variation (
id_variation, id_product
)
SELECT P.id_variation, P.id_product
FROM Shop_Variation V
INNER JOIN tmp_Shop_Product t_P
ON V.id_product = t_P.id_product
WHERE V.active
;
*/
IF NOT EXISTS (SELECT * FROM tmp_Msg_Error WHERE guid = v_guid) THEN
# Product Images
INSERT INTO tmp_Shop_Image (
id_product, id_image, display_order
)
SELECT t_P.id_product, I.id_image, I.display_order
FROM Shop_Image I
INNER JOIN tmp_Shop_Product t_P
ON I.id_product = t_P.id_product
AND ISNULL(I.id_permutation)
INNER JOIN Shop_Product P
ON t_P.id_product = P.id_product
AND NOT P.has_variations
WHERE I.active
;
# Product Permutation Images
INSERT INTO tmp_Shop_Image (
id_product,
id_permutation,
id_image,
display_order
)
SELECT t_P.id_product,
t_P.id_permutation,
I.id_image,
ROW_NUMBER() OVER W AS display_order
FROM Shop_Image I
INNER JOIN Shop_Product_Permutation PP
ON I.id_permutation = PP.id_permutation
INNER JOIN Shop_Product P
ON PP.id_product = P.id_product
AND P.has_variations
INNER JOIN tmp_Shop_Product t_P
ON P.id_product = t_P.id_product
AND PP.id_permutation = t_P.id_permutation
WHERE I.active
WINDOW W AS (ORDER BY P.display_order, PP.display_order, I.display_order)
;
END IF;
-- Permissions
IF NOT EXISTS (SELECT * FROM tmp_Msg_Error WHERE guid = v_guid) AND EXISTS (SELECT * FROM tmp_Shop_Product LIMIT 1) THEN
# SET v_id_user := (SELECT id_user FROM Shop_User WHERE name = CURRENT_USER());
SET v_id_permission_product := (SELECT id_permission FROM Shop_Permission WHERE code = 'STORE_PRODUCT' LIMIT 1);
SET v_ids_product_permission := (SELECT GROUP_CONCAT(DISTINCT id_product SEPARATOR '|') FROM tmp_Shop_Product);
SELECT v_guid, a_id_user, false, v_id_permission_product, v_id_access_level_view, v_ids_product_permission;
CALL p_shop_user_eval(v_guid, a_id_user, false, v_id_permission_product, v_id_access_level_view, v_ids_product_permission);
select * from shop_user_eval_temp;
UPDATE tmp_Shop_Product t_P
INNER JOIN Shop_User_Eval_Temp UE_T
ON t_P.id_product = UE_T.id_product
AND UE_T.GUID = v_guid
SET t_P.can_view = UE_T.can_view,
t_P.can_edit = UE_T.can_edit,
t_P.can_admin = UE_T.can_admin;
DELETE FROM tmp_Shop_Product
WHERE FIND_IN_SET(id_product, (SELECT GROUP_CONCAT(id_product SEPARATOR ',') FROM Shop_User_Eval_Temp)) = 0 # id_product NOT LIKE CONCAT('%', (SELECT GROUP_CONCAT(id_product SEPARATOR '|') FROM Shop_User_Eval_Temp), '%');
;
# CALL p_shop_user_eval_clear_temp(v_guid);
# DROP TABLE IF EXISTS Shop_User_Eval_Temp;
DELETE FROM Shop_User_Eval_Temp
WHERE GUID = v_guid;
END IF;
-- Returns
SET v_now := NOW();
# Category
SELECT DISTINCT t_P.id_category,
C.name,
C.description,
C.display_order
FROM tmp_Shop_Product t_P
INNER JOIN Shop_Category C
ON t_P.id_category = C.id_category
ORDER BY C.display_order
;
IF NOT v_has_product_permutations THEN
# Products
SELECT t_P.id_product,
NULL AS id_permutation,
P.name,
P.description,
P.price_GBP_full,
P.has_variations,
P.id_category,
P.latency_manuf,
P.quantity_min,
P.quantity_max,
P.quantity_step,
P.quantity_stock,
P.id_stripe_product,
P.is_subscription,
RI.name AS name_recurrence_interval,
RI.name_plural AS name_plural_recurrence_interval,
P.count_recurrence_interval
FROM tmp_Shop_Product t_P
INNER JOIN Shop_Product P
ON t_P.id_product = P.id_product
LEFT JOIN Shop_Recurrence_Interval RI
ON P.id_recurrence_interval = RI.id_interval
WHERE ISNULL(t_P.id_permutation)
ORDER BY t_P.display_order
;
ELSE
# Permutations
SELECT t_P.id_product,
t_P.id_permutation,
P.name,
P.description,
P.price_GBP_full,
P.has_variations,
P.id_category,
P.latency_manuf,
P.quantity_min,
P.quantity_max,
P.quantity_step,
P.quantity_stock,
P.id_stripe_product,
P.is_subscription,
RI.name AS name_recurrence_interval,
RI.name_plural AS name_plural_recurrence_interval,
P.count_recurrence_interval
FROM tmp_Shop_Product t_P
INNER JOIN Shop_Product_Permutation PP
ON t_P.id_permutation = PP.id_permutation
AND PP.active
INNER JOIN Shop_Product P
ON PP.id_product = P.id_product
LEFT JOIN Shop_Recurrence_Interval RI
ON P.id_recurrence_interval = RI.id_interval
WHERE NOT ISNULL(t_P.id_permutation)
ORDER BY t_P.display_order
;
END IF;
# Variations
IF v_has_product_permutations THEN
SELECT PPVL.id_variation,
t_P.id_product,
t_P.id_category,
VT.code AS code_variation_type,
VT.name AS name_variation_type,
V.code AS code_variation,
V.name AS name_variation
FROM Shop_Product_Permutation_Variation_Link PPVL
INNER JOIN tmp_Shop_Product t_P
ON PPVL.id_permutation = t_P.id_permutation
INNER JOIN Shop_Variation V
ON PPVL.id_variation = V.id_variation
INNER JOIN Shop_Variation_Type VT
ON V.id_type = VT.id_type
WHERE V.active
AND VT.active
AND PPVL.active
ORDER BY VT.display_order, V.display_order
;
ELSE
SELECT NULL AS id_variation,
NULL AS id_product,
NULL AS id_category,
NULL AS code_variation_type,
NULL AS name_variation_type,
NULL AS code_variation,
NULL AS name_variation
;
END IF;
IF v_has_product_permutations THEN
# Permutation Variations
SELECT t_P.id_permutation,
t_P.id_product,
t_P.id_category,
id_variation
FROM Shop_Product_Permutation_Variation_Link PPVL
INNER JOIN tmp_Shop_Product t_P
ON t_P.id_permutation = PPVL.id_permutation
;
ELSE
SELECT NULL AS id_permutation,
NULL AS id_product,
NULL AS id_category,
NULL AS id_variation
;
END IF;
# Images
SELECT I.id_image,
t_P.id_product,
I.id_permutation,
t_P.id_category,
I.url
FROM tmp_Shop_Image t_I
INNER JOIN Shop_Image I
ON t_I.id_image = I.id_image
INNER JOIN tmp_Shop_Product t_P
ON a_id_product = t_P.id_product
AND I.id_permutation = t_P.id_permutation
-- WHERE I.active
ORDER BY I.display_order
;
# Delivery Regions
IF v_has_product_permutations THEN
SELECT DR.id_region,
t_P.id_category,
t_P.id_product,
t_P.id_permutation,
DR.code,
DR.name
FROM Shop_Delivery_Region DR
INNER JOIN Shop_Product_Delivery_Region_Link PDRL
ON DR.id_region = PDRL.id_region
AND PDRL.active
INNER JOIN tmp_Shop_Product t_P
ON PDRL.id_permutation = t_P.id_permutation
WHERE DR.active
ORDER BY t_P.id_permutation, DR.display_order
;
ELSE
SELECT PDRL.id_region,
t_P.id_category,
t_P.id_product,
t_P.id_permutation,
DR.code,
DR.name
FROM Shop_Delivery_Region DR
INNER JOIN Shop_Product_Delivery_Region_Link PDRL
ON DR.id_region = PDRL.id_region
AND PDRL.active
INNER JOIN tmp_Shop_Product t_P
ON PDRL.id_product = t_P.id_product
WHERE DR.active
ORDER BY DR.display_order
;
END IF;
# Delivery options
IF v_has_product_permutations THEN
SELECT _DO.id_option,
_DO.id_product,
_DO.id_permutation,
t_P.id_category,
DOT.code,
DOT.name,
DOT.latency_delivery_min,
DOT.latency_delivery_max,
DOT.quantity_min,
DOT.quantity_max,
GROUP_CONCAT(DR.code SEPARATOR ',') AS codes_region,
GROUP_CONCAT(DR.name SEPARATOR ',') AS names_region,
_DO.price_GBP,
DOT.display_order
FROM Shop_Delivery_Option _DO
INNER JOIN Shop_Delivery_Option_Type DOT
ON _DO.id_delivery_type = DOT.id_type
AND DOT.active
INNER JOIN tmp_Shop_Product t_P
ON _DO.id_permutation = t_P.id_permutation
INNER JOIN Shop_Product_Delivery_Region_Link PDRL
ON t_P.id_product = PDRL.id_product
AND PDRL.active
INNER JOIN Shop_Delivery_Region DR
ON PDRL.id_region = DR.id_region
AND DR.active
WHERE _DO.active
AND a_id_product = _DO.id_product
GROUP BY t_P.id_product, PDRL.id_region, _DO.id_option, t_P.id_category
ORDER BY DOT.display_order
;
ELSE
SELECT _DO.id_option,
_DO.id_product,
_DO.id_permutation,
t_P.id_category,
DOT.code,
DOT.name,
DOT.latency_delivery_min,
DOT.latency_delivery_max,
DOT.quantity_min,
DOT.quantity_max,
GROUP_CONCAT(DR.code SEPARATOR ',') AS codes_region,
GROUP_CONCAT(DR.name SEPARATOR ',') AS names_region,
_DO.price_GBP,
DOT.display_order
FROM Shop_Delivery_Option _DO
INNER JOIN Shop_Delivery_Option_Type DOT
ON _DO.id_delivery_type = DOT.id_type
AND DOT.active
INNER JOIN tmp_Shop_Product t_P
ON _DO.id_product = t_P.id_product
INNER JOIN Shop_Product_Delivery_Region_Link PDRL
ON t_P.id_product = PDRL.id_product
AND PDRL.active
INNER JOIN Shop_Delivery_Region DR
ON PDRL.id_region = DR.id_region
AND DR.active
WHERE _DO.active
AND a_id_product = _DO.id_product
GROUP BY t_P.id_product, PDRL.id_region, _DO.id_option, t_P.id_category
ORDER BY DOT.display_order
;
END IF;
IF v_has_product_permutations THEN
# Discounts
SELECT D.id_discount,
t_P.id_category,
a_id_product,
D.id_permutation,
D.code,
D.name,
D.multiplier,
D.quantity_min,
D.quantity_max,
D.date_start,
D.date_end,
D.display_order
FROM Shop_Discount D
INNER JOIN tmp_Shop_Product t_P
ON D.id_permutation = t_P.id_permutation
WHERE D.active
;
ELSE
# Discounts
SELECT D.id_discount,
t_P.id_category,
D.id_product,
NULL AS id_permutation,
D.code,
D.name,
D.multiplier,
D.quantity_min,
D.quantity_max,
D.date_start,
D.date_end,
D.display_order
FROM Shop_Discount D
INNER JOIN tmp_Shop_Product t_P
ON D.id_product = t_P.id_product
WHERE D.active
AND a_id_product = D.id_product
;
END IF;
IF v_has_product_permutations THEN
# Discount Delivery Regions
SELECT DDRL.id_discount,
DDRL.id_region,
t_P.id_category,
t_P.id_product,
t_P.id_permutation,
DR.code,
DR.name,
DR.display_order
FROM Shop_Discount D
INNER JOIN tmp_Shop_Product t_P
ON D.id_permutation = t_P.id_permutation
INNER JOIN Shop_Discount_Delivery_Region_Link DDRL
ON D.id_discount = DDRL.id_discount
AND DDRL.active
INNER JOIN Shop_Delivery_Region DR
ON DDRL.id_region = DR.id_region
AND DR.active
WHERE D.active
;
ELSE
# Discount Delivery Regions
SELECT DDRL.id_discount,
DDRL.id_region,
t_P.id_category,
t_P.id_product,
NULL AS id_permutation,
DR.code,
DR.name,
DR.display_order
FROM Shop_Discount D
INNER JOIN tmp_Shop_Product t_P
ON D.id_product = t_P.id_product
INNER JOIN Shop_Discount_Delivery_Region_Link DDRL
ON D.id_discount = DDRL.id_discount
AND DDRL.active
INNER JOIN Shop_Delivery_Region DR
ON DDRL.id_region = DR.id_region
AND DR.active
WHERE D.active
AND a_id_product = D.id_product
;
END IF;
# Errors
SELECT *
FROM tmp_Msg_Error
WHERE guid = v_guid
;
/*
# Return arguments for test
SELECT
a_ids_category,
a_get_inactive_categories,
a_ids_product,
a_get_inactive_products,
a_get_first_product_only,
a_get_all_products,
a_ids_image,
a_get_inactive_images,
a_get_first_image_only,
a_get_all_images
;
*/
-- Clean up
DROP TABLE IF EXISTS tmp_Shop_Image;
DROP TABLE IF EXISTS tmp_Shop_Variation;
DROP TABLE IF EXISTS tmp_Shop_Product;
END //
DELIMITER ;
CALL p_shop_get_product (
'', # a_id_user
1 # a_id_product
);
/*
drop table tmp_msg_error;
select * from shop_image;
select * from shop_discount;
insert into shop_product_change_set (comment)
values ('set product not subscription - test bool output to python');
update shop_product
set is_subscription = 0,
id_change_set = (select id_change_set from shop_product_change_set order by id_change_set desc limit 1)
where id_product = 1
*/

8235
static/MySQL/deprecated/dump.sql Normal file
View File

File diff suppressed because it is too large Load Diff

8235
static/MySQL/deprecated/dump2.sql Normal file
View File

File diff suppressed because it is too large Load Diff