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

Fix: Remove keys etc. for public demo repo.

Browse Source
This commit is contained in:
Teddy Middleton-Smith
2025-01-14 10:53:24 +00:00
parent ed13ccb2c1
commit 2103335735
204 changed files with 49 additions and 52579 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,824 +0,0 @@
/* Store */
# 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 INT,
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 := IFNULL(NEW.created_on, NOW());
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by := IFNULL(NEW.created_by, IFNULL((SELECT id_user FROM Shop_User WHERE firstname = CURRENT_USER()), -1));
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 INT,
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 := IFNULL(NEW.created_on, NOW());
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by := IFNULL(NEW.created_by, IFNULL((SELECT id_user FROM Shop_User WHERE firstname = CURRENT_USER()), -1));
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 INT,
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 := IFNULL(NEW.created_on, NOW());
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by := IFNULL(NEW.created_by, IFNULL((SELECT id_user FROM Shop_User WHERE firstname = CURRENT_USER()), -1));
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 INT,
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 := IFNULL(NEW.created_on, NOW());
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by := IFNULL(NEW.created_by, IFNULL((SELECT id_user FROM Shop_User WHERE firstname = CURRENT_USER()), -1));
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 INT,
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 := IFNULL(NEW.created_on, NOW());
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by := IFNULL(NEW.created_by, IFNULL((SELECT id_user FROM Shop_User WHERE firstname = CURRENT_USER()), -1));
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 INT,
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 := IFNULL(NEW.created_on, NOW());
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by := IFNULL(NEW.created_by, IFNULL((SELECT id_user FROM Shop_User WHERE firstname = CURRENT_USER()), -1));
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 INT,
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 := IFNULL(NEW.created_on, NOW());
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by := IFNULL(NEW.created_by, IFNULL((SELECT id_user FROM Shop_User WHERE firstname = CURRENT_USER()), -1));
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 INT,
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 := IFNULL(NEW.created_on, NOW());
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by := IFNULL(NEW.created_by, IFNULL((SELECT id_user FROM Shop_User WHERE firstname = CURRENT_USER()), -1));
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
View File

File diff suppressed because it is too large Load Diff

20
static/MySQL/deprecated/108_tbl_Shop_Recurrence_Interval.sql
View File

@@ -1,20 +0,0 @@
# Recurrence Interval
SELECT CONCAT('WARNING: Table ', TABLE_NAME, ' already exists.') AS msg_warning FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'Shop_Interval_Recurrence';
CREATE TABLE IF NOT EXISTS Shop_Interval_Recurrence (
id_interval INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
code VARCHAR(50),
name VARCHAR(255),
name_plural VARCHAR(256),
active BIT NOT NULL DEFAULT 1,
created_on DATETIME,
created_by INT,
id_change_set INT,
CONSTRAINT FK_Shop_Interval_Recurrence_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_Product_Change_Set(id_change_set)
);

22
static/MySQL/deprecated/109_tbl_Shop_Recurrence_Interval_Audit.sql
View File

@@ -1,22 +0,0 @@
# Recurrence Interval Audits
SELECT CONCAT('WARNING: Table ', TABLE_NAME, ' already exists.') AS msg_warning FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'Shop_Interval_Recurrence_Audit';
CREATE TABLE IF NOT EXISTS Shop_Interval_Recurrence_Audit (
id_audit INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
id_interval INT NOT NULL,
CONSTRAINT FK_Shop_Interval_Recurrence_Audit_id_interval
FOREIGN KEY (id_interval)
REFERENCES Shop_Interval_Recurrence(id_interval)
ON UPDATE RESTRICT,
name_field VARCHAR(50),
value_prev VARCHAR(256),
value_new VARCHAR(256),
id_change_set INT NOT NULL,
CONSTRAINT FK_Shop_Interval_Recurrence_Audit_id_change_set
FOREIGN KEY (id_change_set)
REFERENCES Shop_Product_Change_Set(id_change_set)
);

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

@@ -1,28 +0,0 @@
# Product Variation Type Link
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 INT,
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
View File

@@ -1,23 +0,0 @@
# Product Variation Type Link Audits
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
View File

@@ -1,35 +0,0 @@
# Product Variation Link
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 INT,
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
View File

@@ -1,23 +0,0 @@
# Product Variation Link Audits
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
View File

@@ -1,32 +0,0 @@
# Product Delivery Option Link
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 INT,
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
View File

@@ -1,23 +0,0 @@
# Product Delivery Region Link Audits
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
View File

@@ -1,19 +0,0 @@
# ERP Order
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 INT,
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
View File

@@ -1,39 +0,0 @@
# User Order
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 INT 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 INT,
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
View File

@@ -1,27 +0,0 @@
# User Order Audits
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
View File

@@ -1,33 +0,0 @@
# User Order Product link
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 INT,
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
View File

@@ -1,22 +0,0 @@
# User Order Product Link Audits
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)
);

56
static/MySQL/deprecated/308_tri_Shop_Recurrence_Interval.sql
View File

@@ -1,56 +0,0 @@
# Shop Recurrence Interval
DROP TRIGGER IF EXISTS before_insert_Shop_Interval_Recurrence;
DROP TRIGGER IF EXISTS before_update_Shop_Interval_Recurrence;
DELIMITER //
CREATE TRIGGER before_insert_Shop_Interval_Recurrence
BEFORE INSERT ON Shop_Interval_Recurrence
FOR EACH ROW
BEGIN
SET NEW.created_on := IFNULL(NEW.created_on, NOW());
SET NEW.created_by := IFNULL(NEW.created_by, IFNULL((SELECT id_user FROM Shop_User WHERE firstname = CURRENT_USER()), -1));
END //
DELIMITER ;;
DELIMITER //
CREATE TRIGGER before_update_Shop_Interval_Recurrence
BEFORE UPDATE ON Shop_Interval_Recurrence
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_Interval_Recurrence_Audit (
id_interval,
name_field,
value_prev,
value_new,
id_change_set
)
# Changed code
SELECT NEW.id_interval, 'code', OLD.code, NEW.code, NEW.id_change_set
WHERE NOT OLD.code <=> NEW.code
UNION
# Changed name
SELECT NEW.id_interval, 'name', OLD.name, NEW.name, NEW.id_change_set
WHERE NOT OLD.name <=> NEW.name
UNION
# Changed name_plural
SELECT NEW.id_interval, 'name_plural', OLD.name_plural, NEW.name_plural, NEW.id_change_set
WHERE NOT OLD.name_plural <=> NEW.name_plural
UNION
# Changed name
SELECT NEW.id_interval, 'active', OLD.active, NEW.active, NEW.id_change_set
WHERE NOT OLD.active <=> NEW.active
;
END //
DELIMITER ;;

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

@@ -1,61 +0,0 @@
# Shop Product Variation Link
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 := IFNULL(NEW.created_on, NOW());
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by := IFNULL(NEW.created_by, IFNULL((SELECT id_user FROM Shop_User WHERE firstname = CURRENT_USER()), -1));
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
View File

@@ -1,61 +0,0 @@
# Shop Product Variation Link
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 := IFNULL(NEW.created_on, NOW());
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by := IFNULL(NEW.created_by, IFNULL((SELECT id_user FROM Shop_User WHERE firstname = CURRENT_USER()), -1));
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 ;;

93
static/MySQL/deprecated/322_tri_Shop_Price.sql
View File

@@ -1,93 +0,0 @@
# Shop Product Currency Region Link
DROP TRIGGER IF EXISTS before_insert_Shop_Product_Currency_Region_Link;
DROP TRIGGER IF EXISTS before_update_Shop_Product_Currency_Region_Link;
DELIMITER //
CREATE TRIGGER before_insert_Shop_Product_Currency_Region_Link
BEFORE INSERT ON Shop_Product_Currency_Region_Link
FOR EACH ROW
BEGIN
IF NEW.created_on <=> NULL THEN
SET NEW.created_on := IFNULL(NEW.created_on, NOW());
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by := IFNULL(NEW.created_by, IFNULL((SELECT id_user FROM Shop_User WHERE firstname = CURRENT_USER()), -1));
END IF;
/*
SET NEW.price_local = (
SELECT PP.price_GBP_full * C.factor_from_GBP
FROM Shop_Product_Permutation PP
INNER JOIN Shop_Product P ON PP.id_product = P.id_product
INNER JOIN Shop_Currency C ON NEW.id_currency = C.id_currency
WHERE NEW.id_product = P.id_product
LIMIT 1
);
*/
END //
DELIMITER ;;
DELIMITER //
CREATE TRIGGER before_update_Shop_Product_Currency_Region_Link
BEFORE UPDATE ON Shop_Product_Currency_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;
/*
SET NEW.price_local = (
SELECT P.price_GBP_full * C.factor_from_GBP
FROM Shop_Product P
INNER JOIN Shop_Currency C ON NEW.id_currency = C.id_currency
WHERE NEW.id_product = P.id_product
LIMIT 1
);
*/
INSERT INTO Shop_Product_Currency_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_currency
SELECT NEW.id_link, 'id_currency', CONVERT(OLD.id_currency, CHAR), CONVERT(NEW.id_currency, CHAR), NEW.id_change_set
WHERE NOT OLD.id_currency <=> NEW.id_currency
UNION
# Changed price_local
SELECT NEW.id_link, 'price_local', OLD.price_local, NEW.price_local, NEW.id_change_set
WHERE NOT OLD.price_local <=> NEW.price_local
UNION
*/
# Changed price_local_VAT_incl
SELECT NEW.id_link, 'price_local_VAT_incl', OLD.price_local_VAT_incl, NEW.price_local_VAT_incl, NEW.id_change_set
WHERE NOT OLD.price_local_VAT_incl <=> NEW.price_local_VAT_incl
UNION
# Changed price_local_VAT_excl
SELECT NEW.id_link, 'price_local_VAT_excl', OLD.price_local_VAT_excl, NEW.price_local_VAT_excl, NEW.id_change_set
WHERE NOT OLD.price_local_VAT_excl <=> NEW.price_local_VAT_excl
UNION
# Changed id_stripe_price
SELECT NEW.id_link, 'id_stripe_price', OLD.id_stripe_price, NEW.id_stripe_price, NEW.id_change_set
WHERE NOT OLD.id_stripe_price <=> NEW.id_stripe_price
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 ;;

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

@@ -1,57 +0,0 @@
# Shop Product Delivery Region Link
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 := IFNULL(NEW.created_on, NOW());
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by := IFNULL(NEW.created_by, IFNULL((SELECT id_user FROM Shop_User WHERE firstname = CURRENT_USER()), -1));
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
View File

@@ -1,67 +0,0 @@
# Shop Product Variation Link
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 := IFNULL(NEW.created_on, NOW());
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by := IFNULL(NEW.created_by, IFNULL((SELECT id_user FROM Shop_User WHERE firstname = CURRENT_USER()), -1));
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
View File

@@ -1,55 +0,0 @@
# Shop User Order Product Link
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 := IFNULL(NEW.created_on, NOW());
END IF;
IF NEW.created_by <=> NULL THEN
SET NEW.created_by := IFNULL(NEW.created_by, IFNULL((SELECT id_user FROM Shop_User WHERE firstname = CURRENT_USER()), -1));
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 ;;

131
static/MySQL/deprecated/7000_p_shop_get_many_role_permission.sql
View File

@@ -1,131 +0,0 @@
/*
THIS STRUCTURE DOES NOT WORK WITH MYSQL ??
CALL p_shop_get_many_role_permission (
'',
0,
'',
0,
0,
1,
'',
0,
0,
1
)
*/
-- Clear previous proc
DROP PROCEDURE IF EXISTS p_shop_get_many_role_permission;
/*
DROP TABLE IF EXISTS tmp_Shop_Image;
DROP TABLE IF EXISTS tmp_Shop_Product;
DROP TABLE IF EXISTS tmp_Shop_Variation;
DROP TABLE IF EXISTS tmp_Shop_Product_Category;
*/
DELIMITER //
CREATE PROCEDURE p_shop_get_many_role_permission (
a_ids_role NVARCHAR(500),
a_get_inactive_roles BIT
)
BEGIN
-- Variable declaration
DECLARE v_has_filter_role BIT;
DECLARE v_priority_view INT;
DECLARE v_priority_edit INT;
DECLARE v_priority_admin INT;
/*
DECLARE v_ids_product_permission VARCHAR(500);
DECLARE v_now DATETIME;
*/
-- Parse arguments + get default values
IF a_ids_role IS NULL THEN
SET a_ids_role = '';
ELSE
SET a_ids_role = TRIM(a_ids_role);
END IF;
IF a_get_inactive_roles IS NULL THEN
SET a_get_inactive_roles = 0;
END IF;
-- Temporary tables
CREATE TABLE tmp_Permission (
id_role INT NOT NULL,
CONSTRAINT FK_tmp_User_Permission_id_role
FOREIGN KEY (id_role)
REFERENCES Shop_Role(id_role),
id_permission INT,
CONSTRAINT FK_tmp_User_Permission_id_permission
FOREIGN KEY (id_permission)
REFERENCES Shop_Permission(id_permission),
id_access_level INT,
CONSTRAINT FK_tmp_User_Permission_id_access_level
FOREIGN KEY (id_user)
REFERENCES Shop_Access_Level(id_user),
can_view BIT,
can_edit BIT,
can_admin BIT
);
-- Parse filters
SET a_ids_role = REPLACE(a_ids_role, ',', '|');
SET v_has_filter_role = CASE WHEN a_ids_role = '' THEN 0 ELSE 1 END;
INSERT INTO tmp_User_Permission (
id_role,
id_permission,
id_access_level,
can_view,
can_edit,
can_admin
)
SELECT U.id_user,
U.is_super_user,
U.is_super_user,
U.is_super_user,
U.is_super_user
FROM Shop_Role R
INNER JOIN Shop_Role_Permission_Link RPL
ON R.id_role = RPL.id_role
AND RPL.active
INNER JOIN Shop_Permission PERM
ON RPL.id_permission = PERM.id_permission
AND PERM.active
INNER JOIN Shop_Permission_Group PG
ON PERM.id_permission_group = PG.id_group
AND PG.active
LEFT JOIN Shop_Access_Level AL
ON RPL.id_access_level = AL.id_access_level
AND AL.active
WHERE
R.id_role LIKE CONCAT('%', a_ids_role, '%')
AND (
PERM.required_access_level = 0
OR AL.priority >= PERM.required_access_level
)
;
UPDATE tmp_User_Permission t_UP
INNER JOIN Shop_Access_Level AL
ON AL.code = 'ADMIN'
SET t_UP.id_access_level = AL.id_access_level
WHERE t_UP.is_super_user
;
-- Clean up
DROP TABLE IF EXISTS tmp_Shop_Product_Category;
DROP TABLE IF EXISTS tmp_Shop_Product;
DROP TABLE IF EXISTS tmp_Shop_Image;
END //
DELIMITER ;;

285
static/MySQL/deprecated/7000_p_shop_get_many_user_order.sql
View File

@@ -1,285 +0,0 @@
/*
CALL p_shop_get_many_user_order (
'',
'',
1,
''
)
*/
-- Clear previous proc
DROP PROCEDURE IF EXISTS p_shop_get_many_user_order;
DELIMITER //
CREATE PROCEDURE p_shop_get_many_user_order (
IN a_id_user INT,
IN a_ids_order VARCHAR(4000),
IN a_n_order_max INT,
IN a_id_checkout_session VARCHAR(200)
)
BEGIN
-- Argument redeclaration
-- Variable declaration
DECLARE v_has_filter_user BIT;
DECLARE v_has_filter_order BIT;
DECLARE v_has_filter_session BIT;
DECLARE v_code_error_data VARCHAR(200);
DECLARE v_code_error_permission VARCHAR(200);
DECLARE v_guid BINARY(36);
SET v_code_error_data := (SELECT code FROM Shop_Msg_Error_Type WHERE id_type = 1);
SET v_code_error_permission := (SELECT code FROM Shop_Msg_Error_Type WHERE id_type = 2);
SET v_guid = UUID();
-- 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_order IS NULL THEN
SET a_ids_order = '';
ELSE
SET a_ids_order = TRIM(a_ids_order);
END IF;
IF a_n_order_max IS NULL THEN
SET a_n_order_max = 1;
END IF;
IF a_id_checkout_session IS NULL THEN
SET a_id_checkout_session = '';
ELSE
SET a_id_checkout_session = TRIM(a_id_checkout_session);
END IF;
-- Temporary tables
DROP TABLE IF EXISTS tmp_Shop_User;
DROP TABLE IF EXISTS tmp_Shop_Order;
CREATE TABLE tmp_Shop_User(
id_user INT NOT NULL PRIMARY KEY,
CONSTRAINT FK_tmp_Shop_User_id_user
FOREIGN KEY (id_user)
REFERENCES Shop_User(id_user),
active BIT NOT NULL
);
CREATE TABLE tmp_Shop_Order (
id_order INT NOT NULL PRIMARY KEY,
CONSTRAINT FK_tmp_Shop_Order_id_order
FOREIGN KEY (id_order)
REFERENCES Shop_User_Order(id_order),
active BIT NOT NULL
);
CREATE TABLE IF NOT EXISTS tmp_Msg_Error (
display_order INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
guid BINARY(36) NOT NULL,
# id_type INT NOT NULL,
# CONSTRAINT FK_tmp_Msg_Error_id_type FOREIGN KEY (id_type)
# REFERENCES Shop_Msg_Error_Type (id_type),
code VARCHAR(50),
msg VARCHAR(4000) NOT NULL
);
-- Parse filters
SET v_has_filter_user = CASE WHEN a_id_user = '' THEN 0 ELSE 1 END;
SET a_ids_order = REPLACE(a_ids_order, '|', ',');
SET v_has_filter_order = CASE WHEN a_ids_order = '' THEN 0 ELSE 1 END;
SET v_has_filter_session = CASE WHEN a_id_checkout_session = '' THEN 0 ELSE 1 END;
-- User
IF NOT EXISTS (SELECT * FROM tmp_Msg_Error LIMIT 1) THEN
IF v_has_filter_user THEN
INSERT INTO tmp_Shop_User (
id_user,
active
)
SELECT id_user,
active
FROM Shop_User
WHERE id_user LIKE CONCAT('%', a_id_user, '%')
AND active
LIMIT 1
;
SET v_has_filter_user = EXISTS (SELECT id_user FROM tmp_Shop_User LIMIT 1);
SET a_id_user := (SELECT id_user FROM tmp_Shop_User LIMIT 1);
END IF;
END IF;
IF NOT v_has_filter_user THEN
INSERT INTO tmp_Msg_Error (
guid,
code,
msg
)
VALUES (
v_guid,
v_code_error_data,
'User ID not valid.'
)
;
END IF;
-- Permissions
IF NOT EXISTS (SELECT * FROM tmp_Msg_Error WHERE guid = v_guid LIMIT 1) THEN
CALL p_shop_user_eval (
v_guid, # a_guid
a_id_user, # a_id_user
0, # a_get_inactive_users
CONVERT((SELECT id_permission FROM Shop_Permission WHERE 'STORE_USER' = code), CHAR), # a_ids_permission
(SELECT id_access_level FROM Shop_Access_Level WHERE code = 'VIEW' AND active), # a_ids_access_level
'', # a_ids_product
'' # a_ids_permutation
);
IF NOT (SELECT can_edit FROM Shop_User_Eval_Temp WHERE guid = v_guid) THEN
INSERT INTO tmp_Msg_Error (
guid,
code,
msg
)
VALUES (
v_guid,
v_code_error_permission,
'User ID does not have permission to access orders.'
)
;
END IF;
DELETE FROM Shop_User_Eval_Temp
WHERE guid = v_guid
;
END IF;
-- Invalid Orders
IF NOT EXISTS (SELECT * FROM tmp_Msg_Error WHERE guid = v_guid LIMIT 1) THEN
# Invalid Order IDs
IF EXISTS (SELECT * FROM Shop_User_Order WHERE NOT (id_user = a_id_user) AND v_has_filter_order AND FIND_IN_SET(id_order, a_ids_order) > 0) THEN # id_order LIKE CONCAT('%', a_ids_order, '%') LIMIT 1) THEN
INSERT INTO tmp_Msg_Error (
guid,
code,
msg
)
VALUES (
v_guid,
v_code_error_data,
CONCAT('You do not have access to the following order IDs: ', (SELECT GROUP_CONCAT(id_order SEPARATOR ', ') FROM Shop_User_Order WHERE NOT (id_user = a_id_user) AND FIND_IN_SET(id_order, a_ids_order) > 0)) # id_order LIKE CONCAT('%', a_ids_order, '%'))) # AND v_has_filter_order # filtered by parent condition
)
;
END IF;
# Invalid Checkout Session IDs
IF EXISTS (SELECT * FROM Shop_User_Order WHERE NOT (id_user = a_id_user) AND v_has_filter_session AND id_checkout_session = a_id_checkout_session) THEN
INSERT INTO tmp_Msg_Error (
guid,
code,
msg
)
VALUES (
v_guid,
v_code_error_data,
CONCAT('You do not have access to the following checkout session IDs: ', (SELECT GROUP_CONCAT(id_order SEPARATOR ', ') FROM Shop_User_Order WHERE NOT (id_user = a_id_user) AND id_checkout_session = a_id_checkout_session)) # AND v_has_filter_order # filtered by parent condition
)
;
END IF;
END IF;
-- Valid Orders
IF NOT EXISTS (SELECT * FROM tmp_Msg_Error WHERE guid = v_guid LIMIT 1) THEN
INSERT INTO tmp_Shop_Order (
id_order,
active
)
SELECT UO.id_order,
UO.active
FROM Shop_User_Order UO
INNER JOIN tmp_Shop_User t_U
ON UO.id_user = t_U.id_user
AND t_U.active
WHERE ((NOT v_has_filter_order OR FIND_IN_SET(UO.id_order, a_ids_order) > 0) # UO.id_order LIKE CONCAT('%', a_ids_order, '%'))
OR (NOT v_has_filter_session OR UO.id_checkout_session = a_id_checkout_session))
AND UO.active
;
END IF;
-- Returns
/*
SELECT *
FROM tmp_Shop_User
;
*/
SELECT t_O.id_order,
UOPL.id_product,
UOPL.id_permutation,
UOPL.quantity
FROM tmp_Shop_Order t_O
INNER JOIN Shop_User_Order UO
ON t_O.id_order = UO.id_order
INNER JOIN Shop_User_Order_Product_Link UOPL
ON UO.id_order = UOPL.id_order
WHERE t_O.active
;
# Errors
SELECT *
FROM tmp_Msg_Error
WHERE guid = v_guid
;
/*
# Return arguments for test
SELECT
a_id_user,
a_ids_order,
a_n_order_max,
a_id_checkout_session
;
*/
-- Clean up
DROP TABLE IF EXISTS tmp_Shop_User;
DROP TABLE IF EXISTS tmp_Shop_Order;
END //
DELIMITER ;;
/*
CALL p_shop_get_many_user_order (
'auth0|6582b95c895d09a70ba10fef',
'1',
0,
''
);
CALL p_shop_get_many_user_order (
'',
'1',
0,
''
);
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
select * from shop_User;
select * from shop_User_oRDER;
*/

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

@@ -1,657 +0,0 @@
/*
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 INT,
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 BINARY(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_Product_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 BINARY(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_Product_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_interval_recurrence,
RI.name_plural AS name_plural_interval_recurrence,
P.count_interval_recurrence
FROM tmp_Shop_Product t_P
INNER JOIN Shop_Product P
ON t_P.id_product = P.id_product
LEFT JOIN Shop_Interval_Recurrence RI
ON P.id_unit_measurement_interval_recurrence = 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_interval_recurrence,
RI.name_plural AS name_plural_interval_recurrence,
P.count_interval_recurrence
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_Interval_Recurrence RI
ON P.id_unit_measurement_interval_recurrence = 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
*/

83
static/MySQL/deprecated/9020_edit_permissions.sql
View File

@@ -1,83 +0,0 @@
SELECT URL.id_link,
URL.id_user,
U.name AS name,
URL.id_role,
R.name AS role
FROM Shop_User_Role_Link URL
INNER JOIN Shop_User U
ON URL.id_user = U.id_user
INNER JOIN Shop_Role R
ON URL.id_role = R.id_role
;
SELECT *
FROM Shop_Role_Permission_Link
;
SELECT *
FROM Shop_Access_Level
;
SELECT *
FROM Shop_Permission
;
SELECT *
FROM Shop_Access_Level
;
select * from shop_user;
select * from shop_user_audit;
select * from Shop_User_Change_Set;
/*
INSERT INTO Shop_User_Change_Set ( comment )
VALUES ('Demotion');
*/
UPDATE Shop_User
SET is_super_user = 0,
id_change_set = (SELECT id_change_set FROM Shop_User_Change_Set LIMIT 1)
WHERE id_user = 1
;
select * from shop_user;
select * from shop_user_audit;
drop procedure if exists p_test;
delimiter //
create procedure p_test ()
begin
declare b0 int;
declare b1 int;
SET b0 = 0;
SET b1 = 1;
select b0, b1;
select cast(b0 as char), cast(b1 as char);
select cast(b0 as char character set utf8), cast(b1 as char character set utf8);
select convert(b0, char), convert(b1, char);
select convert(b0, char character set utf8), convert(b1, char character set utf8);
select convert(convert(b0, signed), char), convert(convert(b1, signed), char);
select convert(convert(b0, signed), char character set utf8), convert(convert(b1, signed), char character set utf8);
end //
delimiter ;
call p_test();
drop procedure if exists p_test;
INSERT INTO Shop_User_Audit (
id_user,
name_field,
value_prev,
value_new,
id_change_set
)
SELECT id_user, name_field, value_prev, value_new, id_change_set
FROM Shop_User_Audit
WHERE id_audit = 1
UNION
SELECT id_user, name_field, value_prev, value_new, id_change_set
FROM Shop_User_Audit
WHERE id_audit = 1
;
select * from shop_user_audit;
SELECT * FROM Shop_Access_Level;
SELECT * FROM Shop_Product;

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff