AppStd/SqlScripts
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
SqlScripts/00_DB_SETUP_SINGLE/01_IDB/CreateDBObjects.sql
SchreiberM ecafe27e3a ms
2023-04-14 10:32:31 +02:00

6371 lines
237 KiB
Transact-SQL
Raw Blame History

--REPLACE @MY_DD_ECM_DB WITH REAL_DBNAME
USE IDB
GO
ALTER TABLE DD_ECM.dbo.TBDD_DOKUMENTART
ADD IDB_DOCTYPE_ID INT NOT NULL DEFAULT 0;
GO
CREATE TABLE TBIDB_DOCTYPE
(
GUID INT NOT NULL IDENTITY (1, 1),
TITLE VARCHAR(100) NOT NULL,
COMMENT VARCHAR(500),
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'Systm',
ADDED_WHEN DATETIME DEFAULT GETDATE(),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_DOCTYPES PRIMARY KEY (GUID),
CONSTRAINT UN_TBIDB_DOCTYPES UNIQUE(TITLE))
GO
CREATE TRIGGER TBIDB_DOCTYPE_AFT_UPD ON TBIDB_DOCTYPE
FOR UPDATE
AS
UPDATE TBIDB_DOCTYPE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_DOCTYPE.GUID = INSERTED.GUID
GO
INSERT INTO TBIDB_DOCTYPE (TITLE) VALUES ('Ausgangsrechnung');
INSERT INTO TBIDB_DOCTYPE (TITLE) VALUES ('Eingangsrechnung');
INSERT INTO TBIDB_DOCTYPE (TITLE) VALUES ('Gutschrift');
INSERT INTO TBIDB_DOCTYPE (TITLE) VALUES ('Quittung');
--DROP TABLE TBIDB_CATALOG
CREATE TABLE TBIDB_CATALOG
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
CAT_TITLE VARCHAR(100) NOT NULL,
CAT_STRING VARCHAR(900) NOT NULL,
ADDED_WHO VARCHAR(30) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(30),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_CATALOG PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_CATALOG_TITLE UNIQUE (CAT_TITLE)
)
GO
CREATE TABLE TBIDB_CATALOG_USER
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
USR_ID INTEGER NOT NULL,
CAT_TITLE VARCHAR(100) NOT NULL,
CAT_STRING VARCHAR(900) NOT NULL,
ADDED_WHO VARCHAR(30) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(30),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_CATALOG_USER PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_CATALOG_USER UNIQUE (USR_ID,CAT_TITLE)
)
GO
CREATE TRIGGER TBIDB_CATALOG_USER_AFT_UPD ON TBIDB_CATALOG_USER
FOR UPDATE
AS
UPDATE TBIDB_CATALOG_USER SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_CATALOG_USER.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_ACTION_OBJECT
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
TITLE VARCHAR(100) NOT NULL,
ADDED_WHO VARCHAR(30) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(30),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_ACTION_OBJECT PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_ACTION_OBJECT UNIQUE (TITLE)
)
GO
CREATE TRIGGER TBIDB_ACTION_OBJECT_AFT_UPD ON TBIDB_ACTION_OBJECT
FOR UPDATE
AS
UPDATE TBIDB_ACTION_OBJECT SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_ACTION_OBJECT.GUID = INSERTED.GUID
GO
INSERT INTO TBIDB_ACTION_OBJECT (TITLE) VALUES ('NEW_FILE');
CREATE TABLE TBIDB_ACTION_STEPS
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
TITLE_DESC VARCHAR(500) NOT NULL,
ACTION_ID INTEGER NOT NULL,
CRITERIA_DESC VARCHAR(100) NOT NULL,
PARAM1 VARCHAR(500) NOT NULL,
OPERATOR VARCHAR(100) NOT NULL,
PARAM2 VARCHAR(500) NOT NULL,
TASK VARCHAR(100) NOT NULL,
SQL1 NVARCHAR(MAX) NOT NULL,
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_ACTION_STEPS PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_ACTION_STEPS UNIQUE (ACTION_ID,PARAM1,OPERATOR,PARAM2),
CONSTRAINT FK_TBIDB_ACTION_STEPS_ACTID FOREIGN KEY (ACTION_ID) REFERENCES TBIDB_ACTION_OBJECT (GUID),
)
GO
CREATE TRIGGER TBIDB_ACTION_STEPS_AFT_UPD ON TBIDB_ACTION_STEPS
FOR UPDATE
AS
UPDATE TBIDB_ACTION_STEPS SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_ACTION_STEPS.GUID = INSERTED.GUID
GO
INSERT INTO TBIDB_CATALOG (CAT_TITLE,CAT_STRING) VALUES ('DB_VERSION','1.0.4.1')
GO
INSERT INTO TBIDB_CATALOG (CAT_TITLE,CAT_STRING) VALUES ('FILESTORE_PRAEFIX','\\IDB\OBJECTS')
GO
INSERT INTO TBIDB_CATALOG (CAT_TITLE,CAT_STRING) VALUES ('DOCTYPE_CHANGED','AUTO REPLACE')
GO
INSERT INTO TBIDB_CATALOG (CAT_TITLE,CAT_STRING) VALUES ('DOCTYPE_CHANGED1','QUESTION VERSION')
GO
INSERT INTO TBIDB_CATALOG (CAT_TITLE,CAT_STRING) VALUES ('DOCTYPE_CHANGED2','AUTO VERSION')
GO
INSERT INTO TBIDB_CATALOG (CAT_TITLE,CAT_STRING) VALUES ('FULLTEXT_OCR','EXTRACTED FULLTEXT')
GO
INSERT INTO TBIDB_CATALOG (CAT_TITLE,CAT_STRING) VALUES ('FULLTEXT_MANUAL1','MANUAL FULLTEXT1')
GO
INSERT INTO TBIDB_CATALOG (CAT_TITLE,CAT_STRING) VALUES ('FULLTEXT_MANUAL2','MANUAL FULLTEXT2')
GO
--INSERT INTO [TBIDB_CATALOG] ([CAT_TITLE],[CAT_STRING]) VALUES ('APPSERV1','172.24.12.39')
--GO
INSERT INTO TBIDB_CATALOG (CAT_TITLE,CAT_STRING) VALUES ('GHOST_SELECT','
SELECT T.USERNAME,T.NAME, T.[PRENAME],T.EMAIL FROM @MY_DD_ECM_DB.dbo.TBDD_USER T ORDER BY USERNAME')
GO
INSERT INTO TBIDB_CATALOG (CAT_TITLE,CAT_STRING) VALUES ('AD_GROUP_ADMIN1','NONE')
GO
CREATE TRIGGER TBIDB_CATALOG_AFT_UPD ON TBIDB_CATALOG
FOR UPDATE
AS
UPDATE TBIDB_CATALOG SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_CATALOG.GUID = INSERTED.GUID
GO
--DROP TABLE TBIDB_BUSINESS_ENTITY
CREATE TABLE TBIDB_BUSINESS_ENTITY
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
TITLE VARCHAR(500) NOT NULL,
PARENT_ENT_ID INTEGER NOT NULL DEFAULT 0,
INHERITS_ATTRIBUTES BIT NOT NULL DEFAULT 1,
COMMENT VARCHAR(1000),
ADDED_WHO VARCHAR(30) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(30),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_BUSINESS_ENTITY PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_BUSINESS_ENTITY UNIQUE (TITLE)
)
GO
CREATE TRIGGER TBIDB_BUSINESS_ENTITY_AFT_UPD ON TBIDB_BUSINESS_ENTITY
FOR UPDATE
AS
UPDATE TBIDB_BUSINESS_ENTITY SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_BUSINESS_ENTITY.GUID = INSERTED.GUID
GO
INSERT INTO TBIDB_BUSINESS_ENTITY (TITLE) VALUES ('DEFAULT');
--DROP TABLE TBIDB_OBJECT_STORE
CREATE TABLE TBIDB_OBJECT_STORE
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
OBJECT_TITLE VARCHAR(250) NOT NULL,
CAT_ID INTEGER NOT NULL,
OBJ_PATH VARCHAR(250) NOT NULL,
IS_ARCHIVE BIT NOT NULL DEFAULT 0,
COMMENT VARCHAR(500),
ADDED_WHO VARCHAR(30) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(30),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_OBJECT_STORE PRIMARY KEY (GUID),
CONSTRAINT FK_OS_CAT_ID FOREIGN KEY (CAT_ID) REFERENCES TBIDB_CATALOG (GUID) ,
CONSTRAINT UQ1_TBIDB_OBJECT_STORE UNIQUE (OBJECT_TITLE),
CONSTRAINT UQ2_TBIDB_OBJECT_STORE UNIQUE (OBJ_PATH)
)
GO
CREATE TRIGGER TBIDB_OBJECT_STORE_AFT_UPD ON TBIDB_OBJECT_STORE
FOR UPDATE
AS
UPDATE TBIDB_OBJECT_STORE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_OBJECT_STORE.GUID = INSERTED.GUID
GO
--DROP TABLE TBIDB_DOCTYPE_OBJECT_STORE
CREATE TABLE TBIDB_DOCTYPE_OBJECT_STORE
(
GUID INT NOT NULL IDENTITY (1, 1),
DOCTYPE_ID INT NOT NULL,
OBJECT_ST_ID INT NOT NULL,
ACTIVE BIT NOT NULL DEFAULT 1,
COMMENT VARCHAR(1000),
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'System',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_DOCTYPE_OBJECT_STORE PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_DOCTYPE_OBJECT_STORE UNIQUE (DOCTYPE_ID,OBJECT_ST_ID),
CONSTRAINT FK_TBIDB_DOCTYPE_OBJECT_STORE_DTID FOREIGN KEY (DOCTYPE_ID) REFERENCES TBIDB_DOCTYPE (GUID),
CONSTRAINT FK_TBIDB_DOCTYPE_OBJECT_STORE_OSTID FOREIGN KEY (OBJECT_ST_ID) REFERENCES TBIDB_OBJECT_STORE (GUID)
)
GO
CREATE TRIGGER TBIDB_DOCTYPE_OBJECT_STORE_AFT_UPD ON TBIDB_DOCTYPE_OBJECT_STORE
FOR UPDATE
AS
UPDATE TBIDB_DOCTYPE_OBJECT_STORE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_DOCTYPE_OBJECT_STORE.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_DOCTYPE_BE
(
GUID INT NOT NULL IDENTITY (1, 1),
DOCTYPE_ID INT NOT NULL,
BE_ID INT NOT NULL,
ACTIVE BIT NOT NULL DEFAULT 1,
COMMENT VARCHAR(1000),
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'System',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_DOCTYPE_BE PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_DOCTYPE_BE_STORE UNIQUE (DOCTYPE_ID,BE_ID),
CONSTRAINT FK_TBIDB_DOCTYPE_BE_DTID FOREIGN KEY (DOCTYPE_ID) REFERENCES TBIDB_DOCTYPE (GUID),
CONSTRAINT FK_TBIDB_DOCTYPE_BE_BE_ID FOREIGN KEY (BE_ID) REFERENCES TBIDB_BUSINESS_ENTITY (GUID)
)
GO
CREATE TRIGGER TBIDB_DOCTYPE_BE_AFT_UPD ON TBIDB_DOCTYPE_BE
FOR UPDATE
AS
UPDATE TBIDB_DOCTYPE_BE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_DOCTYPE_BE.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_DOCTYPE_HANDLING
(
GUID INT NOT NULL IDENTITY (1, 1),
DOCTYPE VARCHAR(100) NOT NULL,
CHANGED_ACTION INT NOT NULL,
ACTIVE BIT NOT NULL DEFAULT 1,
COMMENT VARCHAR(1000),
ADDED_WHO VARCHAR(30) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(30),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_DOCTYPE_HANDLING PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_DOCTYPE_HANDLING UNIQUE (DOCTYPE),
CONSTRAINT FK_TBIDB_DOCTYPE_HANDLING_CHNGACT FOREIGN KEY (CHANGED_ACTION) REFERENCES TBIDB_CATALOG (GUID)
)
GO
CREATE TRIGGER TBIDB_DOCTYPE_HANDLING_AFT_UPD ON TBIDB_DOCTYPE_HANDLING
FOR UPDATE
AS
UPDATE TBIDB_DOCTYPE_HANDLING SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_DOCTYPE_HANDLING.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_TERM_VALUE_VARCHAR
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
TERM_VALUE VARCHAR(900) NOT NULL,
TERM_VALUE_REVERSE VARCHAR(900),
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_TERM_VALUE_VARCHAR PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_TERM_VALUE_VARCHAR UNIQUE (TERM_VALUE),
CONSTRAINT UQ_TBIDB_TERM_VALUE_VARCHAR_REV UNIQUE (TERM_VALUE_REVERSE)
)
GO
CREATE TRIGGER TBIDB_TERM_VALUE_VARCHAR_AFT_UPD ON TBIDB_TERM_VALUE_VARCHAR
FOR UPDATE
AS
UPDATE TBIDB_TERM_VALUE_VARCHAR SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_TERM_VALUE_VARCHAR.GUID = INSERTED.GUID
GO
CREATE TRIGGER [dbo].[TBIDB_TERM_VALUE_VARCHAR_AFT_INS] ON [dbo].[TBIDB_TERM_VALUE_VARCHAR]
FOR INSERT
AS
UPDATE TBIDB_TERM_VALUE_VARCHAR SET TBIDB_TERM_VALUE_VARCHAR.TERM_VALUE_REVERSE = REVERSE(INSERTED.TERM_VALUE)
FROM INSERTED
WHERE TBIDB_TERM_VALUE_VARCHAR.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_TERM_VALUE_INTEGER
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
TERM_VALUE BIGINT NOT NULL,
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_TERM_VALUE_INTEGER PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_TERM_VALUE_INTEGER UNIQUE (TERM_VALUE)
)
GO
CREATE TRIGGER TBIDB_TERM_VALUE_INTEGER_AFT_UPD ON TBIDB_TERM_VALUE_INTEGER
FOR UPDATE
AS
UPDATE TBIDB_TERM_VALUE_INTEGER SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_TERM_VALUE_INTEGER.GUID = INSERTED.GUID
GO
INSERT INTO TBIDB_TERM_VALUE_INTEGER (TERM_VALUE) VALUES (0);
INSERT INTO TBIDB_TERM_VALUE_INTEGER (TERM_VALUE) VALUES (1);
CREATE TABLE TBIDB_TERM_VALUE_FLOAT
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
TERM_VALUE FLOAT NOT NULL,
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_TERM_VALUE_FLOAT PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_TERM_VALUE_FLOAT UNIQUE (TERM_VALUE)
)
GO
CREATE TRIGGER TBIDB_TERM_VALUE_FLOAT_AFT_UPD ON TBIDB_TERM_VALUE_FLOAT
FOR UPDATE
AS
UPDATE TBIDB_TERM_VALUE_FLOAT SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_TERM_VALUE_FLOAT.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_TERM_VALUE_DECIMAL
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
TERM_VALUE DECIMAL(19, 0) NOT NULL,
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_TERM_VALUE_DECIMAL PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_TERM_VALUE_DECIMAL UNIQUE (TERM_VALUE)
)
GO
CREATE TRIGGER TBIDB_TERM_VALUE_DECIMAL_AFT_UPD ON TBIDB_TERM_VALUE_DECIMAL
FOR UPDATE
AS
UPDATE TBIDB_TERM_VALUE_DECIMAL SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_TERM_VALUE_DECIMAL.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_TERM_VALUE_DATE
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
TERM_VALUE DATE NOT NULL,
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_TERM_VALUE_DATE PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_TERM_VALUE_DATE UNIQUE (TERM_VALUE)
)
GO
CREATE TRIGGER TBIDB_TERM_VALUE_DATE_AFT_UPD ON TBIDB_TERM_VALUE_DATE
FOR UPDATE
AS
UPDATE TBIDB_TERM_VALUE_DATE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_TERM_VALUE_DATE.GUID = INSERTED.GUID
GO
--DELETE FROM TBIDB_OBJECT_METADATA
--DELETE FROM TBIDB_LANGUAGE_TERM_METADATA
--DELETE FROM TBIDB_FILE_OBJECT
--DELETE FROM TBIDB_OBJECT_BE
--DELETE FROM TBIDB_OBJECT_METADATA_CHANGE
--DELETE FROM TBIDB_OBJECT
--DROP TABLE TBIDB_TERM_VALUE_DATETIME
CREATE TABLE TBIDB_TERM_VALUE_DATETIME
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
TERM_VALUE DATETIME NOT NULL,
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_TERM_VALUE_DATETIME PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_TERM_VALUE_DATETIME UNIQUE (TERM_VALUE)
)
GO
CREATE TRIGGER TBIDB_TERM_VALUE_DATETIME_UPD ON TBIDB_TERM_VALUE_DATETIME
FOR UPDATE
AS
UPDATE TBIDB_TERM_VALUE_DATETIME SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_TERM_VALUE_DATETIME.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_FULLTEXT_OBJECT
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
OBJECT_ID BIGINT NOT NULL,
FULL_TEXT NVARCHAR(MAX) NOT NULL,
CAT_ID INTEGER NOT NULL,
ADDED_WHO BIGINT,
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
CHANGED_WHO BIGINT,
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_FULLTEXT_OBJECT PRIMARY KEY (GUID),
CONSTRAINT UN_TBIDB_FULLTEXT_OBJECT UNIQUE(OBJECT_ID,CAT_ID),
CONSTRAINT FK_TBIDB_FULLTEXT_OBJECT_CAT_ID FOREIGN KEY (CAT_ID) REFERENCES TBIDB_CATALOG (GUID),
CONSTRAINT FK_TBIDB_FULLTEXT_OBJECT_ADDED_WHO_T_ID FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT FK_TBIDB_FULLTEXT_OBJECT_CHANGED_WHO_T_ID FOREIGN KEY (CHANGED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),)
GO
CREATE TRIGGER TBIDB_FULLTEXT_OBJECT_AFT_UPD ON TBIDB_FULLTEXT_OBJECT
FOR UPDATE
AS
UPDATE TBIDB_FULLTEXT_OBJECT SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_FULLTEXT_OBJECT.GUID = INSERTED.GUID
GO
--DROP TABLE TBIDB_ATTRIBUTE_TYPE
CREATE TABLE TBIDB_ATTRIBUTE_TYPE
(
GUID TINYINT NOT NULL IDENTITY (1, 1),
NAME_TYPE VARCHAR(100) NOT NULL,
COMMENT VARCHAR(500),
BIT1 BIT NOT NULL DEFAULT 0,
BIT2 BIT NOT NULL DEFAULT 0,
BIT3 BIT NOT NULL DEFAULT 0,
BIT4 BIT NOT NULL DEFAULT 0,
DELETED BIT NOT NULL DEFAULT 0,
DELETED_WHO VARCHAR(100),
DELETED_WHEN DATETIME,
ADDED_WHO VARCHAR(30) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(30),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_ATTRIBUTE_TYPE PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_ATTRIBUTE_TYPE UNIQUE (NAME_TYPE)
)
GO
CREATE TRIGGER TBIDB_ATTRIBUTE_TYPE_AFT_UPD ON TBIDB_ATTRIBUTE_TYPE
FOR UPDATE
AS
UPDATE TBIDB_ATTRIBUTE_TYPE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_ATTRIBUTE_TYPE.GUID = INSERTED.GUID
GO
INSERT INTO TBIDB_ATTRIBUTE_TYPE (NAME_TYPE) VALUES ('VARCHAR'); --1
INSERT INTO TBIDB_ATTRIBUTE_TYPE (NAME_TYPE) VALUES ('BIG INTEGER');--2
INSERT INTO TBIDB_ATTRIBUTE_TYPE (NAME_TYPE) VALUES ('FLOAT');--3
INSERT INTO TBIDB_ATTRIBUTE_TYPE (NAME_TYPE) VALUES ('DECIMAL');--4
INSERT INTO TBIDB_ATTRIBUTE_TYPE (NAME_TYPE) VALUES ('DATE');--5
INSERT INTO TBIDB_ATTRIBUTE_TYPE (NAME_TYPE) VALUES ('DATETIME');--6
INSERT INTO TBIDB_ATTRIBUTE_TYPE (NAME_TYPE) VALUES ('BIT');--7
INSERT INTO TBIDB_ATTRIBUTE_TYPE (NAME_TYPE) VALUES ('VECTOR STRING');--8
INSERT INTO TBIDB_ATTRIBUTE_TYPE (NAME_TYPE) VALUES ('VECTOR INTEGER');--9
--DROP TABLE TBIDB_OBJECT_KIND
CREATE TABLE TBIDB_OBJECT_KIND
(
GUID TINYINT NOT NULL IDENTITY (1, 1),
KIND_NAME VARCHAR(100) NOT NULL,
ADDED_WHO VARCHAR(30) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(30),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_OBJECT_KIND PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_OBJECT_KIND UNIQUE (KIND_NAME)
)
GO
INSERT INTO TBIDB_OBJECT_KIND (KIND_NAME) VALUES ('DOC');
INSERT INTO TBIDB_OBJECT_KIND (KIND_NAME) VALUES ('OBJECT');
INSERT INTO TBIDB_OBJECT_KIND (KIND_NAME) VALUES ('DYNAMIC_FOLDER');
GO
CREATE TRIGGER TBIDB_OBJECT_KIND_AFT_UPD ON TBIDB_OBJECT_KIND
FOR UPDATE
AS
UPDATE TBIDB_OBJECT_KIND SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_OBJECT_KIND.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_LANGUAGE
(
GUID TINYINT NOT NULL IDENTITY (1, 1),
LANG_CODE VARCHAR(10) NOT NULL,
CREATE_DEFAULT_ENTRY BIT NOT NULL DEFAULT 0,
COMMENT VARCHAR(1000),
ADDED_WHO VARCHAR(30) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(30),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_LANGUAGE PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_LANGUAGE UNIQUE (LANG_CODE)
)
GO
CREATE TRIGGER TBIDB_LANGUAGE_AFT_UPD ON TBIDB_LANGUAGE
FOR UPDATE
AS
UPDATE TBIDB_LANGUAGE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_LANGUAGE.GUID = INSERTED.GUID
GO
INSERT INTO TBIDB_LANGUAGE (LANG_CODE,CREATE_DEFAULT_ENTRY) VALUES ('de-DE',1);
INSERT INTO TBIDB_LANGUAGE (LANG_CODE,CREATE_DEFAULT_ENTRY) VALUES ('en-EN',1);
GO
--DROP TABLE TBIDB_OBJECT_BE
--DROP TABLE TBIDB_OBJECT
CREATE TABLE TBIDB_OBJECT
(
IDB_OBJ_ID BIGINT NOT NULL IDENTITY (1000000, 1),
KIND_TYPE_ID TINYINT NOT NULL,
REFERENCE_KEY BIGINT,
PARENT_OBJ_ID BIGINT NOT NULL DEFAULT 0,
IS_VERSION BIT NOT NULL DEFAULT 0,
ACTIVE BIT NOT NULL DEFAULT 1,
DELETED BIT NOT NULL DEFAULT 0,
COMMENT VARCHAR(1000),
ADDED_WHO VARCHAR(30) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(30),
CHANGED_WHEN DATETIME,
CHANGED_WHEN_SUBSTRUCTURE DATETIME,
CHANGED_WHO_SUBSTRUCTURE VARCHAR(100),
CONSTRAINT PK_TBIDB_OBJECT PRIMARY KEY (IDB_OBJ_ID),
CONSTRAINT FK_KIND_TYPE_ID FOREIGN KEY (KIND_TYPE_ID) REFERENCES TBIDB_OBJECT_KIND (GUID)
)
GO
CREATE TRIGGER TBIDB_OBJECT_AFT_INS ON TBIDB_OBJECT
WITH EXECUTE AS CALLER
FOR INSERT
AS
BEGIN TRY
DECLARE
@IDB_OBJ_ID BIGINT,
@REFERENCE_KEY BIGINT
SELECT
@IDB_OBJ_ID = IDB_OBJ_ID,
@REFERENCE_KEY = REFERENCE_KEY
FROM INSERTED
IF @REFERENCE_KEY IS NULL
UPDATE TBIDB_OBJECT SET REFERENCE_KEY = @IDB_OBJ_ID
FROM INSERTED
WHERE TBIDB_OBJECT.IDB_OBJ_ID = INSERTED.IDB_OBJ_ID
END TRY
BEGIN CATCH
PRINT 'ERROR IN TRIGGER: ' + CONVERT(VARCHAR(30),ERROR_PROCEDURE())
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
END CATCH
GO
CREATE TRIGGER [dbo].[TBIDB_OBJECT_AFT_UPD] ON [dbo].[TBIDB_OBJECT]
FOR UPDATE
AS
IF UPDATE(REFERENCE_KEY) OR UPDATE(PARENT_OBJ_ID) OR UPDATE(IS_VERSION) OR UPDATE(ACTIVE) OR UPDATE(DELETED) OR UPDATE(COMMENT)
UPDATE TBIDB_OBJECT SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_OBJECT.IDB_OBJ_ID = INSERTED.IDB_OBJ_ID
GO
CREATE TABLE TBIDB_STRUCTURE_TYPE
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
TITLE VARCHAR(100) NOT NULL,
COMMENT VARCHAR(1000),
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_STRUCTURE_TYPE PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_STRUCTURE_TYPE UNIQUE (TITLE)
)
GO
CREATE TRIGGER TBIDB_STRUCTURE_TYPE_AFT_UPD ON TBIDB_STRUCTURE_TYPE
FOR UPDATE
AS
UPDATE TBIDB_STRUCTURE_TYPE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_STRUCTURE_TYPE.GUID = INSERTED.GUID
GO
INSERT INTO TBIDB_STRUCTURE_TYPE (TITLE) VALUES ('DOC_DOCTYPE');
GO
CREATE TABLE TBIDB_OBJECT_STRUCTURE_TYPE
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
IDB_OBJ_ID BIGINT NOT NULL,
STRUCTURE_ID INTEGER NOT NULL,
RELATION_ID INTEGER NOT NULL,
COMMENT VARCHAR(1000),
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_OBJ_STRUCTURE_TYPE PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_OBJ_STRUCTURE_TYPE UNIQUE (IDB_OBJ_ID,STRUCTURE_ID),
CONSTRAINT FK_TBIDB_OBJ_STRUCTURE_TYPE_IDBOBJID FOREIGN KEY (IDB_OBJ_ID) REFERENCES TBIDB_OBJECT (IDB_OBJ_ID),
CONSTRAINT FK_TBIDB_OBJ_STRUCTURE_TYPE_STRIID FOREIGN KEY (STRUCTURE_ID) REFERENCES TBIDB_STRUCTURE_TYPE (GUID)
)
GO
CREATE TRIGGER TBIDB_OBJECT_STRUCTURE_TYPE_AFT_UPD ON TBIDB_OBJECT_STRUCTURE_TYPE
FOR UPDATE
AS
UPDATE TBIDB_OBJECT_STRUCTURE_TYPE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_OBJECT_STRUCTURE_TYPE.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_DOC_INFO
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
IDB_OBJ_ID BIGINT NOT NULL,
OBJ_ST_ID INTEGER NOT NULL,
FILENAME_ONLY VARCHAR(250) NOT NULL,
FILENAME_EXT VARCHAR(250) NOT NULL,
EXTENSION_TERM BIGINT NOT NULL,
RELATIVE_PATH VARCHAR(250) NOT NULL,
RELATIVE_PATH_ONLY_TERM BIGINT NOT NULL,
FULL_TEXT VARBINARY(MAX),
FILE_SIZE INTEGER,
COMMENT VARCHAR(1000),
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_DOC_INFO PRIMARY KEY (GUID),
CONSTRAINT UQ_DI_IDB_OBJ_ID UNIQUE (IDB_OBJ_ID),
CONSTRAINT FK_DI_IDB_OBJ_ST_ID FOREIGN KEY (OBJ_ST_ID) REFERENCES TBIDB_OBJECT_STORE (GUID),
CONSTRAINT FK_DI_IDB_OBJ_ID FOREIGN KEY (IDB_OBJ_ID) REFERENCES TBIDB_OBJECT (IDB_OBJ_ID),
CONSTRAINT FKTBIDB_DOC_INFO_RELATIVEPATHONLYTERM FOREIGN KEY (RELATIVE_PATH_ONLY_TERM) REFERENCES TBIDB_TERM_VALUE_VARCHAR(GUID),
CONSTRAINT FKTBIDB_DOC_INFO_EXTENSIONTERM FOREIGN KEY (EXTENSION_TERM) REFERENCES TBIDB_TERM_VALUE_VARCHAR(GUID)
)
GO
CREATE TRIGGER TBIDB_DOC_INFO_AFT_UPD ON TBIDB_DOC_INFO
FOR UPDATE
AS
UPDATE TBIDB_DOC_INFO SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_DOC_INFO.IDB_OBJ_ID = INSERTED.IDB_OBJ_ID
GO
--DROP TABLE TBIDB_OBJECT_BE
CREATE TABLE TBIDB_OBJECT_BE
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
IDB_OBJ_ID BIGINT NOT NULL,
BE_ID INTEGER NOT NULL,
COMMENT VARCHAR(1000),
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_OBJECT_BE PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_OBJECT_BE UNIQUE (IDB_OBJ_ID,BE_ID),
CONSTRAINT FK_IDB_OBJ_ID FOREIGN KEY (IDB_OBJ_ID) REFERENCES TBIDB_OBJECT (IDB_OBJ_ID),
CONSTRAINT FK_BE_ID FOREIGN KEY (BE_ID) REFERENCES TBIDB_BUSINESS_ENTITY (GUID),
)
GO
CREATE TRIGGER TBIDB_OBJECT_BE_AFT_UPD ON TBIDB_OBJECT_BE
FOR UPDATE
AS
UPDATE TBIDB_OBJECT_BE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_OBJECT_BE.IDB_OBJ_ID = INSERTED.IDB_OBJ_ID
GO
--CREATE TABLE TBIDB_ATTRIBUTE ADD SYS_ATTRIBUTE BIT NOT NULL DEFAULT 0
GO
CREATE TABLE TBIDB_ATTRIBUTE
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
TITLE VARCHAR(100) NOT NULL,
TYP_ID TINYINT NOT NULL,
MULTI_CONTEXT BIT NOT NULL DEFAULT 0,
VIEW_SEQUENCE INTEGER NOT NULL DEFAULT 0,
VIEW_VISIBLE BIT NOT NULL DEFAULT 1,
SYS_ATTRIBUTE BIT NOT NULL DEFAULT 0,
COMMENT VARCHAR(1000),
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
DELETED BIT NOT NULL DEFAULT 0,
DELETED_WHO VARCHAR(100),
DELETED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_ATTRIBUTE PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_ATTRIBUTE UNIQUE (TITLE),
CONSTRAINT FK_TYP_ID FOREIGN KEY (TYP_ID) REFERENCES TBIDB_ATTRIBUTE_TYPE (GUID)
)
GO
CREATE TRIGGER TBIDB_ATTRIBUTE_AFT_UPD ON TBIDB_ATTRIBUTE
FOR UPDATE
AS
UPDATE TBIDB_ATTRIBUTE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_ATTRIBUTE.GUID = INSERTED.GUID
GO
CREATE OR ALTER TRIGGER [dbo].[TBIDB_ATTRIBUTE_AFT_INS] ON [dbo].[TBIDB_ATTRIBUTE]
FOR INSERT
AS
DECLARE
@ATTRIBUTE_ID INTEGER,
@TYP_ID INTEGER,
@ADDED_WHO VARCHAR(50),
@TITLE VARCHAR(100),
@ADD_DEFAULT BIT,
@LANG_ID INTEGER,
@LANG_CODE VARCHAR(5)
SELECT
@ATTRIBUTE_ID = GUID,
@TYP_ID = TYP_ID,
@ADDED_WHO = ADDED_WHO,
@TITLE = TITLE
FROM INSERTED
SELCT
DECLARE @NEW_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@TITLE,'',@TERM_ID = @NEW_TERM_ID OUTPUT;
DECLARE cursorIDBLANGUAGE_ATTR CURSOR FOR
select GUID,LANG_CODE from TBIDB_LANGUAGE where CREATE_DEFAULT_ENTRY = 1
OPEN cursorIDBLANGUAGE_ATTR
FETCH NEXT FROM cursorIDBLANGUAGE_ATTR INTO @LANG_ID,@LANG_CODE
WHILE @@FETCH_STATUS = 0
BEGIN
INSERT INTO [dbo].[TBIDB_ATTRIBUTE_LANGUAGE]
([ATTRIBUTE_ID]
,[LANGUAGE_ID]
,[TERM_ID]
,[ADDED_WHO])
VALUES
(@ATTRIBUTE_ID
,@LANG_ID
,@NEW_TERM_ID
,@ADDED_WHO);
EXEC PRIDB_CREATE_VIEW_DOC_DATA @LANG_CODE,'DEFAULT'
EXEC PRIDB_CREATE_VIEW_DOC_DATA @LANG_CODE,''
FETCH NEXT FROM cursorIDBLANGUAGE_ATTR INTO @LANG_ID,@LANG_CODE
END
CLOSE cursorIDBLANGUAGE_ATTR
DEALLOCATE cursorIDBLANGUAGE_ATTR
GO
CREATE TABLE TBIDB_BE_ATTRIBUTE
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
BE_ID INTEGER NOT NULL,
ATTR_ID INTEGER NOT NULL,
DEFAULT_SEARCH_ATTRIBUTE BIT NOT NULL DEFAULT 0,
COMMENT VARCHAR(1000),
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_BE_ATTRIBUTE PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_BE_ATTRIBUTE UNIQUE (BE_ID,ATTR_ID),
CONSTRAINT FK_IDB_BEATT_BEID FOREIGN KEY (BE_ID) REFERENCES TBIDB_BUSINESS_ENTITY (GUID),
CONSTRAINT FK_IDB_BEATT_AID FOREIGN KEY (ATTR_ID) REFERENCES TBIDB_ATTRIBUTE (GUID),
)
GO
CREATE TRIGGER TBIDB_BE_ATTRIBUTE_AFT_UPD ON TBIDB_BE_ATTRIBUTE
FOR UPDATE
AS
UPDATE TBIDB_BE_ATTRIBUTE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_BE_ATTRIBUTE.GUID = INSERTED.GUID
GO
CREATE OR ALTER TRIGGER [dbo].[TBIDB_BE_ATTRIBUTE_AFT_INS] ON [dbo].[TBIDB_BE_ATTRIBUTE]
FOR INSERT
AS
DECLARE
@ATTRIBUTE_ID INTEGER,
@TYP_ID INTEGER,
@ADDED_WHO VARCHAR(50),
@TITLE VARCHAR(100),
@ADD_DEFAULT BIT,
@LANG_ID INTEGER,
@LANG_CODE VARCHAR(5)
SELECT
@ATTRIBUTE_ID = ATTR_ID
FROM INSERTED
DECLARE c_TBIDB_ATTRIBUTE_AFT_INS CURSOR FOR
select GUID,LANG_CODE from TBIDB_LANGUAGE where CREATE_DEFAULT_ENTRY = 1
OPEN c_TBIDB_ATTRIBUTE_AFT_INS
FETCH NEXT FROM c_TBIDB_ATTRIBUTE_AFT_INS INTO @LANG_ID,@LANG_CODE
WHILE @@FETCH_STATUS = 0
BEGIN
EXEC PRIDB_CREATE_VIEW_DOC_DATA @LANG_CODE,'DEFAULT';
EXEC PRIDB_CREATE_VIEW_DOC_DATA @LANG_CODE,'DOCRESULT';
FETCH NEXT FROM c_TBIDB_ATTRIBUTE_AFT_INS INTO @LANG_ID,@LANG_CODE
END
CLOSE c_TBIDB_ATTRIBUTE_AFT_INS
DEALLOCATE c_TBIDB_ATTRIBUTE_AFT_INS
GO
CREATE OR ALTER TRIGGER [dbo].[TBIDB_BE_ATTRIBUTE_AFT_DEL] ON [dbo].[TBIDB_BE_ATTRIBUTE]
FOR DELETE
AS
DECLARE
@LANG_ID INTEGER,
@LANG_CODE VARCHAR(5)
DECLARE c_TBIDB_ATTRIBUTE_AFT_DEL CURSOR FOR
select GUID,LANG_CODE from TBIDB_LANGUAGE where CREATE_DEFAULT_ENTRY = 1
OPEN c_TBIDB_ATTRIBUTE_AFT_DEL
FETCH NEXT FROM c_TBIDB_ATTRIBUTE_AFT_DEL INTO @LANG_ID,@LANG_CODE
WHILE @@FETCH_STATUS = 0
BEGIN
EXEC PRIDB_CREATE_VIEW_DOC_DATA @LANG_CODE,'DEFAULT';
EXEC PRIDB_CREATE_VIEW_DOC_DATA @LANG_CODE,'DOCRESULT';
FETCH NEXT FROM c_TBIDB_ATTRIBUTE_AFT_DEL INTO @LANG_ID,@LANG_CODE
END
CLOSE c_TBIDB_ATTRIBUTE_AFT_DEL
DEALLOCATE c_TBIDB_ATTRIBUTE_AFT_DEL
GO
CREATE TABLE TBIDB_LANGUAGE_TERM_TYPE
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
TITLE VARCHAR(100) NOT NULL,
COMMENT VARCHAR(500),
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'System',
ADDED_WHEN DATETIME DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_LANGUAGE_TERM_TYPE PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_LANGUAGE_TERM_TYPE UNIQUE (TITLE)
)
GO
INSERT INTO TBIDB_LANGUAGE_TERM_TYPE (TITLE) VALUES ('METADATA-TERM');
INSERT INTO TBIDB_LANGUAGE_TERM_TYPE (TITLE) VALUES ('DOCTYPE');
INSERT INTO TBIDB_LANGUAGE_TERM_TYPE (TITLE) VALUES ('DOC_STATE');
INSERT INTO TBIDB_LANGUAGE_TERM_TYPE (TITLE) VALUES ('STRUCTURE_NODE');
GO
CREATE TRIGGER TBIDB_LANGUAGE_TERM_TYPE_UPD ON TBIDB_LANGUAGE_TERM_TYPE
FOR UPDATE
AS
UPDATE TBIDB_LANGUAGE_TERM_TYPE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_LANGUAGE_TERM_TYPE.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_LANGUAGE_TERM
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
OBJECT_ID BIGINT NOT NULL,
OBJECT_ID1 INT,
TERM_ID BIGINT NOT NULL,
LANG_ID TINYINT NOT NULL,
KIND_TYPE INTEGER,
ADDED_WHO BIGINT,
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
CHANGED_WHO BIGINT,
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_LANGUAGE_TERM PRIMARY KEY (GUID),
CONSTRAINT UN_TBIDB_LANGUAGE_TERM UNIQUE(OBJECT_ID,TERM_ID,LANG_ID,KIND_TYPE),
CONSTRAINT FK_TBIDB_LANGUAGE_TERM_TERMID FOREIGN KEY (TERM_ID) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT FK_TBIDB_LANGUAGE_TERM_LANG_ID FOREIGN KEY (LANG_ID) REFERENCES TBIDB_LANGUAGE (GUID),
CONSTRAINT FK_TBIDB_LANGUAGE_TERM_KINDTYPE FOREIGN KEY (KIND_TYPE) REFERENCES TBIDB_LANGUAGE_TERM_TYPE (GUID),
CONSTRAINT FK_TBIDB_LANGUAGE_TERM_ADDED_WHO_T_ID FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT FK_TBIDB_LANGUAGE_TERM_CHANGED_WHO_T_ID FOREIGN KEY (CHANGED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),)
GO
CREATE NONCLUSTERED INDEX [IDXTBIDB_LANGUAGE_TERM_LANGID_OID_TERMID]
ON [dbo].[TBIDB_LANGUAGE_TERM] ([LANG_ID])
INCLUDE ([OBJECT_ID],[TERM_ID])
GO
CREATE NONCLUSTERED INDEX IDXTBIDB_LANGUAGE_TERM_KINDTYPEID_OID_TID
ON [dbo].[TBIDB_LANGUAGE_TERM] ([KIND_TYPE])
INCLUDE ([OBJECT_ID],[TERM_ID])
GO
CREATE OR ALTER TRIGGER [dbo].[TBIDB_LANGUAGE_TERM_AFT_UPD] ON [dbo].[TBIDB_LANGUAGE_TERM]
FOR UPDATE
AS
DECLARE
@IDB_OBJ_ID BIGINT,
@ATTR_ID INTEGER,
@CHANGED_WHO VARCHAR(100),
@OLD_TERM_ID BIGINT,
@NEW_TERM_ID BIGINT
SELECT
@OLD_TERM_ID = TERM_ID
FROM DELETED
SELECT
@IDB_OBJ_ID = MD.IDB_OBJ_ID,
@ATTR_ID = MD.ATTR_ID,
@NEW_TERM_ID = INS.TERM_ID,
@CHANGED_WHO = INS.CHANGED_WHO
FROM INSERTED INS INNER JOIN TBIDB_OBJECT_METADATA MD ON INS.[OBJECT_ID] = MD.GUID
IF @IDB_OBJ_ID IS NOT NULL AND @CHANGED_WHO IS NOT NULL
INSERT INTO TBIDB_OBJECT_METADATA_CHANGE (
IDB_OBJ_ID,
ATTR_ID,
OLD_TEXT_TERM,
NEW_TEXT_TERM,
CHANGED_WHO) VALUES
(@IDB_OBJ_ID,
@ATTR_ID,
@OLD_TERM_ID,
@NEW_TERM_ID,
@CHANGED_WHO)
UPDATE TBIDB_LANGUAGE_TERM SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_LANGUAGE_TERM.GUID = INSERTED.GUID
GO
--DROP TABLE TBIDB_OBJECT_METADATA_CHANGE
--DROP TABLE TBIDB_OBJECT_METADATA
CREATE TABLE TBIDB_OBJECT_METADATA
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
IDB_OBJ_ID BIGINT NOT NULL,
ATTR_ID INTEGER NOT NULL,
INT_TERM_ID BIGINT,
DEC_TERM_ID BIGINT,
FLOAT_TERM_ID BIGINT,
DATE_TERM_ID BIGINT,
DATETIME_TERM_ID BIGINT,
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_OBJECT_METADATA PRIMARY KEY (GUID),
CONSTRAINT FK_OMD_IDB_OBJ_ID FOREIGN KEY (IDB_OBJ_ID) REFERENCES TBIDB_OBJECT (IDB_OBJ_ID),
CONSTRAINT FK_OMD_ATTR_ID FOREIGN KEY (ATTR_ID) REFERENCES TBIDB_ATTRIBUTE (GUID),
CONSTRAINT FK_OMD_INT_TERM_ID FOREIGN KEY (INT_TERM_ID) REFERENCES TBIDB_TERM_VALUE_INTEGER (GUID),
CONSTRAINT FK_OMD_DEC_TERM_ID FOREIGN KEY (DEC_TERM_ID) REFERENCES TBIDB_TERM_VALUE_DECIMAL (GUID),
CONSTRAINT FK_OMD_FLOAT_TERM_ID FOREIGN KEY (FLOAT_TERM_ID) REFERENCES TBIDB_TERM_VALUE_FLOAT (GUID),
CONSTRAINT FK_OMD_DATE_TERM_ID FOREIGN KEY (DATE_TERM_ID) REFERENCES TBIDB_TERM_VALUE_DATE (GUID),
CONSTRAINT FK_OMD_DATETIME_TERM_ID FOREIGN KEY (DATETIME_TERM_ID) REFERENCES TBIDB_TERM_VALUE_DATETIME (GUID),
)
GO
CREATE NONCLUSTERED INDEX IDXTBIDB_OBJECT_METADATA_IDBOBJID
ON [dbo].[TBIDB_OBJECT_METADATA] ([IDB_OBJ_ID])
GO
--DROP TABLE TBIDB_OBJECT_METADATA_CHANGE;
CREATE TABLE TBIDB_OBJECT_METADATA_CHANGE
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
IDB_OBJ_ID BIGINT NOT NULL,
ATTR_ID INTEGER NOT NULL,
OLD_TEXT_TERM BIGINT,
NEW_TEXT_TERM BIGINT,
OLD_INT_TERM_ID BIGINT,
NEW_INT_TERM_ID BIGINT,
OLD_DEC_TERM_ID BIGINT,
NEW_DEC_TERM_ID BIGINT,
OLD_FLOAT_TERM_ID BIGINT,
NEW_FLOAT_TERM_ID BIGINT,
OLD_DATE_TERM_ID BIGINT,
NEW_DATE_TERM_ID BIGINT,
COMMENT VARCHAR(500),
ADDED_WHO VARCHAR(100),
CHANGED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
CHANGED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CONSTRAINT PK_TBIDB_OBJECT_METADATA_CHANGE PRIMARY KEY (GUID),
CONSTRAINT FK_OMDC_IDB_OBJ_ID FOREIGN KEY (IDB_OBJ_ID) REFERENCES TBIDB_OBJECT (IDB_OBJ_ID),
CONSTRAINT FK_OMDC_ATTR_ID FOREIGN KEY (ATTR_ID) REFERENCES TBIDB_ATTRIBUTE (GUID),
CONSTRAINT FK_OMDC_OLD_TEXT_TERM_ID FOREIGN KEY (OLD_TEXT_TERM) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT FK_OMDC_NEW_TEXT_TERM_ID FOREIGN KEY (NEW_TEXT_TERM) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT FK_OMDC_OLD_INT_TERM_ID FOREIGN KEY (OLD_INT_TERM_ID) REFERENCES TBIDB_TERM_VALUE_INTEGER (GUID),
CONSTRAINT FK_OMDC_NEW_INT_TERM_ID FOREIGN KEY (NEW_INT_TERM_ID) REFERENCES TBIDB_TERM_VALUE_INTEGER (GUID),
CONSTRAINT FK_OMDC_OLD_DEC_TERM_ID FOREIGN KEY (OLD_DEC_TERM_ID) REFERENCES TBIDB_TERM_VALUE_DECIMAL (GUID),
CONSTRAINT FK_OMDC_NEW_DEC_TERM_ID FOREIGN KEY (NEW_DEC_TERM_ID) REFERENCES TBIDB_TERM_VALUE_DECIMAL (GUID),
CONSTRAINT FK_OMDC_OLD_FLOAT_TERM_ID FOREIGN KEY (OLD_FLOAT_TERM_ID) REFERENCES TBIDB_TERM_VALUE_FLOAT (GUID),
CONSTRAINT FK_OMDC_NEW_FLOAT_TERM_ID FOREIGN KEY (NEW_FLOAT_TERM_ID) REFERENCES TBIDB_TERM_VALUE_FLOAT (GUID),
CONSTRAINT FK_OMDC_OLD_DATE_TERM_ID FOREIGN KEY (OLD_DATE_TERM_ID) REFERENCES TBIDB_TERM_VALUE_DATE (GUID),
CONSTRAINT FK_OMDC_NEW_DATE_TERM_ID FOREIGN KEY (NEW_DATE_TERM_ID) REFERENCES TBIDB_TERM_VALUE_DATE (GUID),
)
GO
--DROP TABLE TBIDB_OBJECT_METADATA_ADD
CREATE TABLE [dbo].[TBIDB_OBJECT_METADATA_ADD](
[GUID] BIGINT IDENTITY(1,1) NOT NULL,
[IDB_OBJ_ID] BIGINT NOT NULL,
[ATTR_ID] INT NOT NULL,
[TEXT_TERM_ID] BIGINT,
[INT_TERM_ID] BIGINT,
[DEC_TERM_ID] BIGINT,
[FLOAT_TERM_ID] BIGINT,
[DATE_TERM_ID] BIGINT,
[ADDED_WHO] VARCHAR(100),
[ADDED_WHEN] DATETIME NOT NULL,
CONSTRAINT PK_TBDD_GROUPS_USER PRIMARY KEY (GUID),
CONSTRAINT FK_TBIDB_OBJECTMETADATAADD_ATTRID FOREIGN KEY(ATTR_ID) REFERENCES TBIDB_ATTRIBUTE(GUID),
CONSTRAINT FK_TBIDB_OBJECTMETADATAADD_IDBOBJID FOREIGN KEY(IDB_OBJ_ID) REFERENCES TBIDB_OBJECT(IDB_OBJ_ID),
CONSTRAINT FK_TBIDB_OBJECTMETADATAADD_DATETERMID FOREIGN KEY(DATE_TERM_ID) REFERENCES TBIDB_TERM_VALUE_DATE(GUID),
CONSTRAINT FK_TBIDB_OBJECTMETADATAADD_DECTERMID FOREIGN KEY(DEC_TERM_ID) REFERENCES TBIDB_TERM_VALUE_DECIMAL(GUID),
CONSTRAINT FK_TBIDB_OBJECTMETADATAADD_FLOATTERMID FOREIGN KEY(FLOAT_TERM_ID) REFERENCES TBIDB_TERM_VALUE_FLOAT(GUID),
CONSTRAINT FK_TBIDB_OBJECTMETADATAADD_INTTERMID FOREIGN KEY(INT_TERM_ID) REFERENCES TBIDB_TERM_VALUE_INTEGER(GUID),
CONSTRAINT FK_TBIDB_OBJECTMETADATAADD_TEXTTERMLANGID FOREIGN KEY(TEXT_TERM_ID) REFERENCES TBIDB_TERM_VALUE_VARCHAR(GUID),
)
GO
CREATE TABLE TBIDB_OBJECT_METADATA_DELETE
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
IDB_OBJ_ID BIGINT NOT NULL,
ATTR_ID INTEGER NOT NULL,
TEXT_TERM_ID BIGINT,
INT_TERM_ID BIGINT,
DEC_TERM_ID BIGINT,
FLOAT_TERM_ID BIGINT,
DATE_TERM_ID BIGINT,
USER_DELETE_ID INTEGER NOT NULL DEFAULT 0,
ADDED_WHO VARCHAR(100),
ADDED_WHEN DATETIME,
DELETED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
DELETED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CONSTRAINT PK_TBIDB_OBJECT_METADATA_DELETE PRIMARY KEY (GUID),
CONSTRAINT FK_OMDD_IDB_OBJ_ID FOREIGN KEY (IDB_OBJ_ID) REFERENCES TBIDB_OBJECT (IDB_OBJ_ID),
CONSTRAINT FK_OMDD_ATTR_ID FOREIGN KEY (ATTR_ID) REFERENCES TBIDB_ATTRIBUTE (GUID),
CONSTRAINT FK_OMDD_TEXT_TERM_ID FOREIGN KEY (TEXT_TERM_ID) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT FK_OMDD_INT_TERM_ID FOREIGN KEY (INT_TERM_ID) REFERENCES TBIDB_TERM_VALUE_INTEGER (GUID),
CONSTRAINT FK_OMDD_DEC_TERM_ID FOREIGN KEY (DEC_TERM_ID) REFERENCES TBIDB_TERM_VALUE_DECIMAL (GUID),
CONSTRAINT FK_OMDD_FLOAT_TERM_ID FOREIGN KEY (FLOAT_TERM_ID) REFERENCES TBIDB_TERM_VALUE_FLOAT (GUID),
CONSTRAINT FK_OMDD_DATE_TERM_ID FOREIGN KEY (DATE_TERM_ID) REFERENCES TBIDB_TERM_VALUE_DATE (GUID),
)
GO
CREATE OR ALTER TRIGGER [dbo].[TBIDB_OBJECT_METADATA_AFT_UPD] ON [dbo].[TBIDB_OBJECT_METADATA]
FOR UPDATE
AS
DECLARE
@IDB_OBJ_ID BIGINT,
@ATTR_ID INTEGER,
@CHANGED_WHO VARCHAR(100),
--@OLD_TEXT_TERM_LANG_ID BIGINT,
--@NEW_TEXT_TERM_LANG_ID BIGINT,
@OLD_INT_TERM_ID BIGINT,
@NEW_INT_TERM_ID BIGINT,
@OLD_DEC_TERM_ID BIGINT,
@NEW_DEC_TERM_ID BIGINT,
@OLD_FLOAT_TERM_ID BIGINT,
@NEW_FLOAT_TERM_ID BIGINT,
@OLD_DATE_TERM_ID BIGINT,
@NEW_DATE_TERM_ID BIGINT
SELECT
--@OLD_TEXT_TERM_LANG_ID = TEXT_TERM_LANG_ID,
@OLD_INT_TERM_ID = INT_TERM_ID,
@OLD_DEC_TERM_ID = DEC_TERM_ID,
@OLD_FLOAT_TERM_ID = FLOAT_TERM_ID,
@OLD_DATE_TERM_ID = DATE_TERM_ID
FROM DELETED
SELECT
@IDB_OBJ_ID = IDB_OBJ_ID,
@ATTR_ID = ATTR_ID,
--@NEW_TEXT_TERM_LANG_ID = TEXT_TERM_LANG_ID,
@NEW_INT_TERM_ID = INT_TERM_ID,
@NEW_DEC_TERM_ID = DEC_TERM_ID,
@NEW_FLOAT_TERM_ID = FLOAT_TERM_ID,
@NEW_DATE_TERM_ID = DATE_TERM_ID,
@CHANGED_WHO = CHANGED_WHO
FROM INSERTED
IF @IDB_OBJ_ID IS NOT NULL
INSERT INTO TBIDB_OBJECT_METADATA_CHANGE (
IDB_OBJ_ID,
ATTR_ID,
--OLD_TEXT_TERM_LANG_ID,
--NEW_TEXT_TERM_LANG_ID,
OLD_INT_TERM_ID,
NEW_INT_TERM_ID,
OLD_DEC_TERM_ID,
NEW_DEC_TERM_ID,
OLD_FLOAT_TERM_ID,
NEW_FLOAT_TERM_ID,
OLD_DATE_TERM_ID,
NEW_DATE_TERM_ID,
CHANGED_WHO) VALUES
(@IDB_OBJ_ID,
@ATTR_ID,
--@OLD_TEXT_TERM_LANG_ID,
--@NEW_TEXT_TERM_LANG_ID,
@OLD_INT_TERM_ID,
@NEW_INT_TERM_ID,
@OLD_DEC_TERM_ID,
@NEW_DEC_TERM_ID,
@OLD_FLOAT_TERM_ID,
@NEW_FLOAT_TERM_ID,
@OLD_DATE_TERM_ID,
@NEW_DATE_TERM_ID,
@CHANGED_WHO)
UPDATE TBIDB_OBJECT_METADATA SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_OBJECT_METADATA.GUID = INSERTED.GUID
GO
CREATE OR ALTER TRIGGER TBIDB_OBJECT_METADATA_AFT_INS ON TBIDB_OBJECT_METADATA
WITH EXECUTE AS CALLER
FOR INSERT
AS
BEGIN TRY
DECLARE
--@TEXT_TERM_ID BIGINT,
@INT_TERM_ID BIGINT,
@DEC_TERM_ID BIGINT,
@FLOAT_TERM_ID BIGINT,
@DATE_TERM_ID BIGINT,
@ATTR_ID INTEGER,
@TYPID TINYINT,
@ERROR VARCHAR(100)
SELECT
--@TEXT_TERM_ID = TEXT_TERM_LANG_ID,
@INT_TERM_ID = INT_TERM_ID,
@DEC_TERM_ID = DEC_TERM_ID,
@FLOAT_TERM_ID = FLOAT_TERM_ID,
@DATE_TERM_ID = DATE_TERM_ID,
@ATTR_ID = ATTR_ID
FROM INSERTED
SET @ERROR = 'NONE'
SELECT @TYPID = TYP_ID FROM TBIDB_ATTRIBUTE WHERE GUID = @ATTR_ID
--IF @TYPID in (1,8) AND @TEXT_TERM_ID IS NULL
-- SET @ERROR = 'NO @TEXT_TERM_ID FOR INSERT'
IF @TYPID in (2,9) AND @INT_TERM_ID IS NULL
SET @ERROR = 'NO @INT_TERM_ID FOR INSERT'
ELSE IF @TYPID = 3 AND @FLOAT_TERM_ID IS NULL
SET @ERROR = 'NO @@FLOAT_TERM_ID FOR INSERT'
ELSE IF @TYPID = 4 AND @DEC_TERM_ID IS NULL
SET @ERROR = 'NO @DEC_TERM_ID FOR INSERT'
ELSE IF @TYPID = 5 AND @DATE_TERM_ID IS NULL
SET @ERROR = 'NO @DATE_TERM_ID FOR INSERT'
ELSE IF @TYPID = 7 AND @INT_TERM_ID IS NULL
SET @ERROR = 'NO @INT_TERM_ID FOR INSERT'
IF @ERROR <> 'NONE'
BEGIN
RAISERROR(@ERROR, 16, 1)
rollback transaction
END
END TRY
BEGIN CATCH
PRINT 'ERROR IN TRIGGER: ' + CONVERT(VARCHAR(100),ERROR_PROCEDURE())
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
END CATCH
GO
--DROP TABLE TBIDB_ATT_LANGUAGE
CREATE TABLE TBIDB_ATTRIBUTE_LANGUAGE
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
ATTRIBUTE_ID INT NOT NULL,
LANGUAGE_ID TINYINT NOT NULL,
TERM_ID BIGINT NOT NULL,
COMMENT VARCHAR(500),
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_ATT_LANGUAGE PRIMARY KEY(GUID),
CONSTRAINT UN_TBIDB_ATT_LANGUAGE UNIQUE(ATTRIBUTE_ID,LANGUAGE_ID),
CONSTRAINT FK_ATTRIBUTE_ID FOREIGN KEY(ATTRIBUTE_ID) REFERENCES TBIDB_ATTRIBUTE(GUID),
CONSTRAINT FK_LANGUAGE_ID FOREIGN KEY(LANGUAGE_ID) REFERENCES TBIDB_LANGUAGE(GUID),
CONSTRAINT FK_TERM_ID FOREIGN KEY(TERM_ID) REFERENCES TBIDB_TERM_VALUE_VARCHAR(GUID)
)
GO
CREATE TRIGGER TBIDB_ATT_LANGUAGE_AFT_UPD ON TBIDB_ATTRIBUTE_LANGUAGE
FOR UPDATE
AS
UPDATE TBIDB_ATTRIBUTE_LANGUAGE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_ATTRIBUTE_LANGUAGE.GUID = INSERTED.GUID
GO
CREATE VIEW VWIDB_ATTRIBUTE_LANG
AS
select
ATTR.GUID As AttributeID
,TERM.TERM_VALUE as Attribute
,ATTR.TYP_ID as AttributeTypeID
,ATY.NAME_TYPE as AttributeType
,LANG.LANG_CODE
from
TBIDB_ATTRIBUTE ATTR INNER JOIN TBIDB_ATTRIBUTE_LANGUAGE AL On ATTR.GUID = AL.ATTRIBUTE_ID
INNER JOIN TBIDB_LANGUAGE LANG ON AL.LANGUAGE_ID = LANG.GUID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR TERM ON AL.TERM_ID = TERM.GUID
INNER JOIN TBIDB_ATTRIBUTE_TYPE ATY ON ATTR.TYP_ID = ATY.GUID
WHERE
ATTR.DELETED = 0
GO
CREATE OR ALTER VIEW [dbo].[VWIDB_BE_ATTRIBUTE] AS
SELECT
COALESCE(T.GUID,0) as GUID,
COALESCE(T.[BE_ID],0) BE_ID
,COALESCE(T2.TITLE,'NO BE SO FAR') AS BE
,T1.GUID AS [ATTR_ID]
,T6.TERM_VALUE AS ATTR_TITLE
,T4.TERM_ID AS ATTR_TERM_ID
,T1.TYP_ID
,T1.TYP_ID AS [TYPE_ID]
,T3.NAME_TYPE AS [TYPE_NAME]
,T1.VIEW_VISIBLE
,T1.MULTI_CONTEXT
,T1.VIEW_SEQUENCE
,T1.SYS_ATTRIBUTE
,T.DEFAULT_SEARCH_ATTRIBUTE
,T5.GUID AS LANG_ID
,T5.LANG_CODE
,T1.ADDED_WHEN
,T1.ADDED_WHO
,T1.CHANGED_WHEN
,T1.CHANGED_WHO
FROM TBIDB_ATTRIBUTE T1 LEFT JOIN [TBIDB_BE_ATTRIBUTE] T ON T.ATTR_ID = T1.GUID
LEFT JOIN TBIDB_BUSINESS_ENTITY T2 ON T.BE_ID = T2.GUID
INNER JOIN TBIDB_ATTRIBUTE_TYPE T3 ON T1.TYP_ID = T3.GUID
INNER JOIN TBIDB_ATTRIBUTE_LANGUAGE T4 ON T1.GUID = T4.ATTRIBUTE_ID
INNER JOIN TBIDB_LANGUAGE T5 ON T4.LANGUAGE_ID = T5.GUID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR T6 ON T4.TERM_ID = T6.GUID
WHERE T1.DELETED = 0
GO
CREATE TABLE TBIDB_BASE
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
CONFIG_NAME VARCHAR(900) NOT NULL,
CONFIG_VALUE VARCHAR(MAX) NOT NULL,
COMMENT VARCHAR(500),
ADDED_WHO VARCHAR(30) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(30),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_BASE PRIMARY KEY (GUID),
CONSTRAINT UQ1_TBIDB_BASE UNIQUE (CONFIG_NAME)
)
GO
CREATE TRIGGER TBIDB_BASE_AFT_UPD ON TBIDB_BASE
FOR UPDATE
AS
UPDATE TBIDB_BASE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_BASE.GUID = INSERTED.GUID
GO
INSERT INTO TBIDB_BASE (CONFIG_NAME,CONFIG_VALUE) VALUES ('DB_VERSION','1.1.0')
GO
INSERT INTO TBIDB_BASE (CONFIG_NAME,CONFIG_VALUE) VALUES ('GHOST_SELECT','
SELECT T.USERNAME,T.NAME, T.[PRENAME],T.EMAIL FROM MY_DD_ECM_DB.dbo.TBDD_USER T ORDER BY USERNAME')
GO
CREATE TABLE TBIDB_STATES
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
TITLE VARCHAR(200) NOT NULL,
ADDED_WHO BIGINT,
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
CHANGED_WHO BIGINT,
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_STATES PRIMARY KEY (GUID),
CONSTRAINT FK_TBIDB_STATES_ADDED_WHO_T_ID FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT FK_TBIDB_STATES_CHANGED_WHO_T_ID FOREIGN KEY (CHANGED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),)
GO
CREATE TRIGGER TBIDB_STATES_AFT_UPD ON TBIDB_STATES
FOR UPDATE
AS
UPDATE TBIDB_STATES SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_STATES.GUID = INSERTED.GUID
GO
--DROP TABLE TBIDB_CONVERSATION_MESSAGE
--DROP TABLE TBIDB_CONVERSATION_USER
--DROP TABLE TBIDB_CONVERSATION_OBJECT
CREATE TABLE TBIDB_CONVERSATION_OBJECT
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
TITLE_TERM_ID BIGINT NOT NULL,
IDB_OBJ_ID BIGINT NOT NULL,
ADDED_WHO BIGINT,
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
CHANGED_WHO BIGINT,
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_CONVERSATION_OBJECT PRIMARY KEY (GUID),
CONSTRAINT FK_TBIDB_CONVERSATION_OBJECT_IDB_OBJ_ID FOREIGN KEY (IDB_OBJ_ID) REFERENCES TBIDB_OBJECT (IDB_OBJ_ID),
CONSTRAINT FK_TBIDB_CONVERSATION_OBJECT_ADDED_WHO_T_ID FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT FK_TBIDB_CONVERSATION_OBJECT_CHANGED_WHO_T_ID FOREIGN KEY (CHANGED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),)
GO
CREATE TRIGGER TBIDB_CONVERSATION_OBJECT_AFT_UPD ON TBIDB_CONVERSATION_OBJECT
FOR UPDATE
AS
UPDATE TBIDB_CONVERSATION_OBJECT SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_CONVERSATION_OBJECT.GUID = INSERTED.GUID
GO
GO
--DROP TABLE TBIDB_MYOBJECT_STATES;
CREATE TABLE TBIDB_MYOBJECT_STATES
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
MY_OBJECT_ID BIGINT NOT NULL,
STATE_ID INTEGER NOT NULL,
COMMENT_ID BIGINT ,
ADDED_WHO BIGINT,
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
CHANGED_WHO BIGINT,
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_MYOBJECT_STATES PRIMARY KEY (GUID),
CONSTRAINT FK_TBIDB_MYOBJECT_STATES_STATE_ID FOREIGN KEY (STATE_ID) REFERENCES TBIDB_STATES (GUID),
CONSTRAINT FK_TBIDB_MYOBJECT_STATES_ADDED_WHO_T_ID FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT FK_TBIDB_MYOBJECT_STATES_CHANGED_WHO_T_ID FOREIGN KEY (CHANGED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),)
GO
CREATE TRIGGER TBIDB_MYOBJECT_STATES_AFT_UPD ON TBIDB_MYOBJECT_STATES
FOR UPDATE
AS
UPDATE TBIDB_MYOBJECT_STATES SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_MYOBJECT_STATES.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_CONVERSATION_USER
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
CONV_ID BIGINT NOT NULL,
USER_OR_GROUP_ID INTEGER NOT NULL,
IS_USER BIT NOT NULL,
ADDED_WHO BIGINT,
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
CONSTRAINT PK_TBIDB_CONVERSATION_USER PRIMARY KEY (GUID),
CONSTRAINT FK_TBIDB_CONVERSATION_USER_CONV_ID FOREIGN KEY (CONV_ID) REFERENCES TBIDB_CONVERSATION_OBJECT (GUID),
CONSTRAINT FK_TBIDB_CONVERSATION_USER_ADDED_WHO FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),)
GO
CREATE TABLE TBIDB_COMMON_SQL
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
TITLE VARCHAR(200) NOT NULL,
SQL_COMMAND NVARCHAR(MAX),
ACTIVE BIT NOT NULL DEFAULT 1,
ADDED_WHO VARCHAR(100),
ADDED_WHEN DATETIME DEFAULT GETDATE(),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_COMMON_SQL PRIMARY KEY (GUID)
)
GO
CREATE TRIGGER [dbo].[TBIDB_COMMON_SQL_AFT_UPD] ON [dbo].[TBIDB_COMMON_SQL]
FOR UPDATE
AS
UPDATE TBIDB_COMMON_SQL SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_COMMON_SQL.GUID = INSERTED.GUID
GO
DELETE FROM [TBIDB_COMMON_SQL] WHERE TITLE = 'FLOW_SEARCH_SQL_BASE';
INSERT INTO [dbo].[TBIDB_COMMON_SQL]
([TITLE]
,[SQL_COMMAND]
,[ADDED_WHO])
VALUES
('FLOW_SEARCH_SQL_BASE'
,'SELECT
DOC.*
,CONVERT(BIT,IIF(CHK.CHECKED_OUT_WHEN IS NULL,''False'',''True'')) CHECKED_OUT
FROM
TBIDB_SEARCH_RESULT_TERM_USER RES INNER JOIN VWIDB_LANGUAGE_TERM VWLTERM ON RES.MD_GUID = VWLTERM.MD_ID
INNER JOIN VWIDB_DOCRESULT_DE DOC ON VWLTERM.IDB_OBJ_ID = DOC.DocID
LEFT JOIN TBIDB_OBJECT_CHECK_IN_OUT CHK ON DOC.DocID = CHK.IDB_OBJ_ID
WHERE
RES.USR_ID = @USER_ID AND VWLTERM.LANG_CODE = ''@LANG_CODE''
UNION
SELECT
DOC.*
,CONVERT(BIT,IIF(CHK.CHECKED_OUT_WHEN IS NULL,''False'',''True'')) CHECKED_OUT
FROM
TBIDB_SEARCH_RESULT_STRUCT_TYPE_USER RES INNER JOIN VWIDB_DOC_DOCTYPE VWDT ON RES.STRUCTURE_ID = VWDT.STRUCTURE_ID AND RES.IDB_OBJ_ID = VWDT.IDB_OBJ_ID
INNER JOIN VWIDB_DOCRESULT_DE DOC ON RES.IDB_OBJ_ID = DOC.DocID
LEFT JOIN TBIDB_OBJECT_CHECK_IN_OUT CHK ON DOC.DocID = CHK.IDB_OBJ_ID
WHERE
RES.USR_ID = @USER_ID AND VWDT.LANG_CODE = ''@LANG_CODE''
AND CHK.CHECKED_IN_WHEN IS NULL','SYSTEM')
GO
CREATE TABLE TBIDB_SEARCH_INPUT_USER
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
USR_ID INTEGER,
ATTR_ID INT,
ATTR_TITLE VARCHAR(100),
TERM_ID BIGINT,
OPERATOR VARCHAR(20) NOT NULL DEFAULT 'AND',
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
CONSTRAINT PK_TBIDB_SEARCH_INPUT_USER PRIMARY KEY (GUID),
)
GO
CREATE TABLE TBIDB_SEARCH_RESULT_TERM_USER
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
MD_GUID BIGINT
,USR_ID INTEGER
CONSTRAINT FK_TBIDB_SEARCH_RESULT_USER_MD_GUID FOREIGN KEY (MD_GUID) REFERENCES TBIDB_OBJECT_METADATA (GUID)
)
GO
CREATE TABLE TBIDB_SEARCH_RESULT_TOKEN
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
DocID BIGINT NOT NULL,
USR_ID INTEGER NOT NULL,
TOKEN_ID TINYINT NOT NULL,
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
)
GO
CREATE TABLE TBIDB_SEARCH_RESULT_DOCS
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
DocID BIGINT NOT NULL,
USR_ID INTEGER NOT NULL,
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE()
)
GO
CREATE TABLE TBIDB_SEARCH_RESULT_STRUCT_TYPE_USER
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
IDB_OBJ_ID BIGINT NOT NULL,
STRUCTURE_ID INTEGER NOT NULL,
USR_ID INTEGER
CONSTRAINT FK_TBIDB_SEARCH_RESULT_STRUCT_TYPE_USER_IDBOBJID FOREIGN KEY (IDB_OBJ_ID) REFERENCES TBIDB_OBJECT (IDB_OBJ_ID),
CONSTRAINT FK_TBIDB_SEARCH_RESULT_STRUCT_TYPE_USER_STRUCTURE_ID FOREIGN KEY (STRUCTURE_ID) REFERENCES TBIDB_STRUCTURE_TYPE (GUID)
)
GO
CREATE TABLE TBIDB_SEARCH_DATE_VALUE_USER
(
USR_ID INTEGER
,DATE_FROM DATE NOT NULL
,DATE_TILL DATE
CONSTRAINT PK_TBIDB_SEARCH_DATE_VALUE_USER PRIMARY KEY (USR_ID)
)
GO
CREATE PROCEDURE PRIDB_SEARCH_ADD_USR_DATE @USERID INT,@DATE1 DATE, @DATE2 DATE
AS
BEGIN
DELETE FROM TBIDB_SEARCH_DATE_VALUE_USER WHERE USR_ID = @USERID;
INSERT INTO TBIDB_SEARCH_DATE_VALUE_USER (USR_ID,DATE_FROM,DATE_TILL) VALUES
(@USERID,@DATE1,@DATE2);
END
GO
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_SEARCH_AUTOSUGGEST] @pLANGCODE VARCHAR(5),@pUSRID INT
AS
BEGIN
DECLARE @TBRESULT TABLE(TERM VARCHAR(900),TERM_ID BIGINT, ATTR_TITLE VARCHAR(100),ATTR_ID INT)
INSERT INTO @TBRESULT (TERM, TERM_ID, ATTR_ID,ATTR_TITLE)
select DISTINCT TERM.TERM_VALUE, TERM.GUID, ATTR.ATTR_ID, ATTR.ATTR_TITLE
FROM TBIDB_TERM_VALUE_VARCHAR TERM
INNER JOIN TBIDB_LANGUAGE_TERM TLANG ON TLANG.TERM_ID = TERM.GUID
INNER JOIN TBIDB_LANGUAGE LANG ON LANG.GUID = TLANG.LANG_ID
INNER JOIN TBIDB_OBJECT_METADATA MD ON TLANG.OBJECT_ID = MD.GUID
INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
INNER JOIN VWIDB_BE_ATTRIBUTE ATTR ON MD.ATTR_ID = ATTR.ATTR_ID
WHERE
OBJ.ACTIVE = 1 AND LANG.LANG_CODE = @pLANGCODE
AND ATTR.LANG_CODE = @pLANGCODE
AND ATTR.VIEW_VISIBLE = 1;
INSERT INTO @TBRESULT (TERM, TERM_ID, ATTR_ID,ATTR_TITLE)
select DISTINCT TERM.TERM_VALUE, TERM.GUID, ATTR.ATTR_ID, ATTR.ATTR_TITLE
FROM TBIDB_TERM_VALUE_INTEGER TERM
INNER JOIN TBIDB_OBJECT_METADATA MD ON MD.INT_TERM_ID = TERM.GUID
INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
INNER JOIN VWIDB_BE_ATTRIBUTE ATTR ON MD.ATTR_ID = ATTR.ATTR_ID
WHERE
OBJ.ACTIVE = 1
AND ATTR.LANG_CODE = @pLANGCODE
AND ATTR.VIEW_VISIBLE = 1;
INSERT INTO @TBRESULT (TERM,ATTR_ID,ATTR_TITLE)
select DISTINCT Doctype,Doctype_ID,'DOCTYPE' FROM VWIDB_DOC_DOCTYPE where LANG_CODE = @pLANGCODE;
SELECT * FROM @TBRESULT
END
GO
--DROP TABLE TBIDB_SEARCH_DEF_RELATIONS
--DROP TABLE TBIDB_SEARCH_DEFINITION
CREATE TABLE TBIDB_SEARCH_DEFINITION
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
TITLE VARCHAR(250) NOT NULL,
DESCRIPTION VARCHAR(500),
XML_VALUE NVARCHAR(MAX) NOT NULL,
SYS_SEARCH BIT NOT NULL DEFAULT 0,
ADDED_WHO VARCHAR(100) NOT NULL,
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_SEARCH_DEFINITION PRIMARY KEY (GUID)
)
GO
CREATE TRIGGER [dbo].[TBIDB_SEARCH_DEFINITION_AFT_UPD] ON [dbo].[TBIDB_SEARCH_DEFINITION]
FOR UPDATE
AS
UPDATE TBIDB_SEARCH_DEFINITION SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_SEARCH_DEFINITION.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_SEARCH_DEF_RELATIONS
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
SEARCH_ID INTEGER NOT NULL,
USR_ID INT NOT NULL DEFAULT 0,
GRP_ID INT NOT NULL DEFAULT 0,
ADDED_WHO VARCHAR(100),
ADDED_WHEN DATETIME DEFAULT GETDATE(),
CONSTRAINT PK_TBIDB_SEARCH_DEF_RELATIONS PRIMARY KEY (GUID),
CONSTRAINT FK_TBIDB_SEARCH_DEF_RELATIONS_SID FOREIGN KEY (SEARCH_ID) REFERENCES TBIDB_SEARCH_DEFINITION (GUID),
CONSTRAINT UQ_PK_TBIDB_SEARCH_DEF_RELATIONS UNIQUE(SEARCH_ID,USR_ID,GRP_ID)
)
GO
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_SEARCH_GET_TOKEN_RESULT] (@pUSR_ID as INTEGER,@pType AS VARCHAR(20), @DateStr VARCHAR(500), @pTERM_ID BIGINT, @pTOKENID TINYINT = 0, @pLANG_CODE as VARCHAR(5) = 'de-DE')
AS
BEGIN
DECLARE @DYNSQL_INSERT NVARCHAR(MAX)
DECLARE @DATE1 DATE,@DATE2 DATE
SET @DYNSQL_INSERT = 'INSERT INTO TBIDB_SEARCH_RESULT_TOKEN(DocID,TOKEN_ID,USR_ID)' + char(10) +
'SELECT DISTINCT MD.IDB_OBJ_ID,' + CONVERT(VARCHAR(2),@pTOKENID) + ',' + CONVERT(VARCHAR(10),@pUSR_ID) + char(10)
IF @pType = 'BIG INTEGER'
SET @DYNSQL_INSERT += 'FROM ' + char(10) + CHAR(9) + 'TBIDB_TERM_VALUE_INTEGER TERM' + char(10) +
CHAR(9) + 'INNER JOIN JOIN TBIDB_OBJECT_METADATA MD ON MD.INT_TERM_ID = TERM.GUID' +
CHAR(9) + 'INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID' + char(10)
ELSE IF @pType = 'VARCHAR'
SET @DYNSQL_INSERT += 'FROM ' + char(10) + CHAR(9) + 'TBIDB_TERM_VALUE_VARCHAR TERM' + char(10) +
CHAR(9) + 'INNER JOIN TBIDB_LANGUAGE_TERM TLANG ON TLANG.TERM_ID = TERM.GUID' +
CHAR(9) + 'INNER JOIN TBIDB_LANGUAGE LANG ON LANG.GUID = TLANG.LANG_ID' +
CHAR(9) + 'INNER JOIN TBIDB_OBJECT_METADATA MD ON TLANG.OBJECT_ID = MD.GUID' +
CHAR(9) + 'INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID' + char(10)
ELSE IF @pType = 'DOCTYPE'
SET @DYNSQL_INSERT = 'INSERT INTO TBIDB_SEARCH_RESULT_TOKEN(DocID,TOKEN_ID,USR_ID)' + char(10) +
'SELECT DISTINCT DT.IDB_OBJ_ID,' + CONVERT(VARCHAR(2),@pTOKENID) + ',' + CONVERT(VARCHAR(10),@pUSR_ID) + char(10) +
'FROM' + char(10) + CHAR(9) + 'VWIDB_DOC_DOCTYPE DT' + char(10)
+ CHAR(9) + 'INNER JOIN TBIDB_TERM_VALUE_VARCHAR TERM ON DT.TERM_ID = TERM.GUID'
+ CHAR(9) + 'INNER JOIN TBIDB_OBJECT OBJ ON DT.IDB_OBJ_ID = OBJ.IDB_OBJ_ID' + char(10)
SET @DYNSQL_INSERT += 'WHERE ' + char(10)+ CHAR(9) + 'OBJ.ACTIVE = 1' + char(10)
IF @DateStr = 'DATEPART'
BEGIN
SELECT @DATE1 = DATE_FROM ,@DATE2 = DATE_TILL FROM TBIDB_SEARCH_DATE_VALUE_USER WHERE USR_ID = @pUSR_ID;
SET @DYNSQL_INSERT += 'AND CONVERT(DATE,OBJ.ADDED_WHEN) >= CONVERT(DATE,''' + CONVERT(VARCHAR(10),@DATE1) + ''') AND CONVERT(DATE,OBJ.ADDED_WHEN) <= CONVERT(DATE,''' + CONVERT(VARCHAR(10),@DATE2) + ''')' + char(10)
END
ELSE IF @DateStr = 'ECM_CREATED_TODAY'
SET @DYNSQL_INSERT += 'AND DATEDIFF(DAY,OBJ.ADDED_WHEN,GETDATE()) = 0' + char(10)
ELSE IF @DateStr = 'ECM_CREATED_YESTERDAY'
SET @DYNSQL_INSERT += 'AND DATEDIFF(DAY,OBJ.ADDED_WHEN,GETDATE()) = 1' + char(10)
ELSE IF @DateStr = 'ECM_CREATED_LAST7DAYS'
SET @DYNSQL_INSERT += 'AND DATEDIFF(DAY,OBJ.ADDED_WHEN,GETDATE()) <= 7' + char(10)
ELSE IF @DateStr = 'ECM_YEAR_CURRENT'
SET @DYNSQL_INSERT += 'AND DATEPART(YEAR,OBJ.ADDED_WHEN) = DATEPART(YEAR,GETDATE())' + char(10)
ELSE IF @DateStr = 'ECM_YEAR_LAST'
SET @DYNSQL_INSERT += 'AND DATEPART(YEAR,OBJ.ADDED_WHEN) = DATEPART(YEAR,GETDATE())-1' + char(10)
ELSE IF @DateStr = 'ECM_CREATED_MONTH_CURRENT'
BEGIN
SET @DYNSQL_INSERT += 'AND DATEPART(YEAR,OBJ.ADDED_WHEN) = DATEPART(YEAR,GETDATE())' + char(10)
SET @DYNSQL_INSERT += 'AND DATEPART(MONTH,OBJ.ADDED_WHEN) = DATEPART(MONTH,GETDATE())' + char(10)
END
ELSE IF @DateStr = 'ECM_CREATED_MONTH_LAST'
BEGIN
IF DATEPART(MONTH,GETDATE()) = 1
BEGIN
SET @DYNSQL_INSERT += 'AND DATEPART(YEAR,OBJ.ADDED_WHEN) = DATEPART(YEAR,GETDATE())-1' + char(10)
SET @DYNSQL_INSERT += 'AND DATEPART(MONTH,OBJ.ADDED_WHEN) = 12' + char(10)
END
ELSE
BEGIN
SET @DYNSQL_INSERT += 'AND DATEPART(YEAR,OBJ.ADDED_WHEN) = DATEPART(YEAR,GETDATE())' + char(10)
SET @DYNSQL_INSERT += 'AND DATEPART(MONTH,OBJ.ADDED_WHEN) = DATEPART(MONTH,GETDATE())-1' + char(10)
END
END
SET @DYNSQL_INSERT += CHAR(9) + 'AND TERM.guid = ' + CONVERT(VARCHAR(20),@pTERM_ID) + char(10)
DECLARE @LANGUAGE AS VARCHAR(100)
IF @pType <> 'DOCTYPE'
SET @LANGUAGE = 'AND LANG.LANG_CODE = ''' + @pLANG_CODE + ''''
ELSE
SET @LANGUAGE = 'AND DT.LANG_CODE = ''' + @pLANG_CODE + ''''
SET @DYNSQL_INSERT += CHAR(9) + @LANGUAGE + char(10)
PRINT @DYNSQL_INSERT
EXEC sp_executesql @DYNSQL_INSERT
END
GO
-- =============================================
-- Author: DD MS
-- Changed: 19.05.2022
-- =============================================
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_SEARCH_GET_TOKEN_RESULT_DOCS] (@pUSR_ID as INTEGER,@pDATE_RESTRICTION VARCHAR(500), @pLANG_CODE as VARCHAR(5) = 'de-DE')
AS
BEGIN
DECLARE @SRCH_VAR VARCHAR(900), @DYNSQL_INSERT NVARCHAR(MAX),@DateStr VARCHAR(100)
DECLARE @DATE1 DATE,@DATE2 DATE
DELETE FROM TBIDB_SEARCH_RESULT_TOKEN WHERE USR_ID = @pUSR_ID;
IF LEN(@pDATE_RESTRICTION) > 0
BEGIN
PRINT '@pDATE_RESTRICTION....'
DECLARE @IDX TINYINT, @ATTR_ID_DATE VARCHAR(100)
SET @IDX = CHARINDEX('~',@pDATE_RESTRICTION)
PRINT '@IDX: ' + CONVERT(VARCHAR(10),@IDX)
SET @ATTR_ID_DATE = LEFT(@pDATE_RESTRICTION,@IDX-1)
SET @DateStr = SUBSTRING(@pDATE_RESTRICTION,@IDX + 1,LEN(@pDATE_RESTRICTION)-@IDX)
PRINT @DateStr
END
--###############################################################################
--SUCHE NACH TERM-WERTEN
DECLARE @DOC_RESULTS TABLE (DocID BIGINT)
DECLARE @DOC_RESULTS_TEMP TABLE (DocID BIGINT)
DECLARE @ATTR_ID INT, @ATTR_TITLE VARCHAR(100),@TERM_ID BIGINT,@OPERATOR VARCHAR(10),@TOKEN_ID TINYINT ,@TYPE_ATTR VARCHAR(50)
SET @TOKEN_ID = 0
DECLARE curs_Tokens CURSOR LOCAL FOR
SELECT A.ATTR_ID, A.ATTR_TITLE,A.TERM_ID,A.OPERATOR,B.TYPE_NAME
FROM TBIDB_SEARCH_INPUT_USER A INNER JOIN VWIDB_BE_ATTRIBUTE B ON A.ATTR_ID = B.ATTR_ID WHERE A.USR_ID = @pUSR_ID AND B.LANG_CODE = @pLANG_CODE
UNION
SELECT B.Doctype_ID, B.Doctype,B.TERM_ID,A.OPERATOR,A.ATTR_TITLE
FROM TBIDB_SEARCH_INPUT_USER A INNER JOIN VWIDB_DOCTYPE_LANGUAGE B ON A.ATTR_ID = B.Doctype_ID WHERE A.USR_ID = @pUSR_ID AND B.LANG_CODE = @pLANG_CODE AND A.ATTR_TITLE = 'DOCTYPE'
OPEN curs_Tokens
FETCH NEXT FROM curs_Tokens INTO @ATTR_ID, @ATTR_TITLE,@TERM_ID,@OPERATOR,@TYPE_ATTR
WHILE @@FETCH_STATUS = 0
BEGIN
--IF @TOKEN_ID > 0
-- BEGIN
-- DELETE FROM @DOC_RESULTS;
-- END
SET @TOKEN_ID += 1
PRINT '### WORKIN ON ATTRIBUTE [' + @ATTR_TITLE + '] TOKEN_ID [' + CONVERT(VARCHAR(2),@TOKEN_ID) + '] ###'
EXEC PRIDB_SEARCH_GET_TOKEN_RESULT @pUSR_ID,@TYPE_ATTR,@DateStr,@TERM_ID,@TOKEN_ID,@pLANG_CODE
IF @TOKEN_ID > 1 AND @OPERATOR = 'AND'
BEGIN
DELETE FROM @DOC_RESULTS;
INSERT INTO @DOC_RESULTS(DocID)
SELECT DocID FROM TBIDB_SEARCH_RESULT_TOKEN WHERE TOKEN_ID = @TOKEN_ID AND DocID IN (SELECT DocID FROM TBIDB_SEARCH_RESULT_TOKEN WHERE TOKEN_ID < @TOKEN_ID AND USR_ID = @pUSR_ID)
END
ELSE
INSERT INTO @DOC_RESULTS(DocID)
SELECT DocID FROM TBIDB_SEARCH_RESULT_TOKEN WHERE TOKEN_ID = @TOKEN_ID AND USR_ID = @pUSR_ID --AND DocID NOT IN (SELECT DocID FROM @DOC_RESULTS)
FETCH NEXT FROM curs_Tokens INTO @ATTR_ID, @ATTR_TITLE,@TERM_ID,@OPERATOR,@TYPE_ATTR
END
CLOSE curs_Tokens
DEALLOCATE curs_Tokens
DELETE FROM TBIDB_SEARCH_RESULT_DOCS WHERE USR_ID = @pUSR_ID;
INSERT INTO TBIDB_SEARCH_RESULT_DOCS(DocID,USR_ID)
SELECT DISTINCT DocID,@pUSR_ID FROM @DOC_RESULTS;
END
GO
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_SEARCH_GET_ATTRIBUTE_RESULT] (@pUSR_ID as INTEGER,@pType AS VARCHAR(20), @DateStr VARCHAR(500), @pSEARCH_TERM as VARCHAR(900), @pLANG_CODE as VARCHAR(5) = 'de-DE')
AS
BEGIN
PRINT '##############################################################'
PRINT '######### [PRIDB_SEARCH_GET_ATTRIBUTE_RESULT] ################'
PRINT '##############################################################'
DECLARE @DYNSQL_INSERT NVARCHAR(MAX)
DECLARE @DATE1 DATE,@DATE2 DATE
SET @DYNSQL_INSERT = 'INSERT INTO TBIDB_SEARCH_RESULT_DOCS(DocID,USR_ID)' + char(10) +
'SELECT DISTINCT MD.IDB_OBJ_ID,' + CONVERT(VARCHAR(10),@pUSR_ID) + char(10)
IF @pType = 'BIG INTEGER'
SET @DYNSQL_INSERT += 'FROM' + char(10) + CHAR(9) + 'TBIDB_TERM_VALUE_INTEGER TERM' + char(10) +
CHAR(9) + 'INNER JOIN TBIDB_OBJECT_METADATA MD ON MD.INT_TERM_ID = TERM.GUID' + char(10) +
CHAR(9) + 'INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID' + char(10)
ELSE IF @pType = 'VARCHAR'
SET @DYNSQL_INSERT += 'FROM' + char(10) + CHAR(9) + 'TBIDB_TERM_VALUE_VARCHAR TERM' + char(10) +
'INNER JOIN TBIDB_LANGUAGE_TERM TLANG ON TLANG.TERM_ID = TERM.GUID' + char(10) +
CHAR(9) + 'INNER JOIN TBIDB_LANGUAGE LANG ON LANG.GUID = TLANG.LANG_ID' + char(10) +
CHAR(9) + 'INNER JOIN TBIDB_OBJECT_METADATA MD ON TLANG.OBJECT_ID = MD.GUID' + char(10) +
CHAR(9) + 'INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID' + char(10)
SET @DYNSQL_INSERT += 'WHERE ' + char(10) + CHAR(9) + 'OBJ.ACTIVE = 1' + char(10)
IF @DateStr = 'DATEPART'
BEGIN
SELECT @DATE1 = DATE_FROM ,@DATE2 = DATE_TILL FROM TBIDB_SEARCH_DATE_VALUE_USER WHERE USR_ID = @pUSR_ID;
SET @DYNSQL_INSERT += 'AND CONVERT(DATE,OBJ.ADDED_WHEN) >= CONVERT(DATE,''' + CONVERT(VARCHAR(10),@DATE1) + ''') AND CONVERT(DATE,OBJ.ADDED_WHEN) <= CONVERT(DATE,''' + CONVERT(VARCHAR(10),@DATE2) + ''')' + char(10)
END
ELSE IF @DateStr = 'ECM_CREATED_TODAY'
SET @DYNSQL_INSERT += 'AND DATEDIFF(DAY,OBJ.ADDED_WHEN,GETDATE()) = 0' + char(10)
ELSE IF @DateStr = 'ECM_CREATED_YESTERDAY'
SET @DYNSQL_INSERT += 'AND DATEDIFF(DAY,OBJ.ADDED_WHEN,GETDATE()) = 1' + char(10)
ELSE IF @DateStr = 'ECM_CREATED_LAST7DAYS'
SET @DYNSQL_INSERT += 'AND DATEDIFF(DAY,OBJ.ADDED_WHEN,GETDATE()) <= 7' + char(10)
ELSE IF @DateStr = 'ECM_YEAR_CURRENT'
SET @DYNSQL_INSERT += 'AND DATEPART(YEAR,OBJ.ADDED_WHEN) = DATEPART(YEAR,GETDATE())' + char(10)
ELSE IF @DateStr = 'ECM_YEAR_LAST'
SET @DYNSQL_INSERT += 'AND DATEPART(YEAR,OBJ.ADDED_WHEN) = DATEPART(YEAR,GETDATE())-1' + char(10)
ELSE IF @DateStr = 'ECM_CREATED_MONTH_CURRENT'
BEGIN
SET @DYNSQL_INSERT += 'AND DATEPART(YEAR,OBJ.ADDED_WHEN) = DATEPART(YEAR,GETDATE())' + char(10)
SET @DYNSQL_INSERT += 'AND DATEPART(MONTH,OBJ.ADDED_WHEN) = DATEPART(MONTH,GETDATE())' + char(10)
END
ELSE IF @DateStr = 'ECM_CREATED_MONTH_LAST'
BEGIN
IF DATEPART(MONTH,GETDATE()) = 1
BEGIN
SET @DYNSQL_INSERT += 'AND DATEPART(YEAR,OBJ.ADDED_WHEN) = DATEPART(YEAR,GETDATE())-1' + char(10)
SET @DYNSQL_INSERT += 'AND DATEPART(MONTH,OBJ.ADDED_WHEN) = 12' + char(10)
END
ELSE
BEGIN
SET @DYNSQL_INSERT += 'AND DATEPART(YEAR,OBJ.ADDED_WHEN) = DATEPART(YEAR,GETDATE())' + char(10)
SET @DYNSQL_INSERT += 'AND DATEPART(MONTH,OBJ.ADDED_WHEN) = DATEPART(MONTH,GETDATE())-1' + char(10)
END
END
IF LEN(@pSEARCH_TERM) > 0
BEGIN
IF @pSEARCH_TERM like '%*%' AND @pType = 'VARCHAR'
SET @DYNSQL_INSERT += 'AND CONTAINS(TERM.TERM_VALUE,''' + @pSEARCH_TERM + ''')' + char(10)
ELSE
SET @DYNSQL_INSERT += 'AND TERM.TERM_VALUE = ''' + @pSEARCH_TERM + '''' + char(10)
END
IF @pType = 'VARCHAR'
SET @DYNSQL_INSERT += 'AND LANG.LANG_CODE = ''' + @pLANG_CODE + '''' + char(10)
PRINT @DYNSQL_INSERT
EXEC sp_executesql @DYNSQL_INSERT
END
GO
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_SEARCH_GET_TEXT_RESULTS] (@pUSR_ID as INTEGER,@pSEARCH_TERM as VARCHAR(900),@pDATE_RESTRICTION VARCHAR(500), @pLANG_CODE as VARCHAR(5) = 'de-DE')
AS
BEGIN
DECLARE @SRCH_VAR VARCHAR(900), @DYNSQL_INSERT NVARCHAR(MAX),@DateStr VARCHAR(100)
DECLARE @DATE1 DATE,@DATE2 DATE
IF @pSEARCH_TERM like '%*%'
SET @SRCH_VAR = ' "' + @pSEARCH_TERM + '" '
ELSE
SET @SRCH_VAR = @pSEARCH_TERM
PRINT '@SRCH_VAR [' + @SRCH_VAR + ']'
DELETE FROM TBIDB_SEARCH_RESULT_DOCS WHERE USR_ID = @pUSR_ID;
IF LEN(@pDATE_RESTRICTION) > 0
BEGIN
PRINT '@pDATE_RESTRICTION....'
DECLARE @IDX TINYINT, @ATTR_ID VARCHAR(100)
SET @IDX = CHARINDEX('~',@pDATE_RESTRICTION)
PRINT '@IDX: ' + CONVERT(VARCHAR(10),@IDX)
SET @ATTR_ID = LEFT(@pDATE_RESTRICTION,@IDX-1)
PRINT CONVERT(VARCHAR(10),@ATTR_ID)
SET @DateStr = SUBSTRING(@pDATE_RESTRICTION,@IDX + 1,LEN(@pDATE_RESTRICTION)-@IDX)
PRINT @DateStr
END
--###############################################################################
--SUCHE NACH TERM-WERTEN
EXEC PRIDB_SEARCH_GET_ATTRIBUTE_RESULT @pUSR_ID,'VARCHAR', @DateStr,@pSEARCH_TERM, @pLANG_CODE;
EXEC PRIDB_SEARCH_GET_ATTRIBUTE_RESULT @pUSR_ID,'BIG INTEGER', @DateStr,@pSEARCH_TERM, @pLANG_CODE;
--###############################################################################
--SUCHE NACH STRUCTURE/DOCTYPE-WERTEN
SET @DYNSQL_INSERT = 'INSERT INTO TBIDB_SEARCH_RESULT_DOCS(DocID, USR_ID)
select A.IDB_OBJ_ID, ' + CONVERT(VARCHAR(10),@pUSR_ID) + char(10) +
'FROM VWIDB_DOC_DOCTYPE A' + char(10)
+ CHAR(9) + 'INNER JOIN TBIDB_TERM_VALUE_VARCHAR TERM ON A.TERM_ID = TERM.GUID
WHERE
A.OBJ_ACTIVE = 1' + char(10)
IF @DateStr = 'DATEPART'
BEGIN
SELECT @DATE1 = DATE_FROM ,@DATE2 = DATE_TILL FROM TBIDB_SEARCH_DATE_VALUE_USER WHERE USR_ID = @pUSR_ID;
SET @DYNSQL_INSERT += 'AND CONVERT(DATE,OBJ.ADDED_WHEN) >= CONVERT(DATE,''' + CONVERT(VARCHAR(10),@DATE1) + ''') AND CONVERT(DATE,OBJ.ADDED_WHEN) <= CONVERT(DATE,''' + CONVERT(VARCHAR(10),@DATE2) + ''')' + char(10)
END
ELSE IF @DateStr = 'ECM_CREATED_TODAY'
SET @DYNSQL_INSERT += 'AND DATEDIFF(DAY,OBJ_ADDED_WHEN,GETDATE()) = 0' + char(10)
ELSE IF @DateStr = 'ECM_CREATED_YESTERDAY'
SET @DYNSQL_INSERT += 'AND DATEDIFF(DAY,OBJ_ADDED_WHEN,GETDATE()) = 1' + char(10)
ELSE IF @DateStr = 'ECM_CREATED_LAST7DAYS'
SET @DYNSQL_INSERT += 'AND DATEDIFF(DAY,OBJ_ADDED_WHEN,GETDATE()) <= 7' + char(10)
ELSE IF @DateStr = 'ECM_YEAR_CURRENT'
SET @DYNSQL_INSERT += 'AND DATEPART(YEAR,OBJ_ADDED_WHEN) = DATEPART(YEAR,GETDATE())' + char(10)
ELSE IF @DateStr = 'ECM_YEAR_LAST'
SET @DYNSQL_INSERT += 'AND DATEPART(YEAR,OBJ_ADDED_WHEN) = DATEPART(YEAR,GETDATE())-1' + char(10)
ELSE IF @DateStr = 'ECM_CREATED_MONTH_CURRENT'
BEGIN
SET @DYNSQL_INSERT += 'AND DATEPART(YEAR,OBJ_ADDED_WHEN) = DATEPART(YEAR,GETDATE())' + char(10)
SET @DYNSQL_INSERT += 'AND DATEPART(MONTH,OBJ_ADDED_WHEN) = DATEPART(MONTH,GETDATE())' + char(10)
END
ELSE IF @DateStr = 'ECM_CREATED_MONTH_LAST'
BEGIN
IF DATEPART(MONTH,GETDATE()) = 1
BEGIN
SET @DYNSQL_INSERT += 'AND DATEPART(YEAR,OBJ_ADDED_WHEN) = DATEPART(YEAR,GETDATE())-1' + char(10)
SET @DYNSQL_INSERT += 'AND DATEPART(MONTH,OBJ_ADDED_WHEN) = 12' + char(10)
END
ELSE
BEGIN
SET @DYNSQL_INSERT += 'AND DATEPART(YEAR,OBJ_ADDED_WHEN) = DATEPART(YEAR,GETDATE())' + char(10)
SET @DYNSQL_INSERT += 'AND DATEPART(MONTH,OBJ_ADDED_WHEN) = DATEPART(MONTH,GETDATE())-1' + char(10)
END
END
IF LEN(@SRCH_VAR) > 0
BEGIN
IF @pSEARCH_TERM like '%*%'
SET @DYNSQL_INSERT += 'AND CONTAINS(TERM.TERM_VALUE,''' + @SRCH_VAR + ''')' + char(10)
ELSE
SET @DYNSQL_INSERT += 'AND TERM.TERM_VALUE = ''' + @SRCH_VAR + '''' + char(10)
END
SET @DYNSQL_INSERT += 'AND LANG_CODE = ''' + @pLANG_CODE + '''' + char(10) +
'AND A.IDB_OBJ_ID NOT IN (SELECT DocID FROM TBIDB_SEARCH_RESULT_DOCS WHERE USR_ID = ' + CONVERT(VARCHAR(10),@pUSR_ID) + ')'
PRINT @DYNSQL_INSERT
EXEC sp_executesql @DYNSQL_INSERT
END
GO
--DROP TABLE TBIDB_SEARCH_PROFILE
--DROP TABLE TBIDB_SEARCH_LANGUAGE_SQL_RESULT
--DROP TABLE TBIDB_SEARCH_PROFILE_USER_GROUP
CREATE TABLE TBIDB_SEARCH_PROFILE
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
COMMENT VARCHAR(900),
ACTIVE BIT NOT NULL DEFAULT 1,
ADDED_WHO BIGINT,
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
CHANGED_WHO BIGINT,
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_SEARCH_PROFILE PRIMARY KEY (GUID),
CONSTRAINT FK_TBIDB_SEARCH_PROFILE_ADDED_WHO_T_ID FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT FK_TBIDB_SEARCH_PROFILE_CHANGED_WHO_T_ID FOREIGN KEY (CHANGED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
)
GO
CREATE TRIGGER TBIDB_SEARCH_PROFILE_AFT_UPD ON TBIDB_SEARCH_PROFILE
FOR UPDATE
AS
UPDATE TBIDB_SEARCH_PROFILE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_SEARCH_PROFILE.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_SEARCH_RESULT_ATTRIBUTES
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
SEARCH_PROFIL_ID INTEGER NOT NULL,
ATTRIBUTE_ID INTEGER NOT NULL,
SEQUENCE INTEGER DEFAULT 0,
ADDED_WHO BIGINT,
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
CONSTRAINT PK_TBIDB_SEARCH_RESULT_ATTRIBUTES_GUID PRIMARY KEY (GUID),
CONSTRAINT FK_TBIDB_SEARCH_RESULT_ATTRIBUTES_SPID FOREIGN KEY (SEARCH_PROFIL_ID) REFERENCES TBIDB_SEARCH_PROFILE (GUID),
CONSTRAINT FK_TBIDB_SEARCH_RESULT_ATTRIBUTES_ADDED_WHO FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT UQ_TBIDB_SEARCH_RESULT_ATTRIBUTES UNIQUE(SEARCH_PROFIL_ID,ATTRIBUTE_ID)
)
GO
CREATE TABLE TBIDB_SEARCH_LANGUAGE_SQL_RESULT
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
SEARCH_PROFIL_ID INTEGER NOT NULL,
LANGUAGE_ID TINYINT NOT NULL,
SEARCH_TERM_ID BIGINT NOT NULL,
ADDED_WHO BIGINT,
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
CHANGED_WHO BIGINT,
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_SEARCH_LANGUAGE_SQL_RESULT_GUID PRIMARY KEY (GUID),
CONSTRAINT FK_TBIDB_SEARCH_LANGUAGE_SQL_RESULT_P_ID FOREIGN KEY (SEARCH_PROFIL_ID) REFERENCES TBIDB_SEARCH_PROFILE (GUID),
CONSTRAINT FK_TBIDB_SEARCH_LANGUAGE_SQL_RESULT_LID FOREIGN KEY (LANGUAGE_ID) REFERENCES TBIDB_LANGUAGE (GUID),
CONSTRAINT FK_TBIDB_SEARCH_LANGUAGE_SQL_RESULT_STID FOREIGN KEY (SEARCH_TERM_ID) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT FK_TBIDB_SEARCH_LANGUAGE_SQL_RESULT_ADDED_WHO FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT FK_TBIDB_SEARCH_LANGUAGE_SQL_RESULT_CHANGED_WHO FOREIGN KEY (CHANGED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
--CONSTRAINT FK_TBIDB_SEARCH_PROFILE_USER_USER_ID FOREIGN KEY (USER_ID) REFERENCES @MY_DD_ECM_DB.dbo.TBDD_USER (GUID),
CONSTRAINT UQ_TBIDB_SEARCH_LANGUAGE_SQL_RESULT UNIQUE(SEARCH_PROFIL_ID,LANGUAGE_ID)
)
GO
CREATE TRIGGER TBIDB_SEARCH_LANGUAGE_SQL_RESULT_AFT_UPD ON TBIDB_SEARCH_LANGUAGE_SQL_RESULT
FOR UPDATE
AS
UPDATE TBIDB_SEARCH_LANGUAGE_SQL_RESULT SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_SEARCH_LANGUAGE_SQL_RESULT .GUID = INSERTED.GUID
GO
--DROP TABLE TBIDB_SEARCH_PROFILE_USER_GROUP
CREATE TABLE TBIDB_SEARCH_PROFILE_USER_GROUP
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
SEARCH_PROFIL_ID INTEGER NOT NULL,
USER_ID INTEGER NOT NULL DEFAULT 0,
GROUP_ID INTEGER NOT NULL DEFAULT 0,
ADDED_WHO BIGINT,
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
CONSTRAINT PK_TBIDB_SEARCH_PROFILE_USER_GUID PRIMARY KEY (GUID),
CONSTRAINT FK_TBIDB_SEARCH_PROFILE_USER_PID FOREIGN KEY (SEARCH_PROFIL_ID) REFERENCES TBIDB_SEARCH_PROFILE (GUID),
CONSTRAINT FK_TBIDB_SEARCH_PROFILE_USER_ADDED_WHO FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
--CONSTRAINT FK_TBIDB_SEARCH_PROFILE_USER_USER_ID FOREIGN KEY (USER_ID) REFERENCES @MY_DD_ECM_DB.dbo.TBDD_USER (GUID),
CONSTRAINT UQ_TBIDB_SEARCH_PROFILE_USER UNIQUE(SEARCH_PROFIL_ID,USER_ID,GROUP_ID)
)
GO
--CREATE TABLE TBIDB_SEARCH_PROFILE_GROUP
--(
-- GUID INTEGER NOT NULL IDENTITY (1, 1),
-- SEARCH_PROFIL_ID INTEGER NOT NULL,
-- GROUP_ID INTEGER NOT NULL,
-- ADDED_WHO BIGINT,
-- ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
-- CONSTRAINT PK_TBIDB_SEARCH_PROFILE_GROUP_GUID PRIMARY KEY (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_PROFILE_GROUP_P_ID FOREIGN KEY (SEARCH_PROFIL_ID) REFERENCES TBIDB_SEARCH_PROFILE (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_PROFILE_GROUP_ADDED_WHO FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
-- --CONSTRAINT FK_TBIDB_SEARCH_PROFILE_USER_USER_ID FOREIGN KEY (USER_ID) REFERENCES @MY_DD_ECM_DB.dbo.TBDD_USER (GUID),
-- CONSTRAINT UQ_TBIDB_SEARCH_PROFILE_GROUP UNIQUE(SEARCH_PROFIL_ID,GROUP_ID)
--)
--GO
----DROP TABLE TBIDB_SEARCH_PROFILE_ATTRIBUTES
--CREATE TABLE TBIDB_SEARCH_PROFILE_ATTRIBUTES
--(
-- GUID INTEGER NOT NULL IDENTITY (1, 1),
-- SEARCH_PROFIL_ID INTEGER NOT NULL,
-- ATTRIBUTE_ID INTEGER NOT NULL,
-- X_LOC FLOAT NOT NULL DEFAULT 0,
-- Y_LOC FLOAT NOT NULL DEFAULT 0,
-- [SEQUENCE] INTEGER NOT NULL DEFAULT 0,
-- HEIGHT SMALLINT NOT NULL DEFAULT 25,
-- WIDTH SMALLINT NOT NULL DEFAULT 200,
-- MULTISELECT BIT NOT NULL DEFAULT 0,
-- SOURCE_SQL BIGINT,
-- ENABLE_SQL BIGINT,
-- ENABLE_CONID SMALLINT,
-- --DEPENDING_ATTRIBUTE1 INTEGER NOT NULL DEFAULT 0,
-- ADDED_WHO BIGINT,
-- ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
-- CHANGED_WHO BIGINT,
-- CHANGED_WHEN DATETIME,
-- CONSTRAINT PK_TBIDB_SEARCH_PROFILE_ATTRIBUTES_GUID PRIMARY KEY (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_PROFILE_ATTRIBUTES_P_ID FOREIGN KEY (SEARCH_PROFIL_ID) REFERENCES TBIDB_SEARCH_PROFILE (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_PROFILE_ATTRIBUTES_ADDED_WHO FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_PROFILE_ATTRIBUTES_CHANGED_WHO FOREIGN KEY (CHANGED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_PROFILE_ATTRIBUTES_SOURCE_SQL FOREIGN KEY (SOURCE_SQL) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_PROFILE_ATTRIBUTES_ENABLE_SQL FOREIGN KEY (ENABLE_SQL) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
-- CONSTRAINT UQ_TBIDB_SEARCH_PROFILE_ATTRIBUTES UNIQUE(SEARCH_PROFIL_ID,ATTRIBUTE_ID)
--)
--GO
--CREATE TRIGGER TBIDB_SEARCH_PROFILE_ATTRIBUTES_AFT_UPD ON TBIDB_SEARCH_PROFILE_ATTRIBUTES
--FOR UPDATE
--AS
-- UPDATE TBIDB_SEARCH_PROFILE_ATTRIBUTES SET CHANGED_WHEN = GETDATE()
-- FROM INSERTED
-- WHERE TBIDB_SEARCH_PROFILE_ATTRIBUTES .GUID = INSERTED.GUID
--GO
----drop table TBIDB_SEARCH_ATTRIBUTES_LINKS;
--CREATE TABLE TBIDB_SEARCH_ATTRIBUTES_LINKS
--(
-- GUID INTEGER NOT NULL IDENTITY (1, 1),
-- DEP_ATTR_ID INTEGER NOT NULL,
-- LINKED_ATTR_ID INTEGER NOT NULL,
-- ADDED_WHO BIGINT,
-- ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
-- CHANGED_WHO BIGINT,
-- CHANGED_WHEN DATETIME,
-- CONSTRAINT PK_TBIDB_SEARCH_ATTRIBUTES_LINKS_GUID PRIMARY KEY (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_ATTRIBUTES_LINKS_DA_ID FOREIGN KEY (DEP_ATTR_ID) REFERENCES TBIDB_SEARCH_PROFILE_ATTRIBUTES (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_ATTRIBUTES_LINKS_LA_ID FOREIGN KEY (LINKED_ATTR_ID) REFERENCES TBIDB_SEARCH_PROFILE_ATTRIBUTES (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_ATTRIBUTES_LINKS_ADDED_WHO FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_ATTRIBUTES_LINKS_CHANGED_WHO FOREIGN KEY (CHANGED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID)
--)
--GO
----DROP TABLE TBIDB_SEARCH_RESTRICTIONS_INPUT
--CREATE TABLE TBIDB_SEARCH_RESTRICTIONS_INPUT
--(
-- GUID INTEGER NOT NULL IDENTITY (1, 1),
-- SEARCH_ID INTEGER NOT NULL,
-- RESTR_ATTR_ID INTEGER NOT NULL,
-- SOURCE_ATTR_ID INTEGER NOT NULL,
-- TERM VARCHAR(900) NOT NULL,
-- USR_ID INTEGER NOT NULL,
-- ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
-- CONSTRAINT PK_TBIDB_SEARCH_RESTRICTIONS_INPUT_GUID PRIMARY KEY (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_RESTRICTIONS_INPUT_SID FOREIGN KEY (SEARCH_ID) REFERENCES TBIDB_SEARCH_PROFILE (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_RESTRICTIONS_INPUT_RA_ID FOREIGN KEY (RESTR_ATTR_ID) REFERENCES TBIDB_SEARCH_PROFILE_ATTRIBUTES (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_RESTRICTIONS_INPUT_SA_ID FOREIGN KEY (SOURCE_ATTR_ID) REFERENCES TBIDB_SEARCH_PROFILE_ATTRIBUTES (GUID),
--)
--GO
--CREATE TABLE TBIDB_SEARCH_RESTRICTIONS_OBJECTS
--(
-- GUID INTEGER NOT NULL IDENTITY (1, 1),
-- SEARCH_ID INTEGER NOT NULL,
-- RESTR_ATTR_ID INTEGER NOT NULL,
-- SOURCE_ATTR_ID INTEGER NOT NULL,
-- IDB_OBJ_ID BIGINT NOT NULL,
-- USR_ID INTEGER NOT NULL,
-- ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
-- CONSTRAINT PK_TBIDB_SEARCH_RESTRICTIONS_OBJECTS_GUID PRIMARY KEY (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_RESTRICTIONS_OBJECTS_SID FOREIGN KEY (SEARCH_ID) REFERENCES TBIDB_SEARCH_PROFILE (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_RESTRICTIONS_OBJECTS_RA_ID FOREIGN KEY (RESTR_ATTR_ID) REFERENCES TBIDB_SEARCH_PROFILE_ATTRIBUTES (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_RESTRICTIONS_OBJECTS_SA_ID FOREIGN KEY (SOURCE_ATTR_ID) REFERENCES TBIDB_SEARCH_PROFILE_ATTRIBUTES (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_RESTRICTIONS_OBJECTS_IOBJ_ID FOREIGN KEY (IDB_OBJ_ID) REFERENCES TBIDB_OBJECT (IDB_OBJ_ID)
--)
--GO
--CREATE TRIGGER [dbo].[TBIDB_SEARCH_RESTRICTIONS_INPUT_AFT_INS] ON [dbo].[TBIDB_SEARCH_RESTRICTIONS_INPUT]
--WITH EXECUTE AS CALLER
--FOR INSERT
--AS
--BEGIN TRY
-- DECLARE
-- @SEARCH_ID INTEGER,
-- @RESTR_ATTR_ID INTEGER,
-- @SOURCE_ATTR_ID INTEGER,
-- @TERM VARCHAR(900),
-- @USR_ID INTEGER,
-- @pLANG_CODE VARCHAR(5)
-- SELECT
-- @SEARCH_ID = SEARCH_ID,
-- @RESTR_ATTR_ID = RESTR_ATTR_ID,
-- @SOURCE_ATTR_ID = SOURCE_ATTR_ID,
-- @TERM = TERM,
-- @USR_ID = USR_ID
-- FROM INSERTED
-- --DELETE FROM TBIDB_SEARCH_RESTRICTIONS_OBJECTS
-- --WHERE
-- -- SEARCH_ID = @SEARCH_ID AND
-- -- RESTR_ATTR_ID = @RESTR_ATTR_ID AND
-- -- SOURCE_ATTR_ID = @SOURCE_ATTR_ID AND
-- -- USR_ID = @USR_ID;
-- SELECT @pLANG_CODE = [LANGUAGE] FROM @MY_DD_ECM_DB.dbo.TBDD_USER WHERE GUID = @USR_ID
-- INSERT INTO TBIDB_SEARCH_RESTRICTIONS_OBJECTS (SEARCH_ID,RESTR_ATTR_ID, SOURCE_ATTR_ID, IDB_OBJ_ID, USR_ID)
-- SELECT @SEARCH_ID,@RESTR_ATTR_ID, @SOURCE_ATTR_ID,T.IDB_OBJECT_ID,@USR_ID
-- FROM [dbo].[FNIDB_GET_TERM_FOR_ATTRIBUTE_ID] (@SOURCE_ATTR_ID,@pLANG_CODE,@USR_ID) T LEFT JOIN TBIDB_SEARCH_RESTRICTIONS_OBJECTS T1
-- ON T.IDB_OBJECT_ID = T1.IDB_OBJ_ID
-- where T.TERM_VALUE = @TERM AND T1.IDB_OBJ_ID IS NULL
-- --where TERM_VALUE = @TERM
--END TRY
--BEGIN CATCH
-- PRINT 'ERROR IN TRIGGER: ' + CONVERT(VARCHAR(30),ERROR_PROCEDURE())
-- + ' - ERROR-MESSAGE: '
-- + CONVERT(VARCHAR(500),ERROR_MESSAGE())
--END CATCH
--GO
CREATE TABLE [dbo].[TBIDB_LANGUAGE_TERM_METADATA](
[GUID] [bigint] NOT NULL,
[LANG_TERM_ID] [bigint] NOT NULL,
[ADDED_WHO] [bigint] NOT NULL,
[ADDED_WHEN] [datetime] NOT NULL,
[CHANGED_WHO] [bigint] NULL,
[CHANGED_WHEN] [datetime] NULL,
CONSTRAINT [PKTBIDB_LANGUAGE_TERM_METADATA] PRIMARY KEY CLUSTERED
(
[GUID] ASC,
[LANG_TERM_ID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[TBIDB_LANGUAGE_TERM_METADATA] ADD DEFAULT (getdate()) FOR [ADDED_WHEN]
GO
ALTER TABLE [dbo].[TBIDB_LANGUAGE_TERM_METADATA] WITH CHECK ADD CONSTRAINT [FK_TBIDB_LTMD_ADDED_WHO_T_ID] FOREIGN KEY([ADDED_WHO])
REFERENCES [dbo].[TBIDB_TERM_VALUE_VARCHAR] ([GUID])
GO
ALTER TABLE [dbo].[TBIDB_LANGUAGE_TERM_METADATA] CHECK CONSTRAINT [FK_TBIDB_LTMD_ADDED_WHO_T_ID]
GO
ALTER TABLE [dbo].[TBIDB_LANGUAGE_TERM_METADATA] WITH CHECK ADD CONSTRAINT [FK_TBIDB_LTMD_CHANGED_WHO_T_ID] FOREIGN KEY([CHANGED_WHO])
REFERENCES [dbo].[TBIDB_TERM_VALUE_VARCHAR] ([GUID])
GO
ALTER TABLE [dbo].[TBIDB_LANGUAGE_TERM_METADATA] CHECK CONSTRAINT [FK_TBIDB_LTMD_CHANGED_WHO_T_ID]
GO
CREATE NONCLUSTERED INDEX [TBIDB_LANGUAGE_TERM_METADATA_LANG_TERM_ID]
ON [dbo].[TBIDB_LANGUAGE_TERM_METADATA] ([LANG_TERM_ID])
GO
CREATE NONCLUSTERED INDEX [IDXTBIDB_OBJECT_METADATA2]
ON [dbo].[TBIDB_OBJECT_METADATA] ([ATTR_ID])
INCLUDE ([IDB_OBJ_ID],[INT_TERM_ID],[ADDED_WHO],[ADDED_WHEN])
GO
CREATE NONCLUSTERED INDEX [IDXTBIDB_OBJECT_METADATA3]
ON [dbo].[TBIDB_OBJECT_METADATA] ([ATTR_ID])
INCLUDE ([IDB_OBJ_ID],[FLOAT_TERM_ID],[ADDED_WHO],[ADDED_WHEN])
GO
CREATE NONCLUSTERED INDEX [IDXTBIDB_OBJECT_METADATA_ATTR_ID_[FLOAT_TERM_ID]
ON [dbo].[TBIDB_OBJECT_METADATA] ([ATTR_ID],[FLOAT_TERM_ID])
INCLUDE ([IDB_OBJ_ID],[ADDED_WHO],[ADDED_WHEN])
GO
CREATE NONCLUSTERED INDEX IDX_CHANGED_WHEN
ON [dbo].[TBIDB_OBJECT_METADATA_CHANGE] ([CHANGED_WHEN])
INCLUDE ([GUID])
GO
CREATE NONCLUSTERED INDEX IDX_CHANGED_WHEN_IDBOBJID
ON [dbo].[TBIDB_OBJECT_METADATA_CHANGE] ([IDB_OBJ_ID])
INCLUDE ([CHANGED_WHEN])
GO
CREATE TABLE TBIDB_CONVERSATION_MESSAGE
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
CONV_ID BIGINT NOT NULL,
TO_USER BIGINT NOT NULL DEFAULT 0,
FROM_USER BIGINT NOT NULL,
MESSAGE_TERM_ID BIGINT NOT NULL,
ADDED_WHO BIGINT,
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
CONSTRAINT PK_TBIDB_CONVERSATION_MESSAGE PRIMARY KEY (GUID),
CONSTRAINT FK_TBIDB_CONVERSATION_MESSAGE_CONV_ID FOREIGN KEY (CONV_ID) REFERENCES TBIDB_CONVERSATION_OBJECT (GUID),
CONSTRAINT FK_TBIDB_CONVERSATION_MESSAGE_MESSAGE_FROM_USER FOREIGN KEY (FROM_USER) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT FK_TBIDB_CONVERSATION_MESSAGE_ADDED_WHO FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),)
GO
--CREATE TABLE TBIDB_USER_SEARCH_CRITERIA
--(
-- GUID BIGINT NOT NULL IDENTITY (1, 1),
-- SEARCH_PROFIL_ID INTEGER NOT NULL,
-- USERID INTEGER NOT NULL,
-- ATTRIBUTE_ID INTEGER NOT NULL,
-- TERM_TEXT VARCHAR(900),
-- --TERM_DATE DATE,
-- --TERM_FLOAT FLOAT,
-- --TERM_DEC DECIMAL(19,2),
-- TERM_ID BIGINT,
-- ADDED_WHO BIGINT,
-- ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
-- CONSTRAINT PK_TBIDB_USER_SEARCH_CRITERIA_GUID PRIMARY KEY (GUID),
-- CONSTRAINT FK_TBIDB_USER_SEARCH_CRITERIA_SPID FOREIGN KEY (SEARCH_PROFIL_ID) REFERENCES TBIDB_SEARCH_PROFILE (GUID),
-- CONSTRAINT FK_TBIDB_USER_SEARCH_CRITERIA_ADDED_WHO FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID)
--)
--GO
--CREATE TABLE TBIDB_SEARCH_CRITERIA_SAVE
--(
-- GUID BIGINT NOT NULL IDENTITY (1, 1),
-- SEARCH_PROFIL_ID INTEGER NOT NULL,
-- ATTRIBUTE_ID INTEGER NOT NULL,
-- TERM_TEXT VARCHAR(900),
-- --TERM_DATE DATE,
-- --TERM_FLOAT FLOAT,
-- --TERM_DEC DECIMAL(19,2),
-- TERM_ID BIGINT,
-- ADDED_WHO BIGINT,
-- ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
-- CONSTRAINT PK_TBIDB_SEARCH_CRITERIA_SAVE_GUID PRIMARY KEY (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_CRITERIA_SAVE_SPID FOREIGN KEY (SEARCH_PROFIL_ID) REFERENCES TBIDB_SEARCH_PROFILE (GUID),
-- CONSTRAINT FK_TBIDB_SEARCH_CRITERIA_SAVE_ADDED_WHO FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID)
--)
--GO
CREATE TABLE TBIDB_ACCESSRIGHT
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
IDB_OBJ_ID BIGINT NOT NULL,
USR_ID INTEGER NOT NULL DEFAULT 0,
GRP_ID INTEGER NOT NULL DEFAULT 0,
ACCESSRIGHT INTEGER NOT NULL,
COMMENT VARCHAR(250),
ADDED_WHO BIGINT NOT NULL,
ADDED_WHEN DATETIME DEFAULT GETDATE(),
CONSTRAINT PK_TBIDB_ACCESSRIGHT_GUID PRIMARY KEY (GUID),
CONSTRAINT FK_TBIDB_ACCESSRIGHT_IDB_OBJ_ID FOREIGN KEY (IDB_OBJ_ID) REFERENCES TBIDB_OBJECT (IDB_OBJ_ID),
CONSTRAINT FK_TBIDB_ACCESSRIGHT_ADDED_WHO FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT UQ_TBIDB_ACCESSRIGHT UNIQUE(IDB_OBJ_ID,USR_ID,GRP_ID,ACCESSRIGHT)
)
GO
CREATE NONCLUSTERED INDEX IDX_TBIDB_ACCESSRIGHT_USRID
ON [dbo].[TBIDB_ACCESSRIGHT] ([USR_ID])
INCLUDE ([IDB_OBJ_ID])
GO
CREATE NONCLUSTERED INDEX IDX_TBIDB_ACCESSRIGHT_GRPID
ON [dbo].[TBIDB_ACCESSRIGHT] ([GRP_ID])
INCLUDE ([IDB_OBJ_ID])
GO
CREATE TABLE TBIDB_REFRESH_ON_APPSERVER
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
IDB_OBJ_ID BIGINT NOT NULL,
USR_ID INTEGER NOT NULL,
ACCESSRIGHT INTEGER NOT NULL,
ADDED_WHO BIGINT NOT NULL,
ADDED_WHEN DATETIME DEFAULT GETDATE(),
CONSTRAINT PKTBIDB_REFRESH_ON_APPSERVER_GUID PRIMARY KEY (GUID),
CONSTRAINT FKTBIDB_REFRESH_ON_APPSERVER_IDB_OBJ_ID FOREIGN KEY (IDB_OBJ_ID) REFERENCES TBIDB_OBJECT (IDB_OBJ_ID),
CONSTRAINT FKTBIDB_REFRESH_ON_APPSERVER_ADDED_WHO FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT UQ_TBIDB_REFRESH_ON_APPSERVER UNIQUE(IDB_OBJ_ID,USR_ID)
)
GO
CREATE NONCLUSTERED INDEX [IDX_ATTR-ID_OBJ-INTTERMID]
ON [dbo].[TBIDB_OBJECT_METADATA] ([ATTR_ID])
INCLUDE ([IDB_OBJ_ID],[INT_TERM_ID])
GO
CREATE NONCLUSTERED INDEX IDXATTR_IDINT_TERM_ID_IDB_OBJ_ID
ON [dbo].[TBIDB_OBJECT_METADATA] ([ATTR_ID],[INT_TERM_ID])
INCLUDE ([IDB_OBJ_ID])
GO
CREATE NONCLUSTERED INDEX IDX_DELETED_OBJID
ON [dbo].[TBIDB_OBJECT] ([DELETED])
INCLUDE ([IDB_OBJ_ID])
GO
CREATE NONCLUSTERED INDEX [IDXATTR_ID-IDB_OBJ_ID-FLOAT_TERM_ID]
ON [dbo].[TBIDB_OBJECT_METADATA] ([ATTR_ID])
INCLUDE ([IDB_OBJ_ID],[FLOAT_TERM_ID])
GO
CREATE NONCLUSTERED INDEX [ATTR_ID_IDB_OBJ_ID_DEC_TERM_ID]
ON [dbo].[TBIDB_OBJECT_METADATA] ([ATTR_ID])
INCLUDE ([IDB_OBJ_ID],[DEC_TERM_ID])
GO
CREATE NONCLUSTERED INDEX [ATTR_ID-IDB_OBJ_ID-DATE_TERM_ID]
ON [dbo].[TBIDB_OBJECT_METADATA] ([ATTR_ID])
INCLUDE ([IDB_OBJ_ID],[DATE_TERM_ID])
GO
CREATE NONCLUSTERED INDEX [IDXATTR_ID-DATE_TERM_ID-IDB_OBJ_ID]
ON [dbo].[TBIDB_OBJECT_METADATA] ([ATTR_ID],[DATE_TERM_ID])
INCLUDE ([IDB_OBJ_ID])
GO
--CREATE TABLE TBIDB_FLOW_SEARCH_CATEGORY_ATTRIBUTES
--(
-- GUID BIGINT NOT NULL IDENTITY (1, 1),
-- ATTRIBUTE_ID INTEGER NOT NULL,
-- ACTIVE BIT NOT NULL DEFAULT 1,
-- ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM (DEF)',
-- ADDED_WHEN DATETIME DEFAULT GETDATE(),
-- CHANGED_WHO VARCHAR(100),
-- CHANGED_WHEN DATETIME,
-- CONSTRAINT PKTBIDB_FLOW_SEARCH_CATEGORY_ATTRIBUTES_GUID PRIMARY KEY (GUID),
-- CONSTRAINT UQ_TBIDB_FLOW_SEARCH_CATEGORY_ATTRIBUTES UNIQUE(ATTRIBUTE_ID),
-- CONSTRAINT FK_TBIDB_FLOW_SEARCH_CATEGORY_ATTRIBUTES FOREIGN KEY (ATTRIBUTE_ID) REFERENCES TBIDB_ATTRIBUTE (GUID),
--)
--GO
--INSERT INTO TBIDB_FLOW_SEARCH_CATEGORY_ATTRIBUTES (ATTRIBUTE_ID) VALUES(1);
--ALTER TABLE [TBIDB_FILE_OBJECT]
--ADD [FILE_HASH] VARCHAR(500) NOT NULL
--GO
CREATE TABLE TBIDB_FILE_OBJECT
(
IDB_OBJ_ID BIGINT NOT NULL,
OBJ_ST_ID INTEGER NOT NULL,
EXTENSION_TERM_ID BIGINT NOT NULL,
RELPATH_TERM_ID BIGINT NOT NULL,
FILENAME_TERM_ID BIGINT NOT NULL,
FILE_SIZE BIGINT,
FILE_HASH VARCHAR(500) NOT NULL,
FULLTEXT_CREATED DATETIME,
ADDED_WHO VARCHAR(30) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(30),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_FILE_OBJECT PRIMARY KEY (IDB_OBJ_ID),
CONSTRAINT FK_TBIDB_FILE_OBJECT_OBJSTID FOREIGN KEY (OBJ_ST_ID) REFERENCES TBIDB_OBJECT_STORE (GUID),
CONSTRAINT FK_TBIDB_FILE_OBJECT_IDBOBJID FOREIGN KEY (IDB_OBJ_ID) REFERENCES TBIDB_OBJECT (IDB_OBJ_ID),
CONSTRAINT FK_TBIDB_FILE_OBJECT_EXTTID FOREIGN KEY (EXTENSION_TERM_ID) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT FK_TBIDB_FILE_OBJECT_RPTID FOREIGN KEY (RELPATH_TERM_ID) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT FK_TBIDB_FILE_OBJECT_FNTID FOREIGN KEY (FILENAME_TERM_ID) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID)
)
GO
CREATE TRIGGER TBIDB_FILE_OBJECT_AFT_UPD ON TBIDB_FILE_OBJECT
FOR UPDATE
AS
UPDATE TBIDB_FILE_OBJECT SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_FILE_OBJECT.IDB_OBJ_ID = INSERTED.IDB_OBJ_ID
GO
CREATE NONCLUSTERED INDEX IDX_CHANGED_WHEN_IN_GUID
ON [dbo].[TBIDB_OBJECT_METADATA_CHANGE] ([CHANGED_WHEN])
INCLUDE ([GUID])
GO
CREATE NONCLUSTERED INDEX IDX_IDBOBJID_CW
ON [dbo].[TBIDB_OBJECT_METADATA_CHANGE] ([IDB_OBJ_ID])
INCLUDE ([CHANGED_WHEN])
GO
CREATE NONCLUSTERED INDEX [IDXTBIDB_OBJECT_METADATA4]
ON [dbo].[TBIDB_OBJECT_METADATA] ([ATTR_ID])
INCLUDE ([IDB_OBJ_ID],[DEC_TERM_ID],[ADDED_WHO],[ADDED_WHEN])
GO
CREATE NONCLUSTERED INDEX [IDXTBIDB_OBJECT_METADATA5]
ON [dbo].[TBIDB_OBJECT_METADATA] ([ATTR_ID],[DEC_TERM_ID])
INCLUDE ([IDB_OBJ_ID],[ADDED_WHO],[ADDED_WHEN])
GO
CREATE TABLE TBIDB_OBJ_STATES
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
TITLE VARCHAR(500),
ADDED_WHO BIGINT,
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
CHANGED_WHO BIGINT,
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_OBJ_STATES PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_OBJ_STATES UNIQUE (TITLE)
)
GO
CREATE TRIGGER TBIDB_OBJ_STATES_AFT_UPD ON TBIDB_OBJ_STATES
FOR UPDATE
AS
UPDATE TBIDB_OBJ_STATES SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_OBJ_STATES.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_OBJ_STATES_LANGUAGE
(
GUID INTEGER NOT NULL IDENTITY (1, 1),
STATE_ID INTEGER NOT NULL,
LANG_ID TINYINT NOT NULL,
TERM_ID BIGINT NOT NULL,
ADDED_WHO BIGINT,
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
CHANGED_WHO BIGINT,
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_OBJ_STATES_LANGUAGE PRIMARY KEY (GUID),
CONSTRAINT FK_TBIDB_OBJ_STATES_LANGUAGE_STATEID FOREIGN KEY (STATE_ID) REFERENCES TBIDB_OBJ_STATES (GUID),
CONSTRAINT FK_TBIDB_OBJ_STATES_LANGUAGE_LANGID FOREIGN KEY (LANG_ID) REFERENCES TBIDB_LANGUAGE (GUID),
CONSTRAINT FK_TBIDB_OBJ_STATES_LANGUAGE_ADDED_WHO_T_ID FOREIGN KEY (ADDED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),
CONSTRAINT FK_TBIDB_OBJ_STATES_LANGUAGE_CHANGED_WHO_T_ID FOREIGN KEY (CHANGED_WHO) REFERENCES TBIDB_TERM_VALUE_VARCHAR (GUID),)
GO
CREATE TRIGGER TBIDB_OBJ_STATES_LANGUAGE_AFT_UPD ON TBIDB_OBJ_STATES_LANGUAGE
FOR UPDATE
AS
UPDATE TBIDB_OBJ_STATES_LANGUAGE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_OBJ_STATES_LANGUAGE.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_TERM_TYPE
(
GUID INT NOT NULL IDENTITY (1, 1),
TITLE VARCHAR(100) NOT NULL,
ADDED_WHO VARCHAR(100) DEFAULT 'System',
ADDED_WHEN DATETIME NOT NULL DEFAULT GETDATE(),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_TERM_TYPE PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_TERM_TYPE_TITLE UNIQUE (TITLE))
GO
CREATE TRIGGER TBIDB_TERM_TYPE_AFT_UPD ON TBIDB_TERM_TYPE
FOR UPDATE
AS
UPDATE TBIDB_TERM_TYPE SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_TERM_TYPE.GUID = INSERTED.GUID
GO
CREATE TABLE TBIDB_OBJECT_DYNAMIC_FOLDER
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
IDB_OBJ_ID BIGINT NOT NULL,
DYN_FOLD_ID BIGINT NOT NULL,
COMMENT VARCHAR(1000),
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_OBJECT_DYNAMIC_FOLDER PRIMARY KEY (GUID),
CONSTRAINT UQ_TBIDB_OBJECT_DYNAMIC_FOLDER UNIQUE (IDB_OBJ_ID,DYN_FOLD_ID),
CONSTRAINT FK_TBIDB_OBJECT_DYNAMIC_FOLDER_IDBOBJID FOREIGN KEY (IDB_OBJ_ID) REFERENCES TBIDB_OBJECT (IDB_OBJ_ID),
CONSTRAINT FK_TBIDB_OBJECT_DYNAMIC_FOLDER_DYNFOLDID FOREIGN KEY (DYN_FOLD_ID) REFERENCES TBIDB_OBJECT (IDB_OBJ_ID)
)
GO
CREATE TRIGGER TBIDB_OBJECT_DYNAMIC_FOLDER_AFT_UPD ON TBIDB_OBJECT_DYNAMIC_FOLDER
FOR UPDATE
AS
UPDATE TBIDB_OBJECT_DYNAMIC_FOLDER SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_OBJECT_DYNAMIC_FOLDER.GUID = INSERTED.GUID
GO
--DROP TABLE TBIDB_OBJECT_CHECK_IN_OUT
CREATE TABLE TBIDB_OBJECT_CHECK_IN_OUT
(
GUID BIGINT NOT NULL IDENTITY (1, 1),
IDB_OBJ_ID BIGINT NOT NULL,
CHECKED_OUT_WHEN DATETIME NOT NULL,
CHECKED_IN_WHEN DATETIME,
COMMENT VARCHAR(1000),
ADDED_WHO VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
ADDED_WHEN DATETIME NOT NULL DEFAULT (GETDATE()),
CHANGED_WHO VARCHAR(100),
CHANGED_WHEN DATETIME,
CONSTRAINT PK_TBIDB_OBJECT_CHECK_IN_OUT PRIMARY KEY (GUID),
CONSTRAINT FK_TBIDB_OBJECT_CHECK_IN_OUT_IDB_OBJ_ID FOREIGN KEY (IDB_OBJ_ID) REFERENCES TBIDB_OBJECT (IDB_OBJ_ID)
)
GO
CREATE TRIGGER TBIDB_OBJECT_CHECK_IN_OUT_AFT_UPD ON TBIDB_OBJECT_CHECK_IN_OUT
FOR UPDATE
AS
UPDATE TBIDB_OBJECT_CHECK_IN_OUT SET CHANGED_WHEN = GETDATE()
FROM INSERTED
WHERE TBIDB_OBJECT_CHECK_IN_OUT.IDB_OBJ_ID = INSERTED.IDB_OBJ_ID
GO
/*###########################
######### FUNCTIONS #########
#############################*/
CREATE OR ALTER FUNCTION [dbo].[FNIDB_GET_VARIABLE_VALUE] (@IDB_OBJ_ID BIGINT, @ATTRIBUTE VARCHAR(100),@LANG_CODE VARCHAR(10))
RETURNS @Output TABLE (TERM_VALUE NVARCHAR(900), TERM_DATE DATE,TERM_DATETIME DATETIME)
AS
BEGIN
DECLARE
@ATTR_ID INTEGER,
@TYP_ID TINYINT,
@TYP_DESCR VARCHAR(100),
@MULTI BIT,
@TERM_RESULT VARCHAR(900),
@IDB_CREATED_WHEN DATETIME,
@IDB_CREATED_WHO VARCHAR(100),
@IDB_CHANGED_WHEN DATETIME,
@IDB_CHANGED_WHO VARCHAR(100)
SELECT @IDB_CREATED_WHEN = ADDED_WHEN, @IDB_CREATED_WHO = ADDED_WHO, @IDB_CHANGED_WHEN = CHANGED_WHEN, @IDB_CHANGED_WHO = CHANGED_WHO FROM TBIDB_OBJECT
WHERE IDB_OBJ_ID = @IDB_OBJ_ID;
IF @ATTRIBUTE like 'IDB%'
BEGIN
SELECT @IDB_CREATED_WHEN = ADDED_WHEN, @IDB_CREATED_WHO = ADDED_WHO, @IDB_CHANGED_WHEN = CHANGED_WHEN, @IDB_CHANGED_WHO = CHANGED_WHO FROM TBIDB_OBJECT
WHERE IDB_OBJ_ID = @IDB_OBJ_ID
IF @ATTRIBUTE = 'IDBCreatedWhen'
INSERT INTO @Output (TERM_VALUE) VALUES (@IDB_CREATED_WHEN)
ELSE IF @ATTRIBUTE = 'IDBCreatedWho'
INSERT INTO @Output (TERM_VALUE) VALUES (@IDB_CREATED_WHO)
ELSE IF @ATTRIBUTE = 'IDBChangedWhen'
INSERT INTO @Output (TERM_VALUE) VALUES (@IDB_CHANGED_WHEN)
ELSE IF @ATTRIBUTE = 'IDBChangedWho'
INSERT INTO @Output (TERM_VALUE) VALUES (@IDB_CHANGED_WHO)
END
ELSE
BEGIN
SELECT @ATTR_ID = T.GUID, @TYP_ID = T.TYP_ID, @MULTI = T.MULTI_CONTEXT,@TYP_DESCR = T1.NAME_TYPE FROM TBIDB_ATTRIBUTE T, TBIDB_ATTRIBUTE_TYPE T1
WHERE T.TYP_ID = T1.GUID AND UPPER(TITLE) = UPPER(@ATTRIBUTE)
IF @TYP_ID IN (1,8) --VARCHAR
BEGIN
DECLARE @TL_ID BIGINT
INSERT INTO @Output (TERM_VALUE)
SELECT TERM.TERM_VALUE FROM
TBIDB_TERM_VALUE_VARCHAR TERM INNER JOIN TBIDB_LANGUAGE_TERM TLANG ON TERM.GUID = TLANG.TERM_ID
INNER JOIN TBIDB_OBJECT_METADATA MD ON TLANG.OBJECT_ID = MD.GUID
INNER JOIN TBIDB_LANGUAGE LANG ON TLANG.LANG_ID = LANG.GUID
INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE MD.ATTR_ID = @ATTR_ID
AND LANG.LANG_CODE = @LANG_CODE
AND MD.IDB_OBJ_ID = @IDB_OBJ_ID
AND OBJ.ACTIVE = 1
END
ELSE IF @TYP_ID IN (2,7,9) --BIGINT
BEGIN
INSERT INTO @Output (TERM_VALUE)
SELECT TERM.TERM_VALUE FROM TBIDB_TERM_VALUE_INTEGER TERM, TBIDB_OBJECT_METADATA MD WHERE MD.INT_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @ATTR_ID AND IDB_OBJ_ID = @IDB_OBJ_ID
END
ELSE IF @TYP_ID = 3 --FLOAT
BEGIN
INSERT INTO @Output (TERM_VALUE)
SELECT TERM.TERM_VALUE FROM TBIDB_TERM_VALUE_FLOAT TERM, TBIDB_OBJECT_METADATA MD WHERE MD.FLOAT_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @ATTR_ID AND IDB_OBJ_ID = @IDB_OBJ_ID
END
ELSE IF @TYP_ID = 4
BEGIN
INSERT INTO @Output (TERM_VALUE)
SELECT TERM.TERM_VALUE FROM TBIDB_TERM_VALUE_DECIMAL TERM, TBIDB_OBJECT_METADATA MD WHERE MD.DEC_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @ATTR_ID AND IDB_OBJ_ID = @IDB_OBJ_ID
END
ELSE IF @TYP_ID = 5
BEGIN
INSERT INTO @Output (TERM_VALUE)
SELECT TERM.TERM_VALUE FROM TBIDB_TERM_VALUE_DATE TERM, TBIDB_OBJECT_METADATA MD WHERE MD.DATE_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @ATTR_ID AND IDB_OBJ_ID = @IDB_OBJ_ID
END
ELSE IF @TYP_ID = 6
BEGIN
INSERT INTO @Output (TERM_VALUE,TERM_DATETIME)
SELECT TERM.TERM_VALUE,TERM.TERM_VALUE FROM TBIDB_TERM_VALUE_DATETIME TERM, TBIDB_OBJECT_METADATA MD WHERE MD.DATETIME_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @ATTR_ID AND IDB_OBJ_ID = @IDB_OBJ_ID
END
END
RETURN
END
GO
CREATE OR ALTER FUNCTION [dbo].[FNIDB_PM_GET_VARIABLE_VALUE_ROWID] (@DocID BIGINT, @ATTRIBUTE VARCHAR(100),@LANG_CODE VARCHAR(10), @DocID_ISFOREIGN as BIT = False)
RETURNS @Output TABLE (ID INT IDENTITY(1, 1),TERM_VALUE VARCHAR(900))
AS
BEGIN
DECLARE
@ATTR_ID INTEGER,
@TYP_ID TINYINT,
@TYP_DESCR VARCHAR(100),
@MULTI BIT,
@TERM_RESULT VARCHAR(900)
SELECT @ATTR_ID = T.GUID, @TYP_ID = T.TYP_ID, @MULTI = T.MULTI_CONTEXT,@TYP_DESCR = T1.NAME_TYPE FROM TBIDB_ATTRIBUTE T, TBIDB_ATTRIBUTE_TYPE T1
WHERE T.TYP_ID = T1.GUID AND UPPER(TITLE) = UPPER(@ATTRIBUTE);
IF @DocID_ISFOREIGN = 1
SELECT @DocID = IDB_OBJ_ID FROM TBIDB_OBJECT WHERE REFERENCE_KEY = @DocID;
IF @TYP_ID IN (1,8) --VARCHAR
BEGIN
DECLARE @TL_ID BIGINT
INSERT INTO @Output (TERM_VALUE)
SELECT TERM.TERM_VALUE FROM
TBIDB_TERM_VALUE_VARCHAR TERM INNER JOIN TBIDB_LANGUAGE_TERM TLANG ON TERM.GUID = TLANG.TERM_ID
INNER JOIN TBIDB_OBJECT_METADATA MD ON TLANG.OBJECT_ID = MD.GUID
INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
INNER JOIN TBIDB_LANGUAGE LANG ON TLANG.LANG_ID = LANG.GUID
WHERE
MD.ATTR_ID = @ATTR_ID
AND LANG.LANG_CODE = @LANG_CODE
AND MD.IDB_OBJ_ID = @DocID
AND OBJ.ACTIVE = 1;
END
ELSE IF @TYP_ID IN (2,7,9) --BIGINT
BEGIN
INSERT INTO @Output (TERM_VALUE)
SELECT TERM.TERM_VALUE FROM TBIDB_TERM_VALUE_INTEGER TERM, TBIDB_OBJECT_METADATA MD WHERE MD.INT_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @ATTR_ID AND IDB_OBJ_ID = @DocID
END
ELSE IF @TYP_ID = 3 --FLOAT
BEGIN
INSERT INTO @Output (TERM_VALUE)
SELECT TERM.TERM_VALUE FROM TBIDB_TERM_VALUE_FLOAT TERM, TBIDB_OBJECT_METADATA MD WHERE MD.FLOAT_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @ATTR_ID AND IDB_OBJ_ID = @DocID
END
ELSE IF @TYP_ID = 4
BEGIN
INSERT INTO @Output (TERM_VALUE)
SELECT TERM.TERM_VALUE FROM TBIDB_TERM_VALUE_DECIMAL TERM, TBIDB_OBJECT_METADATA MD WHERE MD.DEC_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @ATTR_ID AND IDB_OBJ_ID = @DocID
END
ELSE IF @TYP_ID = 5
BEGIN
INSERT INTO @Output (TERM_VALUE)
SELECT TERM.TERM_VALUE FROM TBIDB_TERM_VALUE_DATE TERM, TBIDB_OBJECT_METADATA MD WHERE MD.DATE_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @ATTR_ID AND IDB_OBJ_ID = @DocID
END
RETURN
END
GO
CREATE FUNCTION [dbo].[FNGetFileName]
(
@Path NVARCHAR(MAX)
)
RETURNS NVARCHAR(MAX)
AS
BEGIN
DECLARE @FileName NVARCHAR(MAX)
DECLARE @ReversedPath NVARCHAR(MAX)
SET @ReversedPath = REVERSE(@Path)
SELECT @FileName = RIGHT(@Path, CHARINDEX('\', @ReversedPath)-1)
RETURN @FileName
END
GO
CREATE FUNCTION [dbo].[FNGetFileNameWithoutExtension]
(
@Path NVARCHAR(MAX)
)
RETURNS NVARCHAR(MAX)
AS
BEGIN
DECLARE @FileName NVARCHAR(MAX)
DECLARE @ReversedPath NVARCHAR(MAX)
DECLARE @ExtLength INT
SET @ReversedPath = REVERSE(@Path)
SELECT @ExtLength = CHARINDEX('.', @ReversedPath)
SELECT @FileName = RIGHT(@Path, CHARINDEX('\', @ReversedPath)-1)
SELECT @FileName = LEFT(@FileName, LEN(@FileName) - @ExtLength)
RETURN @FileName
END
GO
CREATE FUNCTION [dbo].[FNGetDirectoryPath]
(
@Path NVARCHAR(MAX)
)
RETURNS NVARCHAR(MAX)
AS
BEGIN
DECLARE @FileName NVARCHAR(MAX)
DECLARE @ReversedPath NVARCHAR(MAX)
DECLARE @PathLength INT
SET @ReversedPath = REVERSE(@Path)
SELECT @PathLength = CHARINDEX('\', @ReversedPath)
SELECT @FileName = LEFT(@Path, LEN(@Path) - @PathLength)
RETURN @FileName
END
GO
CREATE FUNCTION [dbo].[FNGetExtension]
(
@Path NVARCHAR(MAX)
)
RETURNS NVARCHAR(MAX)
AS
BEGIN
DECLARE @FileName NVARCHAR(MAX)
DECLARE @ReversedPath NVARCHAR(MAX)
DECLARE @ExtLength INT
SET @ReversedPath = REVERSE(@Path)
SET @FileName = ''
SELECT @ExtLength = CHARINDEX('.', @ReversedPath)
IF (@ExtLength > 0)
BEGIN
SELECT @FileName = RIGHT(@Path, @ExtLength - 1)
END
RETURN @FileName
END
GO
CREATE OR ALTER FUNCTION [dbo].[FNIDB_GET_TERM_TEXT] (@IDB_OBJ_ID BIGINT,@ATTR_ID INTEGER,@LANG_CODE VARCHAR(10) = 'de-DE')
RETURNS VARCHAR(900)
AS
BEGIN
DECLARE @TERM_ID BIGINT, @RESULT VARCHAR(900)
SELECT @RESULT = TERM.TERM_VALUE
FROM
TBIDB_OBJECT_METADATA T INNER JOIN TBIDB_LANGUAGE_TERM T1 ON T.GUID = T1.OBJECT_ID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR TERM ON T1.TERM_ID = TERM.GUID
INNER JOIN TBIDB_LANGUAGE LANG ON T1.LANG_ID = LANG.GUID
INNER JOIN TBIDB_OBJECT OBJ ON T.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE
T.IDB_OBJ_ID = @IDB_OBJ_ID and T.ATTR_ID = @ATTR_ID
AND LANG.LANG_CODE = @LANG_CODE
AND OBJ.ACTIVE = 1;
RETURN @RESULT
END
GO
CREATE FUNCTION [dbo].[FNIDB_GET_TERM_VALUE_VARCHAR] (@TERM_ID BIGINT)
RETURNS VARCHAR(900)
AS
BEGIN
DECLARE @RESULT VARCHAR(900)
SELECT @RESULT = TERM_VALUE FROM TBIDB_TERM_VALUE_VARCHAR WHERE GUID = @TERM_ID
RETURN @RESULT
END
GO
----------------------------------------------------
CREATE OR ALTER FUNCTION [dbo].[FNIDB_GET_TERM_TEXT_VECTOR] (@IDB_OBJ_ID BIGINT,@ATTR_ID INTEGER, @LANG_CODE VARCHAR(5) = 'de-DE')
RETURNS VARCHAR(5000)
AS
BEGIN
DECLARE @TERM_ID BIGINT, @RESULT_SING VARCHAR(900), @RESULT VARCHAR(5000)
SEt @RESULT = ''
DECLARE c_FNIDB_GET_TERM_TEXT_VECTOR CURSOR FOR
SELECT T1.TERM_ID FROM TBIDB_OBJECT_METADATA T INNER JOIN TBIDB_LANGUAGE_TERM T1 ON T.GUID = T1.[OBJECT_ID]
INNER JOIN TBIDB_LANGUAGE LANG ON T1.LANG_ID = LANG.GUID
INNER JOIN TBIDB_OBJECT OBJ ON T.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE
T.IDB_OBJ_ID = @IDB_OBJ_ID and T.ATTR_ID = @ATTR_ID
AND OBJ.ACTIVE = 1 AND LANG.LANG_CODE = @LANG_CODE
OPEN c_FNIDB_GET_TERM_TEXT_VECTOR
FETCH NEXT FROM c_FNIDB_GET_TERM_TEXT_VECTOR INTO @TERM_ID
WHILE @@FETCH_STATUS = 0
BEGIN
SELECT @RESULT_SING = TERM_VALUE FROM TBIDB_TERM_VALUE_VARCHAR WHERE GUID = @TERM_ID
IF @RESULT = ''
SET @RESULT = @RESULT_SING
ELSE
SET @RESULT += '; ' + @RESULT_SING
FETCH NEXT FROM c_FNIDB_GET_TERM_TEXT_VECTOR INTO @TERM_ID
END
CLOSE c_FNIDB_GET_TERM_TEXT_VECTOR
DEALLOCATE c_FNIDB_GET_TERM_TEXT_VECTOR
RETURN @RESULT
END
GO
CREATE OR ALTER FUNCTION FNIDB_GET_TERM_INTEGER_VECTOR (@IDB_OBJ_ID BIGINT,@ATTR_ID INTEGER)
RETURNS VARCHAR(5000)
AS
BEGIN
DECLARE @TERM_ID BIGINT, @RESULT_SING VARCHAR(900), @RESULT VARCHAR(5000)
SEt @RESULT = ''
DECLARE c_FNIDB_GET_TERM_INTEGER_VECTOR CURSOR FOR
SELECT INT_TERM_ID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID and ATTR_ID = @ATTR_ID
OPEN c_FNIDB_GET_TERM_INTEGER_VECTOR
FETCH NEXT FROM c_FNIDB_GET_TERM_INTEGER_VECTOR INTO @TERM_ID
WHILE @@FETCH_STATUS = 0
BEGIN
SELECT @RESULT_SING = TERM_VALUE FROM TBIDB_TERM_VALUE_INTEGER WHERE GUID = @TERM_ID
IF @RESULT = ''
SET @RESULT = @RESULT_SING
ELSE
SET @RESULT += '; ' + @RESULT_SING
FETCH NEXT FROM c_FNIDB_GET_TERM_INTEGER_VECTOR INTO @TERM_ID
END
CLOSE c_FNIDB_GET_TERM_INTEGER_VECTOR
DEALLOCATE c_FNIDB_GET_TERM_INTEGER_VECTOR
RETURN @RESULT
END
GO
CREATE FUNCTION FNIDB_GET_TERM_INTEGER (@IDB_OBJ_ID BIGINT,@ATTR_ID INTEGER)
RETURNS BIGINT
AS
BEGIN
DECLARE @TERM_ID BIGINT, @RESULT VARCHAR(900)
SELECT @TERM_ID = INT_TERM_ID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID and ATTR_ID = @ATTR_ID
SELECT @RESULT = TERM_VALUE FROM TBIDB_TERM_VALUE_INTEGER WHERE GUID = @TERM_ID
RETURN @RESULT
END
GO
CREATE FUNCTION FNIDB_GET_TERM_BIT (@IDB_OBJ_ID BIGINT,@ATTR_ID INTEGER)
RETURNS BIT
AS
BEGIN
DECLARE @TERM_ID BIGINT, @RESULT BIT
SELECT @TERM_ID = INT_TERM_ID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID and ATTR_ID = @ATTR_ID
SELECT @RESULT = TERM_VALUE FROM TBIDB_TERM_VALUE_INTEGER WHERE GUID = @TERM_ID
RETURN @RESULT
END
GO
CREATE FUNCTION [dbo].[FNIDB_GET_TERM_FLOAT] (@IDB_OBJ_ID BIGINT,@ATTR_ID INTEGER)
RETURNS FLOAT
AS
BEGIN
DECLARE @TERM_ID BIGINT, @RESULT FLOAT
SELECT @TERM_ID = FLOAT_TERM_ID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID and ATTR_ID = @ATTR_ID
SELECT @RESULT = TERM_VALUE FROM TBIDB_TERM_VALUE_FLOAT WHERE GUID = @TERM_ID
RETURN @RESULT
END
GO
CREATE FUNCTION FNIDB_GET_TERM_DATE (@IDB_OBJ_ID BIGINT,@ATTR_ID INTEGER)
RETURNS DATE
AS
BEGIN
DECLARE @TERM_ID BIGINT, @RESULT DATE
SELECT @TERM_ID = DATE_TERM_ID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID and ATTR_ID = @ATTR_ID
SELECT @RESULT = TERM_VALUE FROM TBIDB_TERM_VALUE_DATE WHERE GUID = @TERM_ID
RETURN @RESULT
END
GO
CREATE OR ALTER FUNCTION FNIDB_GET_TERM_DATE_TIME (@IDB_OBJ_ID BIGINT,@ATTR_ID INTEGER)
RETURNS DATE
AS
BEGIN
DECLARE @RESULT DATE
SELECT @RESULT = TERM_VALUE
FROM
TBIDB_OBJECT_METADATA MD INNER JOIN TBIDB_TERM_VALUE_DATETIME DT ON MD.DATETIME_TERM_ID = DT.GUID
WHERE
MD.IDB_OBJ_ID = @IDB_OBJ_ID and MD.ATTR_ID = @ATTR_ID
RETURN @RESULT
END
GO
CREATE FUNCTION FNIDB_GET_TERM_DECIMAL (@IDB_OBJ_ID BIGINT,@ATTR_ID INTEGER)
RETURNS DECIMAL(19,0)
AS
BEGIN
DECLARE @TERM_ID BIGINT, @RESULT DECIMAL(19,0)
SELECT @TERM_ID = DEC_TERM_ID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID and ATTR_ID = @ATTR_ID
SELECT @RESULT = TERM_VALUE FROM TBIDB_TERM_VALUE_DECIMAL WHERE GUID = @TERM_ID
RETURN @RESULT
END
GO
CREATE FUNCTION [dbo].[FNGET_WINDREAM_FILE_PATH] (@pDOCID BIGINT)
RETURNS VARCHAR(MAX)
AS
BEGIN
DECLARE
@RESULT VARCHAR(MAX),
@DOCID BIGINT,
@a TINYINT = 1,
@i TINYINT = 0,
@PARENT_ID BIGINT,
@DATEINAME NVARCHAR(255),
@PARENTNAME NVARCHAR(255),
@FSFLAGS INT,
@WM_PREFIX VARCHAR(50)
SET @WM_PREFIX = '\\windream\objects'
SELECT @FSFLAGS = dwFSFlags FROM [windream60].[dbo].[BaseAttributes] WHERE dwDocID = @pDOCID
IF @FSFLAGS = 16
BEGIN
SET @RESULT = 'THIS IS NOT A FILE!'
END
ELSE
BEGIN
SELECT @DATEINAME = szLongName,@PARENT_ID = dwParentID FROM [windream60].[dbo].[BaseAttributes] WHERE dwDocID = @pDOCID
WHILE @a > 0
BEGIN
IF @i = 0
BEGIN
IF @PARENT_ID = 1
BEGIN
SET @RESULT = '\'
BREAK
END
ELSE
BEGIN
SET @DOCID = @PARENT_ID
SET @RESULT = '\'
END
END
ELSE
BEGIN
IF @PARENT_ID = 1
BEGIN
SET @RESULT = '\' + @PARENTNAME + @RESULT
BREAK
END
ELSE
BEGIN
SET @DOCID = @PARENT_ID
SET @RESULT = '\' + @PARENTNAME + @RESULT
END
END
--select * from [172.24.12.41\BRAINPOOL].windream60.dbo.BaseAttributes
SELECT @PARENTNAME = szLongName,@PARENT_ID = dwParentID FROM [windream60].[dbo].[BaseAttributes] WHERE dwDocID = @DOCID
SET @i = @i + 1
END
END
SET @RESULT = @WM_PREFIX + @RESULT + @DATEINAME
RETURN @RESULT
END
GO
CREATE OR ALTER FUNCTION [dbo].[FNIDB_PM_GET_VARIABLE_VALUE] (@DocID BIGINT, @ATTRIBUTE VARCHAR(100),@LANG_CODE VARCHAR(10), @DocID_ISFOREIGN as BIT = False)
RETURNS @Output TABLE (TERM_VALUE VARCHAR(900))
AS
BEGIN
DECLARE
@ATTR_ID INTEGER,
@TYP_ID TINYINT,
@TYP_DESCR VARCHAR(100),
@MULTI BIT,
@TERM_RESULT VARCHAR(900),
@IDB_CREATED_WHEN DATETIME,
@IDB_CREATED_WHO VARCHAR(100),
@IDB_CHANGED_WHEN DATETIME,
@IDB_CHANGED_WHO VARCHAR(100)
IF @DocID_ISFOREIGN = 1
SELECT @DocID = IDB_OBJ_ID,@IDB_CREATED_WHEN = ADDED_WHEN, @IDB_CREATED_WHO = ADDED_WHO, @IDB_CHANGED_WHEN = CHANGED_WHEN, @IDB_CHANGED_WHO = CHANGED_WHO FROM TBIDB_OBJECT WHERE REFERENCE_KEY = @DocID
ELSE
SELECT @IDB_CREATED_WHEN = ADDED_WHEN, @IDB_CREATED_WHO = ADDED_WHO, @IDB_CHANGED_WHEN = CHANGED_WHEN, @IDB_CHANGED_WHO = CHANGED_WHO FROM TBIDB_OBJECT
WHERE IDB_OBJ_ID = @DocID
IF @ATTRIBUTE like 'IDB%'
BEGIN
SELECT @IDB_CREATED_WHEN = ADDED_WHEN, @IDB_CREATED_WHO = ADDED_WHO, @IDB_CHANGED_WHEN = CHANGED_WHEN, @IDB_CHANGED_WHO = CHANGED_WHO FROM TBIDB_OBJECT
WHERE IDB_OBJ_ID = @DocID
IF @ATTRIBUTE = 'IDBCreatedWhen'
INSERT INTO @Output (TERM_VALUE) VALUES (@IDB_CREATED_WHEN)
ELSE IF @ATTRIBUTE = 'IDBCreatedWho'
INSERT INTO @Output (TERM_VALUE) VALUES (@IDB_CREATED_WHO)
ELSE IF @ATTRIBUTE = 'IDBChangedWhen'
INSERT INTO @Output (TERM_VALUE) VALUES (@IDB_CHANGED_WHEN)
ELSE IF @ATTRIBUTE = 'IDBChangedWho'
INSERT INTO @Output (TERM_VALUE) VALUES (@IDB_CHANGED_WHO)
END
ELSE
BEGIN
SELECT @ATTR_ID = T.GUID, @TYP_ID = T.TYP_ID, @MULTI = T.MULTI_CONTEXT,@TYP_DESCR = T1.NAME_TYPE FROM TBIDB_ATTRIBUTE T, TBIDB_ATTRIBUTE_TYPE T1
WHERE T.TYP_ID = T1.GUID AND UPPER(TITLE) = UPPER(@ATTRIBUTE);
IF @TYP_ID IN (1,8) --VARCHAR
BEGIN
DECLARE @TL_ID BIGINT
INSERT INTO @Output (TERM_VALUE)
SELECT TERM.TERM_VALUE FROM
TBIDB_TERM_VALUE_VARCHAR TERM INNER JOIN TBIDB_LANGUAGE_TERM TLANG ON TERM.GUID = TLANG.TERM_ID
INNER JOIN TBIDB_OBJECT_METADATA MD ON TLANG.[OBJECT_ID] = MD.GUID
INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
INNER JOIN TBIDB_LANGUAGE LANG ON TLANG.LANG_ID = LANG.GUID
WHERE MD.ATTR_ID = @ATTR_ID
AND LANG.LANG_CODE = @LANG_CODE
AND MD.IDB_OBJ_ID = @DocID
AND OBJ.ACTIVE = 1;
END
ELSE IF @TYP_ID IN (2,7,9) --BIGINT
BEGIN
INSERT INTO @Output (TERM_VALUE)
SELECT TERM.TERM_VALUE FROM TBIDB_TERM_VALUE_INTEGER TERM, TBIDB_OBJECT_METADATA MD WHERE MD.INT_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @ATTR_ID AND IDB_OBJ_ID = @DocID
END
ELSE IF @TYP_ID = 3 --FLOAT
BEGIN
INSERT INTO @Output (TERM_VALUE)
SELECT TERM.TERM_VALUE FROM TBIDB_TERM_VALUE_FLOAT TERM, TBIDB_OBJECT_METADATA MD WHERE MD.FLOAT_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @ATTR_ID AND IDB_OBJ_ID = @DocID
END
ELSE IF @TYP_ID = 4
BEGIN
INSERT INTO @Output (TERM_VALUE)
SELECT TERM.TERM_VALUE FROM TBIDB_TERM_VALUE_DECIMAL TERM, TBIDB_OBJECT_METADATA MD WHERE MD.DEC_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @ATTR_ID AND IDB_OBJ_ID = @DocID
END
ELSE IF @TYP_ID = 5
BEGIN
INSERT INTO @Output (TERM_VALUE)
SELECT TERM.TERM_VALUE FROM TBIDB_TERM_VALUE_DATE TERM, TBIDB_OBJECT_METADATA MD WHERE MD.DATE_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @ATTR_ID AND IDB_OBJ_ID = @DocID
END
END
RETURN
END
GO
-------------------------------------------------------------------
CREATE OR ALTER FUNCTION [dbo].[FNIDB_GET_TERM_FOR_LANG_TERM_ID] (@LANG_TERM_ID BIGINT, @pLANGUAGE_CODE VARCHAR(5) = 'de-DE')
RETURNS VARCHAR(900)
AS
BEGIN
DECLARE @TERM_ID BIGINT, @RESULT VARCHAR(900)
SELECT @RESULT = T1.TERM_VALUE
FROM
TBIDB_LANGUAGE_TERM T INNER JOIN TBIDB_TERM_VALUE_VARCHAR T1 ON T.TERM_ID = T1.GUID
INNER JOIN TBIDB_LANGUAGE LANG ON T.LANG_ID = LANG.GUID
WHERE
T.GUID = @LANG_TERM_ID AND
LANG.LANG_CODE = @pLANGUAGE_CODE
RETURN @RESULT
END
GO
-------------------------------------------------------------------
CREATE OR ALTER FUNCTION [dbo].[FNIDB_GET_STATE_FOR_OBJECT_ID] (@OBJ_ID BIGINT,@LANG_CODE VARCHAR(5))
RETURNS @Output TABLE (ID BIGINT,[STATE] VARCHAR(100),ADDED_WHO VARCHAR(100), ADDED_WHEN DATETIME)
AS
BEGIN
INSERT INTO @Output (ID,STATE,ADDED_WHO,ADDED_WHEN)
SELECT A.GUID, E.TERM_VALUE
,F.TERM_VALUE AS ADDED_WHO
, A.ADDED_WHEN
FROM TBIDB_MYOBJECT_STATES A INNER JOIN TBIDB_STATES B ON A.STATE_ID = B.GUID
INNER JOIN TBIDB_LANGUAGE_TERM C ON B.GUID = C.OBJECT_ID
INNER JOIN TBIDB_LANGUAGE D ON C.LANG_ID = D.GUID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR E ON C.TERM_ID = E.GUID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR F ON A.ADDED_WHO = F.GUID
WHERE D.LANG_CODE = @LANG_CODE AND A.MY_OBJECT_ID = @OBJ_ID
RETURN
END
GO
-------------------------------------------------------------------
CREATE FUNCTION [dbo].[FNIDB_OBJECT_DYNAMIC_CONFIG] (@pIDB_OBJ_ID as INTEGER, @pUSERID as INTEGER)
RETURNS
@Table TABLE
(CONF_TITLE VARCHAR(900),CONF_VALUE VARCHAR(900))
AS
BEGIN
DECLARE @CONVID BIGINT
SELECT @CONVID = CONVERSATION_ID FROM VWIDB_CONVERSATION WHERE IDB_OBJ_ID = @pIDB_OBJ_ID AND CONVERSATION_STATE = 'Started'
IF @CONVID > 0
BEGIN
INSERT INTO @Table (CONF_TITLE, CONF_VALUE) VALUES ('CONVERSATION_ID',@CONVID);
END
IF EXISTS(SELECT CONV_ID FROM VWIDB_CONVERSATION_USER WHERE CONV_ID = @CONVID AND USER_ID = @pUSERID)
BEGIN
INSERT INTO @Table (CONF_TITLE, CONF_VALUE) VALUES ('CONVERSATION_USER_ACTIVE','True');
END
INSERT INTO @Table (CONF_TITLE, CONF_VALUE) VALUES ('CONVERSATION_RIGHT','Admin');
INSERT INTO @Table (CONF_TITLE, CONF_VALUE) VALUES ('CONVERSATION_RIGHT','Start');
INSERT INTO @Table (CONF_TITLE, CONF_VALUE) VALUES ('CONVERSATION_RIGHT','Stop');
INSERT INTO @Table (CONF_TITLE, CONF_VALUE) VALUES ('CONVERSATION_RIGHT','AddMessage');
INSERT INTO @Table (CONF_TITLE, CONF_VALUE) VALUES ('CONVERSATION_RIGHT','AddUser');
INSERT INTO @Table (CONF_TITLE, CONF_VALUE) VALUES ('NEW_CONVERSATION_USER_SELECT','SELECT GUID as UserID, NAME, USERNAME, EMAIL from @MY_DD_ECM_DB.dbo.TBDD_USER');
INSERT INTO @Table (CONF_TITLE, CONF_VALUE) VALUES ('CONVERSATION_ADD_USER_SELECT','SELECT GUID as UserID, NAME, USERNAME, EMAIL from @MY_DD_ECM_DB.dbo.TBDD_USER WHERE GUID NOT IN (SELECT USER_OR_GROUP_ID FROM
TBIDB_CONVERSATION_USER WHERE CONV_ID = @CONVID AND IS_USER = 1)');
RETURN
END
GO
CREATE FUNCTION [dbo].[FNIDB_GET_FILE_PATH] (@pIDB_OBJ_ID BIGINT)
RETURNS VARCHAR(500)
AS
BEGIN
DECLARE @RELPATH VARCHAR(500),@FILEPATH VARCHAR(500),@NAVPATH as VARCHAR(500)
SELECT @RELPATH = [CAT_STRING] FROM [TBIDB_CATALOG] where CAT_TITLE = 'FILESTORE_PRAEFIX'
SELECT @NAVPATH = RELATIVE_PATH FROM TBIDB_DOC_INFO WHERE IDB_OBJ_ID = @pIDB_OBJ_ID
RETURN @NAVPATH
END
GO
CREATE FUNCTION [dbo].[FNIDB_GET_TERM_FOR_TERM_ID] (@pTERMGUID BIGINT)
RETURNS VARCHAR(900)
AS
BEGIN
DECLARE @TERM_ID BIGINT, @RESULT VARCHAR(900)
SELECT @RESULT = T.TERM_VALUE
FROM TBIDB_TERM_VALUE_VARCHAR T WHERE T.GUID = @pTERMGUID
RETURN @RESULT
END
GO
---- =============================================
---- Author: DD MS
---- Craeation date: 17.08.2020 MS [TBIDB_LANGUAGE_TERM_METADATA]
---- =============================================
--DROP FUNCTION [dbo].[FNIDB_GET_TERM_FOR_LANGUAGE_TERM_METADATA_GUID] (@pTBIDB_LANGUAGE_TERM_METADATA_GUID BIGINT,@pLANG_CODE VARCHAR(5) = 'de-DE')
--RETURNS VARCHAR(900)
--AS
--BEGIN
-- DECLARE @TERM_ID BIGINT, @RESULT VARCHAR(900),@LANG_ID INTEGER
-- SELECT @LANG_ID = GUID FROM TBIDB_LANGUAGE WHERE LANG_CODE = @pLANG_CODE
-- SELECT @RESULT = T3.TERM_VALUE -- @TERM_ID = T1.TEXT_TERM_ID
-- FROM TBIDB_LANGUAGE_TERM_METADATA T2
-- INNER JOIN TBIDB_TERM_LANGUAGE T1 ON T2.LANG_TERM_ID = T1.GUID
-- INNER JOIN TBIDB_TERM_VALUE_VARCHAR T3 ON T1.TEXT_TERM_ID = T3.GUID
-- WHERE
-- T2.GUID = @pTBIDB_LANGUAGE_TERM_METADATA_GUID
-- AND T1.LANGUAGE_ID = @LANG_ID
-- --SELECT @RESULT = TERM_VALUE FROM TBIDB_TERM_VALUE_VARCHAR WHERE GUID = @TERM_ID
-- RETURN @RESULT
--END
--GO
-- =============================================
-- Author: DD MS
-- Creation date: 17.08.2020
-- =============================================
CREATE OR ALTER FUNCTION [dbo].[FNIDB_GET_TERM_FOR_ATTRIBUTE_ID] (@pATTRIBUTE_ID INTEGER,@pLANG_CODE VARCHAR(10), @pUSERID INTEGER)
RETURNS @Output TABLE (IDB_OBJECT_ID BIGINT, TERM_VALUE VARCHAR(900),TERM_ID BIGINT,IDB_CREATED_WHEN DATETIME,IDB_CREATED_WHO VARCHAR(100))
AS
BEGIN
DECLARE
@TYP_ID TINYINT,
@TYP_DESCR VARCHAR(100),
@MULTI BIT,
@TERM_RESULT VARCHAR(900),
@CREATED_WHEN DATETIME,
@CREATED_WHO VARCHAR(100)
BEGIN
SELECT @TYP_ID = T.TYP_ID, @MULTI = T.MULTI_CONTEXT,@TYP_DESCR = T1.NAME_TYPE FROM TBIDB_ATTRIBUTE T, TBIDB_ATTRIBUTE_TYPE T1
WHERE T.TYP_ID = T1.GUID AND T.GUID = @pATTRIBUTE_ID;
IF @TYP_ID IN (1,8) --VARCHAR
BEGIN
DECLARE @TL_ID BIGINT
INSERT INTO @Output (IDB_OBJECT_ID,TERM_VALUE,TERM_ID,IDB_CREATED_WHEN,IDB_CREATED_WHO)
SELECT MD.IDB_OBJ_ID, TERM.TERM_VALUE,TERM.GUID, MD.ADDED_WHEN,MD.ADDED_WHO
FROM
TBIDB_TERM_VALUE_VARCHAR TERM INNER JOIN TBIDB_LANGUAGE_TERM TLANG ON TERM.GUID = TLANG.TERM_ID
INNER JOIN TBIDB_LANGUAGE LANG ON TLANG.LANG_ID = LANG.GUID
INNER JOIN TBIDB_OBJECT_METADATA MD ON TLANG.[OBJECT_ID] = MD.GUID
INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE MD.ATTR_ID = @pATTRIBUTE_ID
AND LANG.LANG_CODE = @pLANG_CODE
AND OBJ.ACTIVE = 1;
END
ELSE IF @TYP_ID IN (2,7,9) --BIGINT
BEGIN
INSERT INTO @Output (IDB_OBJECT_ID,TERM_VALUE,TERM_ID,IDB_CREATED_WHEN,IDB_CREATED_WHO)
SELECT MD.IDB_OBJ_ID, TERM.TERM_VALUE,TERM.GUID, MD.ADDED_WHEN,MD.ADDED_WHO
FROM
TBIDB_TERM_VALUE_INTEGER TERM, TBIDB_OBJECT_METADATA MD WHERE MD.INT_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @pATTRIBUTE_ID
END
ELSE IF @TYP_ID = 3 --FLOAT
BEGIN
INSERT INTO @Output (IDB_OBJECT_ID,TERM_VALUE,TERM_ID,IDB_CREATED_WHEN,IDB_CREATED_WHO)
SELECT MD.IDB_OBJ_ID, TERM.TERM_VALUE,TERM.GUID, MD.ADDED_WHEN,MD.ADDED_WHO
FROM TBIDB_TERM_VALUE_FLOAT TERM, TBIDB_OBJECT_METADATA MD WHERE MD.FLOAT_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @pATTRIBUTE_ID
END
ELSE IF @TYP_ID = 4
BEGIN
INSERT INTO @Output (IDB_OBJECT_ID,TERM_VALUE,TERM_ID,IDB_CREATED_WHEN,IDB_CREATED_WHO)
SELECT MD.IDB_OBJ_ID, TERM.TERM_VALUE, TERM.GUID, MD.ADDED_WHEN,MD.ADDED_WHO
FROM TBIDB_TERM_VALUE_DECIMAL TERM, TBIDB_OBJECT_METADATA MD WHERE MD.DEC_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @pATTRIBUTE_ID
END
ELSE IF @TYP_ID = 5
BEGIN
INSERT INTO @Output (IDB_OBJECT_ID,TERM_VALUE,TERM_ID,IDB_CREATED_WHEN,IDB_CREATED_WHO)
SELECT MD.IDB_OBJ_ID, TERM.TERM_VALUE,TERM.GUID, MD.ADDED_WHEN,MD.ADDED_WHO
FROM TBIDB_TERM_VALUE_DATE TERM, TBIDB_OBJECT_METADATA MD WHERE MD.DATE_TERM_ID = TERM.GUID
AND MD.ATTR_ID = @pATTRIBUTE_ID
END
END
RETURN
END
GO
--CREATE FUNCTION [dbo].[FNIDB_SEARCH_GET_FILTER_SQL] (@pSEARCH_ID INTEGER, @pUSERID INTEGER, @pLANG_CODE VARCHAR(5))
--RETURNS NVARCHAR(MAX)
--AS
--BEGIN
-- DECLARE @ATTR_ID INTEGER, @ATTR_TITLE AS VARCHAR(100), @RUN TINYINT, @RESULT NVARCHAR(MAX), @RUN_ALIAS VARCHAR(2), @RUN_SELECT VARCHAR(500)
-- ,@RUN_FROM VARCHAR(500), @SELECT_PART NVARCHAR(MAX), @FROM_PART NVARCHAR(MAX),@SEPARATOR VARCHAR(1)
-- SET @RUN = 0
-- SET @RUN_ALIAS = 'T'
-- SET @SELECT_PART = 'SELECT '
-- SET @FROM_PART = ''
-- DECLARE cursAttribute CURSOR LOCAL FOR
-- SELECT ATTRIBUTE_ID,ATTRIBUTE_TITLE
-- FROM VWIDB_SEARCH_PROFILE_ATTRIBUTES WHERE SEARCH_PROFIL_ID = @pSEARCH_ID ORDER BY SEQUENCE
-- OPEN cursAttribute
-- FETCH NEXT FROM cursAttribute INTO @ATTR_ID,@ATTR_TITLE
-- WHILE @@FETCH_STATUS = 0
-- BEGIN
-- SET @RUN_SELECT = ''
-- SET @RUN_FROM = ''
-- IF @RUN = 0
-- BEGIN
-- SET @RUN_SELECT = 'T.IDB_OBJECT_ID, T.TERM_VALUE AS [' + @ATTR_TITLE + ']'
-- SET @RUN_FROM = CHAR(10) + 'FROM [dbo].[FNIDB_GET_TERM_FOR_ATTRIBUTE_ID] (' + CONVERT(VARCHAR(10),@ATTR_ID) + ',''' + @pLANG_CODE + ''',' + CONVERT(VARCHAR(10),@pUSERID) + ') T'
-- END
-- ELSE
-- BEGIN
-- SET @RUN_SELECT = ', ' + @RUN_ALIAS + CONVERT(VARCHAR(2), @RUN) + '.TERM_VALUE AS [' + @ATTR_TITLE + ']'
-- SET @RUN_FROM = CHAR(10) + 'INNER JOIN [dbo].[FNIDB_GET_TERM_FOR_ATTRIBUTE_ID] (' + CONVERT(VARCHAR(10),@ATTR_ID) + ',''' + @pLANG_CODE + ''',' + CONVERT(VARCHAR(10),@pUSERID) + ') ' + @RUN_ALIAS + CONVERT(VARCHAR(2), @RUN)
-- SET @RUN_FROM += ' ON T.IDB_OBJECT_ID = T' + CONVERT(VARCHAR(2), @RUN) + '.IDB_OBJECT_ID'
-- END
-- SET @SELECT_PART += @RUN_SELECT
-- SET @FROM_PART += @RUN_FROM
-- SET @RUN += 1
-- FETCH NEXT FROM cursAttribute INTO @ATTR_ID,@ATTR_TITLE
-- END
-- CLOSE cursAttribute
-- DEALLOCATE cursAttribute
-- SET @RESULT = @SELECT_PART + @FROM_PART
-- RETURN @RESULT
--END
--GO
-- =======================================================
-- Author: SYSTEM, DD MS
-- Create Date: 22.10.2020
-- Gunction returns all values for parameterized Attribute
-- =======================================================
CREATE OR ALTER FUNCTION [dbo].[FNIDB_PM_GET_VARIABLE_VALUE_FOR_ALL_OBJECTS] (@ATTRIBUTE VARCHAR(100),@LANG_CODE VARCHAR(10))
RETURNS @Output TABLE (IDB_OBJ_ID BIGINT,TERM_VALUE VARCHAR(900))
AS
BEGIN
DECLARE
@ATTR_ID INTEGER,
@TYP_ID TINYINT,
@TYP_DESCR VARCHAR(100),
@MULTI BIT,
@LANG_ID INT,
@TERM_RESULT VARCHAR(900)
SELECT @LANG_ID = GUID FROM TBIDB_LANGUAGE WHERE LANG_CODE = @LANG_CODE
SELECT @ATTR_ID = T.GUID, @TYP_ID = T.TYP_ID, @MULTI = T.MULTI_CONTEXT,@TYP_DESCR = T1.NAME_TYPE FROM TBIDB_ATTRIBUTE T, TBIDB_ATTRIBUTE_TYPE T1
WHERE T.TYP_ID = T1.GUID AND UPPER(TITLE) = UPPER(@ATTRIBUTE)
IF @TYP_ID IN (1,8) --VARCHAR
BEGIN
DECLARE @TL_ID BIGINT
INSERT INTO @Output (IDB_OBJ_ID,TERM_VALUE)
SELECT MD.IDB_OBJ_ID, TERM.TERM_VALUE
FROM
TBIDB_TERM_VALUE_VARCHAR TERM INNER JOIN TBIDB_LANGUAGE_TERM TLANG ON TERM.GUID = TLANG.TERM_ID
INNER JOIN TBIDB_LANGUAGE LANG ON TLANG.LANG_ID = LANG.GUID
INNER JOIN TBIDB_OBJECT_METADATA MD ON TLANG.[OBJECT_ID] = MD.GUID
INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE MD.ATTR_ID = @ATTR_ID
AND LANG.LANG_CODE = @LANG_CODE
AND OBJ.ACTIVE = 1
ORDER BY OBJ.IDB_OBJ_ID DESC
END
ELSE IF @TYP_ID IN (2,7,9) --BIGINT
BEGIN
INSERT INTO @Output (IDB_OBJ_ID,TERM_VALUE)
SELECT OBJ.IDB_OBJ_ID,TERM.TERM_VALUE
FROM
TBIDB_TERM_VALUE_INTEGER TERM INNER JOIN TBIDB_OBJECT_METADATA MD ON MD.INT_TERM_ID = TERM.GUID
INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE
MD.ATTR_ID = @ATTR_ID
AND OBJ.ACTIVE = 1
ORDER BY OBJ.IDB_OBJ_ID DESC
END
ELSE IF @TYP_ID = 3 --FLOAT
BEGIN
INSERT INTO @Output (IDB_OBJ_ID,TERM_VALUE)
SELECT OBJ.IDB_OBJ_ID,TERM.TERM_VALUE
FROM
TBIDB_TERM_VALUE_FLOAT TERM INNER JOIN TBIDB_OBJECT_METADATA MD ON MD.FLOAT_TERM_ID = TERM.GUID
INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE
MD.ATTR_ID = @ATTR_ID
AND OBJ.ACTIVE = 1 ORDER BY OBJ.IDB_OBJ_ID DESC
END
ELSE IF @TYP_ID = 4
BEGIN
INSERT INTO @Output (IDB_OBJ_ID,TERM_VALUE)
SELECT OBJ.IDB_OBJ_ID,TERM.TERM_VALUE
FROM
TBIDB_TERM_VALUE_DECIMAL TERM INNER JOIN TBIDB_OBJECT_METADATA MD ON MD.DEC_TERM_ID = TERM.GUID
INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE
MD.ATTR_ID = @ATTR_ID
AND OBJ.ACTIVE = 1
ORDER BY OBJ.IDB_OBJ_ID DESC
END
ELSE IF @TYP_ID = 5
BEGIN
INSERT INTO @Output (IDB_OBJ_ID,TERM_VALUE)
SELECT OBJ.IDB_OBJ_ID,TERM.TERM_VALUE
FROM
TBIDB_TERM_VALUE_DATE TERM INNER JOIN TBIDB_OBJECT_METADATA MD ON MD.DATE_TERM_ID = TERM.GUID
INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE
MD.ATTR_ID = @ATTR_ID AND OBJ.ACTIVE = 1
ORDER BY OBJ.IDB_OBJ_ID DESC
END
RETURN
END
GO
--=============================================
--Author: SYSTEM MS
--Creation date: 22.10.2020
--=============================================
CREATE OR ALTER FUNCTION [dbo].[FNIDB_GET_SEARCH_PROFILES] (@pUSERID INT, @pLANGCODE VARCHAR(5))
RETURNS @Output TABLE (SEARCH_PROFILE_ID INTEGER,TITLE VARCHAR(100),RESULT_SQL VARCHAR(915),PSOURCE VARCHAR(50))
AS
BEGIN
DECLARE
@ATTR_ID INTEGER,
@TYP_ID TINYINT,
@TYP_DESCR VARCHAR(100),
@MULTI BIT,
@LANG_ID INT,
@TERM_RESULT VARCHAR(900),
@IDB_CREATED_WHEN DATETIME,
@IDB_CREATED_WHO VARCHAR(100),
@IDB_CHANGED_WHEN DATETIME,
@IDB_CHANGED_WHO VARCHAR(100)
INSERT INTO @Output (SEARCH_PROFILE_ID,TITLE,RESULT_SQL,PSOURCE)
SELECT
T.GUID
,TERM.TERM_VALUE TITLE
,[dbo].[FNIDB_GET_TERM_FOR_TERM_ID] (T2.SEARCH_TERM_ID) AS RESULT_SQL
,'TBIDB_SEARCH_PROFILE_USER'
FROM TBIDB_SEARCH_PROFILE T INNER JOIN TBIDB_SEARCH_PROFILE_USER_GROUP T1 ON T.GUID = T1.SEARCH_PROFIL_ID
INNER JOIN TBIDB_LANGUAGE_TERM LTERM ON T.GUID = LTERM.OBJECT_ID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR TERM ON LTERM.TERM_ID = TERM.GUID
INNER JOIN TBIDB_SEARCH_LANGUAGE_SQL_RESULT T2 ON T.GUID = T2.SEARCH_PROFIL_ID
INNER JOIN TBIDB_LANGUAGE T3 ON T2.LANGUAGE_ID = T3.GUID
INNER JOIN TBIDB_LANGUAGE T4 ON LTERM.LANG_ID = T4.GUID
WHERE T1.USER_ID = @pUSERID AND T3.LANG_CODE = @pLANGCODE
AND T4.LANG_CODE = @pLANGCODE
INSERT INTO @Output (SEARCH_PROFILE_ID,TITLE,RESULT_SQL,PSOURCE)
SELECT
T.GUID
,TERM.TERM_VALUE TITLE
,[dbo].[FNIDB_GET_TERM_FOR_TERM_ID] (T4.SEARCH_TERM_ID) AS RESULT_SQL
,'TBIDB_SEARCH_PROFILE_GROUP'
FROM TBIDB_SEARCH_PROFILE T INNER JOIN TBIDB_SEARCH_PROFILE_USER_GROUP T1 ON T.GUID = T1.SEARCH_PROFIL_ID
INNER JOIN DD_ECM.dbo.TBDD_GROUPS T2 ON T1.GROUP_ID = T2.GUID
INNER JOIN DD_ECM.dbo.TBDD_GROUPS_USER T3 ON T2.GUID = T3.GROUP_ID
INNER JOIN TBIDB_LANGUAGE_TERM LTERM ON T.GUID = LTERM.OBJECT_ID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR TERM ON LTERM.TERM_ID = TERM.GUID
INNER JOIN TBIDB_SEARCH_LANGUAGE_SQL_RESULT T4 ON T.GUID = T4.SEARCH_PROFIL_ID
INNER JOIN TBIDB_LANGUAGE T5 ON T4.LANGUAGE_ID = T3.GUID
INNER JOIN TBIDB_LANGUAGE T6 ON LTERM.LANG_ID = T6.GUID
WHERE T3.USER_ID = @pUSERID AND T5.LANG_CODE = @pLANGCODE
AND T6.LANG_CODE = @pLANGCODE
RETURN
END
GO
--CREATE FUNCTION [dbo].[FNIDB_SEARCH_RESULT_GET_OBJECTS] (@pUSERID INT,@PSEARCHID INT)
----DECLARE @pUSERID INT,@PSEARCHID INT
----SET @pUSERID =1
----SET @PSEARCHID = 7
--RETURNS @TBRESULT TABLE (RUN INT, IDB_OBJ_ID BIGINT, ATTR_ID INT,ATTR_TITLE VARCHAR(100), COMMENT VARCHAR(200))
--AS
--BEGIN
-- DECLARE
-- @GUID BIGINT,@ATTR_ID INT,@LASTATTR_ID INT ,@ATTR_TITLE VARCHAR(100),@RUN TINYINT,@COUNT_ATTRIBUTES TINYINT
-- ,@RESTRICTIONSYN BIT
-- SET @LASTATTR_ID = 0
-- DECLARE @TBRESULT_RESTRICTION TABLE (RUN INT, IDB_OBJ_ID BIGINT, ATTR_ID INT,ATTR_TITLE VARCHAR(100), COMMENT VARCHAR(200))
-- select @COUNT_ATTRIBUTES = COUNT(T.USERID)
-- from
-- VWIDB_SEARCH_ATTRIBUTES_USER T
-- WHERE
-- T.SEARCH_PROFIL_ID = @PSEARCHID AND T.USERID = @pUSERID
-- SET @RUN = 1
-- DECLARE cursorSearchAttributes CURSOR FOR
-- select
-- T.ATTRIBUTE_ID,T.TITLE
-- from
-- VWIDB_SEARCH_ATTRIBUTES_USER T
-- WHERE
-- T.SEARCH_PROFIL_ID = @PSEARCHID AND T.USERID = @pUSERID
-- ORDER BY T.SEQUENCE
-- OPEN cursorSearchAttributes
-- FETCH NEXT FROM cursorSearchAttributes INTO @ATTR_ID,@ATTR_TITLE
-- WHILE @@FETCH_STATUS = 0
-- BEGIN
-- DECLARE @SEARCH_DEF_ID BIGINT, @TERM_ID BIGINT
-- DECLARE cursorDetailAttribute CURSOR FOR
-- select
-- T.GUID,T.TERM_ID
-- from
-- TBIDB_USER_SEARCH_CRITERIA T
-- WHERE
-- T.SEARCH_PROFIL_ID = 7 AND T.USERID = 1 AND T.ATTRIBUTE_ID = @ATTR_ID
-- OPEN cursorDetailAttribute
-- FETCH NEXT FROM cursorDetailAttribute INTO @SEARCH_DEF_ID,@TERM_ID
-- WHILE @@FETCH_STATUS = 0
-- BEGIN
-- INSERT INTO @TBRESULT_RESTRICTION ( RUN, IDB_OBJ_ID, ATTR_ID, ATTR_TITLE)
-- SELECT @SEARCH_DEF_ID, IDB_OBJECT_ID, @ATTR_ID, @ATTR_TITLE
-- FROM
-- FNIDB_GET_TERM_FOR_ATTRIBUTE_ID (@ATTR_ID,'de-DE',@pUSERID)
-- WHERE
-- TERM_ID = @TERM_ID
-- --SELECT * FROM @TBRESULT_RESTRICTION
-- FETCH NEXT FROM cursorDetailAttribute INTO @SEARCH_DEF_ID,@TERM_ID
-- END
-- CLOSE cursorDetailAttribute
-- DEALLOCATE cursorDetailAttribute
-- --PRINT 'FIRST SEARCH ROW'
-- --PRINT @TBRESULT_RESTRICTION
-- --PRINT '@COUNT_ATTRIBUTES: ' + CONVERT(VARCHAR(2),@COUNT_ATTRIBUTES)
-- --PRINT '@RUN: ' + CONVERT(VARCHAR(2),@RUN)
-- IF @RUN = 1
-- INSERT INTO @TBRESULT ( RUN, IDB_OBJ_ID, ATTR_ID, ATTR_TITLE, COMMENT)
-- SELECT * FROM @TBRESULT_RESTRICTION
-- ELSE
-- IF @COUNT_ATTRIBUTES = @RUN
-- BEGIN
-- -- --#### Now deleting the Results which are not part of the restriction
-- --PRINT 'DELETE AS THIS IS THE LAST RUN PER ATTRIBUTE'
-- DELETE FROM @TBRESULT WHERE IDB_OBJ_ID NOT IN (
-- SELECT IDB_OBJ_ID FROM @TBRESULT_RESTRICTION)
-- -- UPDATE T
-- -- SET
-- -- T.RUN = T1.RUN
-- -- FROM
-- -- @TBRESULT T INNER JOIN
-- -- @TBRESULT_RESTRICTION T1 ON T.IDB_OBJ_ID = T1.IDB_OBJ_ID
-- END
-- SET @RUN +=1
-- SET @LASTATTR_ID = @ATTR_ID
-- DELETE FROM @TBRESULT_RESTRICTION
-- FETCH NEXT FROM cursorSearchAttributes INTO @ATTR_ID,@ATTR_TITLE
-- END
-- CLOSE cursorSearchAttributes
-- DEALLOCATE cursorSearchAttributes
--RETURN
----select DISTINCT IDB_OBJ_ID from @TBRESULT ORDER BY IDB_OBJ_ID
--END
--GO
/*#########################################
############## VIEWS ######################
###########################################*/
CREATE VIEW VWIDB_FILE_OBJECT AS
SELECT
A.IDB_OBJ_ID
,FN.TERM_VALUE as Filename
,EXT.TERM_VALUE as Extension
,RP.TERM_VALUE as RELPATH
,A.FILE_HASH
,A.FILE_SIZE
,A.ADDED_WHEN
,A.ADDED_WHO
,A.CHANGED_WHO
,A.CHANGED_WHEN
FROM
TBIDB_FILE_OBJECT A INNER JOIN TBIDB_TERM_VALUE_VARCHAR EXT ON A.EXTENSION_TERM_ID = EXT.GUID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR FN ON A.FILENAME_TERM_ID = FN.GUID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR RP ON A.RELPATH_TERM_ID = RP.GUID
GO
CREATE VIEW VWIDB_OBJECT_STORE
AS
SELECT
A.GUID,
A.OBJECT_TITLE AS Objectstore,
A.IS_ARCHIVE Archive
,B.CAT_STRING As REL_PATH
,A.ADDED_WHEN
,A.ADDED_WHO
,A.CHANGED_WHO
,A.CHANGED_WHEN
FROM
TBIDB_OBJECT_STORE A INNER JOIN TBIDB_CATALOG B ON A.CAT_ID = B.GUID
GO
CREATE OR ALTER VIEW [dbo].[VWIDB_VALUE_CHANGE_LOG] AS
select
T.GUID AS ChangeID,
T1.GUID AS AttributeID,
T.IDB_OBJ_ID, T1.TITLE as Attribute,
T2.TERM_VALUE as [OLD VALUE],
T3.TERM_VALUE as [NEW VALUE],
T.CHANGED_WHO ,
T.CHANGED_WHEN
from TBIDB_OBJECT_METADATA_CHANGE T
INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTR_ID = T1.GUID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR T2 ON T.OLD_TEXT_TERM = T2.GUID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR T3 ON T.NEW_TEXT_TERM = T3.GUID
GO
CREATE VIEW [dbo].[VWIDB_OBJ_VALUE_BIT] AS
SELECT
T.GUID AS MetadataID,
T.ATTR_ID AS AttributID,
T.IDB_OBJ_ID,
T1.TITLE as Attribut,
(SELECT [dbo].[FNIDB_GET_TERM_BIT] (T.IDB_OBJ_ID,T.ATTR_ID)) AS 'Term_Value',
T.ADDED_WHO,
T.ADDED_WHEN,
T.CHANGED_WHO,
T.CHANGED_WHEN
FROM
TBIDB_OBJECT_METADATA T INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTR_ID = T1.GUID
INNER JOIN TBIDB_ATTRIBUTE_TYPE T2 ON T1.TYP_ID = T2.GUID
WHERE
T2.NAME_TYPE = 'BIT'
GO
CREATE VIEW [dbo].[VWIDB_OBJ_VALUE_DATE] AS
SELECT
T.GUID AS MetadataID,
T.ATTR_ID AS AttributID,
T.IDB_OBJ_ID,
T1.TITLE as Attribut,
(SELECT [dbo].[FNIDB_GET_TERM_DATE] (T.IDB_OBJ_ID,T.ATTR_ID)) AS 'Term_Value',
T.ADDED_WHO,
T.ADDED_WHEN,
T.CHANGED_WHO,
T.CHANGED_WHEN
FROM
TBIDB_OBJECT_METADATA T INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTR_ID = T1.GUID
INNER JOIN TBIDB_ATTRIBUTE_TYPE T2 ON T1.TYP_ID = T2.GUID
WHERE
T2.NAME_TYPE = 'DATE'
GO
CREATE VIEW [dbo].[VWIDB_OBJ_VALUE_DATETIME] AS
SELECT
T.GUID AS MetadataID,
T.ATTR_ID AS AttributID,
T.IDB_OBJ_ID,
T1.TITLE as Attribut,
T3.TERM_VALUE AS 'Term_Value',
T.ADDED_WHO,
T.ADDED_WHEN,
T.CHANGED_WHO,
T.CHANGED_WHEN
FROM
TBIDB_OBJECT_METADATA T INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTR_ID = T1.GUID
INNER JOIN TBIDB_TERM_VALUE_DATETIME T3 ON T.DATETIME_TERM_ID = T3.GUID
GO
CREATE NONCLUSTERED INDEX [TBIDB_OBJECT_METADATA_DATETIMETERMID]
ON [dbo].[TBIDB_OBJECT_METADATA] ([DATETIME_TERM_ID])
INCLUDE ([IDB_OBJ_ID],[ATTR_ID],[ADDED_WHO],[ADDED_WHEN],[CHANGED_WHO],[CHANGED_WHEN])
GO
CREATE VIEW [dbo].[VWIDB_OBJ_VALUE_DECIMAL] AS
SELECT
T.GUID AS MetadataID,
T.ATTR_ID AS AttributID,
T.IDB_OBJ_ID,
T1.TITLE as Attribut,
(SELECT [dbo].[FNIDB_GET_TERM_DECIMAL] (T.IDB_OBJ_ID,T.ATTR_ID)) AS 'Term_Value',
T.ADDED_WHO,
T.ADDED_WHEN,
T.CHANGED_WHO,
T.CHANGED_WHEN
FROM
TBIDB_OBJECT_METADATA T INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTR_ID = T1.GUID
INNER JOIN TBIDB_ATTRIBUTE_TYPE T2 ON T1.TYP_ID = T2.GUID
WHERE
T2.NAME_TYPE = 'DECIMAL'
GO
CREATE VIEW [dbo].[VWIDB_OBJ_VALUE_FLOAT] AS
SELECT
T.GUID AS MetadataID,
T.ATTR_ID AS AttributID,
T.IDB_OBJ_ID,
T1.TITLE as Attribut,
(SELECT [dbo].[FNIDB_GET_TERM_FLOAT] (T.IDB_OBJ_ID,T.ATTR_ID)) AS 'Term_Value',
T.ADDED_WHO,
T.ADDED_WHEN,
T.CHANGED_WHO,
T.CHANGED_WHEN
FROM
TBIDB_OBJECT_METADATA T INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTR_ID = T1.GUID
INNER JOIN TBIDB_ATTRIBUTE_TYPE T2 ON T1.TYP_ID = T2.GUID
WHERE
T2.NAME_TYPE = 'FLOAT'
GO
CREATE VIEW [dbo].[VWIDB_OBJ_VALUE_INTEGER] AS
SELECT
T.GUID AS MetadataID,
T.ATTR_ID AS AttributID,
T.IDB_OBJ_ID,
T1.TITLE as Attribut,
(SELECT [dbo].[FNIDB_GET_TERM_INTEGER] (T.IDB_OBJ_ID,T.ATTR_ID)) AS 'Term_Value',
T.ADDED_WHO,
T.ADDED_WHEN,
T.CHANGED_WHO,
T.CHANGED_WHEN
FROM
TBIDB_OBJECT_METADATA T INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTR_ID = T1.GUID
INNER JOIN TBIDB_ATTRIBUTE_TYPE T2 ON T1.TYP_ID = T2.GUID
WHERE
T2.NAME_TYPE = 'BIG INTEGER'
GO
CREATE VIEW [dbo].[VWIDB_OBJ_VALUE_TEXT] AS
SELECT
T.IDB_OBJ_ID
,T.ATTR_ID
,T1.TITLE ATTR_NAME
,(SELECT [dbo].[FNIDB_GET_TERM_TEXT] (T.IDB_OBJ_ID,T.ATTR_ID,'de-DE')) AS 'Term_Value'
FROM
TBIDB_OBJECT_METADATA T INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTR_ID = T1.GUID
INNER JOIN TBIDB_ATTRIBUTE_TYPE T2 ON T1.TYP_ID = T2.GUID
WHERE
T2.NAME_TYPE = 'VARCHAR'
GO
CREATE VIEW [dbo].[VWIDB_VALUE_DELETE_LOG] AS
select
T.GUID AS DeleteID,
T1.GUID AS AttributID,
T.IDB_OBJ_ID,
T1.TITLE as Attribut,
T3.TERM_VALUE as [Gel<EFBFBD>schter Wert],
T.DELETED_WHO [Gel<EFBFBD>scht wer],
T.DELETED_WHEN [Gel<EFBFBD>scht wann]
from TBIDB_OBJECT_METADATA_DELETE T
INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTR_ID = T1.GUID
INNER JOIN TBIDB_LANGUAGE_TERM T2 ON T.GUID = T2.[OBJECT_ID]
INNER JOIN TBIDB_TERM_VALUE_VARCHAR T3 ON T2.TERM_ID = T3.GUID
GO
CREATE OR ALTER VIEW [dbo].[VWIDB_VALUE_TEXT] AS
select TOP 100 PERCENT
T.GUID AS MetadataID,
T1.GUID AS AttributID,
T.IDB_OBJ_ID,
T1.TITLE as Attribut,
T3.TERM_VALUE,
T4.LANG_CODE,
T.ADDED_WHO,
T.ADDED_WHEN,
T.CHANGED_WHO [Ge<EFBFBD>ndert wer],
T.CHANGED_WHEN [Ge<EFBFBD>ndert wann]
from TBIDB_OBJECT_METADATA T
INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTR_ID = T1.GUID
INNER JOIN TBIDB_LANGUAGE_TERM T2 ON T.GUID = T2.[OBJECT_ID]
INNER JOIN TBIDB_OBJECT OBJ ON T.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR T3 ON T2.TERM_ID = T3.GUID
INNER JOIN TBIDB_LANGUAGE T4 ON T2.LANG_ID = T4.GUID
WHERE OBJ.ACTIVE = 1
GO
CREATE VIEW [dbo].[VWIDB_OBJ_VALUE_TEXT_SORTED] as
SELECT TOP 100 PERCENT
*, [Ge<EFBFBD>ndert wann] as LAST_CHANGE
FROM
VWIDB_VALUE_TEXT where [Ge<EFBFBD>ndert wann] IS NOT NULL
UNION
SELECT TOP 100 PERCENT
*, [ADDED_WHEN] as LAST_CHANGE
FROM
VWIDB_VALUE_TEXT where [Ge<EFBFBD>ndert wann] IS NULL
ORDER BY IDB_OBJ_ID DESC,LAST_CHANGE DESC
GO
CREATE VIEW VWIDB_CONVERSATION AS
SELECT
GUID As CONVERSATION_ID
,IDB_OBJ_ID
,[dbo].[FNIDB_GET_TERM_FOR_LANG_TERM_ID] (TITLE_TERM_ID,'de-DE') as TITLE
--,[dbo].[FNIDB_GET_STATE_FOR_OBJECT_ID] (GUID) AS CONVERSATION_STATE
,[dbo].[FNIDB_GET_TERM_VALUE_VARCHAR] (ADDED_WHO) as ADDED_WHO
,ADDED_WHEN
,[dbo].[FNIDB_GET_TERM_VALUE_VARCHAR] (CHANGED_WHO) as CHANGED_WHO
,CHANGED_WHEN
FROM TBIDB_CONVERSATION_OBJECT
GO
CREATE VIEW VWIDB_CONV_MESSAGES AS
select
T.GUID,
T.CONV_ID,
(SELECT EMAIL FROM DD_ECM.dbo.TBDD_USER WHERE GUID = T.TO_USER) TO_USER,
[dbo].[FNIDB_GET_TERM_FOR_LANG_TERM_ID] (T1.TITLE_TERM_ID,'de-DE') AS CONV_TITLE
,[dbo].[FNIDB_GET_TERM_VALUE_VARCHAR] (T.FROM_USER) as USER_FROM
,[dbo].[FNIDB_GET_TERM_FOR_LANG_TERM_ID] (T.MESSAGE_TERM_ID,'de-DE') as MESSAGE_TEXT
,[dbo].[FNIDB_GET_TERM_FOR_LANG_TERM_ID] (T.ADDED_WHO,'de-DE') as ADDED_WHO
,T.ADDED_WHEN
from TBIDB_CONVERSATION_MESSAGE T INNER JOIN TBIDB_CONVERSATION_OBJECT T1 ON T.CONV_ID = T1.GUID
GO
CREATE VIEW VWIDB_CONVERSATION_USER AS
SELECT
T.CONV_ID
,T1.GUID As USER_ID
,T1.USERNAME
,T1.EMAIL
,T1.NAME + ', ' + T1.PRENAME as NAME
FROM
[IDB].[dbo].[TBIDB_CONVERSATION_USER] T
INNER JOIN @MY_DD_ECM_DB.dbo.TBDD_USER T1 ON T.USER_OR_GROUP_ID = T1.GUID
WHERE IS_USER = 1
GO
--CREATE VIEW VWIDB_SEARCH_PROFILE_ATTRIBUTES AS
--SELECT
-- T.SEARCH_PROFIL_ID,
-- T.GUID,
-- T.ATTRIBUTE_ID,
-- --T.DEPENDING_ATTRIBUTE1,
-- T1.TITLE AS ATTRIBUTE_TITLE,
-- T.HEIGHT,
-- T.WIDTH,
-- T.MULTISELECT,
-- T2.NAME_TYPE AS ATTRIBUTE_TYPE
-- ,[dbo].[FNIDB_GET_TERM_FOR_TERM_ID] (T.SOURCE_SQL) AS SOURCE_SQL
-- ,[dbo].[FNIDB_GET_TERM_FOR_TERM_ID] (T.ADDED_WHO) AS ADDED_WHO
-- ,T.ADDED_WHEN
-- ,[dbo].[FNIDB_GET_TERM_FOR_TERM_ID] (T.CHANGED_WHO) AS CHANGED_WHO
-- ,T.CHANGED_WHEN
-- ,T.[SEQUENCE]
--FROM
-- TBIDB_SEARCH_PROFILE_ATTRIBUTES T INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTRIBUTE_ID = T1.GUID
-- INNER JOIN TBIDB_ATTRIBUTE_TYPE T2 ON T1.TYP_ID = T2.GUID
--GO
--CREATE VIEW VWIDB_SEARCH_ATTRIBUTES_LINKS AS
--SELECT
-- T1.SEARCH_PROFIL_ID,
-- T.GUID,
-- T.DEP_ATTR_ID,
-- --T.DEPENDING_ATTRIBUTE1,
-- T3.TITLE AS DEP_ATTRIBUTE_TITLE,
-- [dbo].[FNIDB_GET_TERM_FOR_TERM_ID] (T1.SOURCE_SQL) DEP_SOURCE_SQL,
-- T.LINKED_ATTR_ID
-- --T.DEPENDING_ATTRIBUTE1,
-- ,T5.TITLE AS LINK_ATTRIBUTE_TITLE
-- ,T.ADDED_WHEN
-- ,[dbo].[FNIDB_GET_TERM_FOR_TERM_ID] (T.CHANGED_WHO) AS CHANGED_WHO
-- ,T.CHANGED_WHEN
--FROM
-- TBIDB_SEARCH_ATTRIBUTES_LINKS T INNER JOIN TBIDB_SEARCH_PROFILE_ATTRIBUTES T1 ON T.DEP_ATTR_ID = T1.ATTRIBUTE_ID
-- --INNER JOIN TBIDB_SEARCH_PROFILE_ATTRIBUTES T2 ON T.LINKED_ATTR_ID = T2.ATTRIBUTE_ID
-- INNER JOIN TBIDB_ATTRIBUTE T3 ON T.DEP_ATTR_ID = T3.GUID
-- INNER JOIN TBIDB_ATTRIBUTE T5 ON T.LINKED_ATTR_ID = T5.GUID
--GO
--CREATE VIEW VWIDB_SEARCH_ATTRIBUTES_USER
--AS
-- select TOP 100 PERCENT
-- T.USERID,T.SEARCH_PROFIL_ID, T.ATTRIBUTE_ID,T1.TITLE,T2.SEQUENCE
-- from
-- TBIDB_USER_SEARCH_CRITERIA T INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTRIBUTE_ID = T1.GUID
-- INNER JOIN TBIDB_SEARCH_PROFILE_ATTRIBUTES T2 ON T.SEARCH_PROFIL_ID = T2.SEARCH_PROFIL_ID AND T.ATTRIBUTE_ID = T2.ATTRIBUTE_ID
-- GROUP BY T.USERID,T.SEARCH_PROFIL_ID, T.ATTRIBUTE_ID,T1.TITLE,T2.SEQUENCE
-- ORDER BY T.USERID, T.SEARCH_PROFIL_ID, T2.SEQUENCE
--GO
CREATE OR ALTER VIEW [dbo].[VWIDB_CHANGE_LOG] AS
select
T.GUID AS ChangeID,
T.IDB_OBJ_ID,
T1.TITLE as Attribute,
T2.TERM_VALUE as [Old value],
T3.TERM_VALUE as [New value],
T.CHANGED_WHO [Changed who],
T.CHANGED_WHEN [Changed when]
from TBIDB_OBJECT_METADATA_CHANGE T
INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTR_ID = T1.GUID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR T2 ON T.OLD_TEXT_TERM = T2.GUID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR T3 ON T.NEW_TEXT_TERM = T3.GUID
GO
--CREATE VIEW [dbo].[VWIDB_CATEGORIES_PER_OBJECT_AND_LANGUAGE] AS
--select
-- MD.IDB_OBJ_ID
-- ,TLANG.LANGUAGE_ID
-- ,TERM.TERM_VALUE
-- ,TERM_ATTR.TERM_VALUE AS ATTRIBUTE_TITLE
-- ,ATTR.GUID AS ATTRIBUTE_ID
--FROM
-- TBIDB_TERM_VALUE_VARCHAR TERM INNER JOIN TBIDB_TERM_LANGUAGE TLANG ON TERM.GUID = TLANG.TEXT_TERM_ID
-- INNER JOIN TBIDB_LANGUAGE_TERM_METADATA T1 ON TLANG.GUID = T1.LANG_TERM_ID
-- INNER JOIN TBIDB_OBJECT_METADATA MD ON T1.GUID = MD.TEXT_TERM_LANG_ID
-- INNER JOIN TBIDB_FLOW_SEARCH_CATEGORY_ATTRIBUTES CAT_ATTR ON MD.ATTR_ID = CAT_ATTR.ATTRIBUTE_ID
-- INNER JOIN TBIDB_ATTRIBUTE ATTR ON CAT_ATTR.ATTRIBUTE_ID = ATTR.GUID
-- INNER JOIN TBIDB_ATTRIBUTE_LANGUAGE ATTR_LANG ON ATTR.GUID = ATTR_LANG.ATTRIBUTE_ID
-- INNER JOIN TBIDB_TERM_VALUE_VARCHAR TERM_ATTR ON ATTR_LANG.TERM_ID = TERM_ATTR.GUID
--WHERE
-- CAT_ATTR.ACTIVE = 1
--GO
CREATE VIEW VWIDB_DOCTYPE_HANDLING AS
SELECT
A.GUID
,A.DOCTYPE
,B.CAT_STRING AS CHANGED_HANDLING
,A.ADDED_WHO
,A.ADDED_WHEN
,A.CHANGED_WHO
,A.CHANGED_WHEN
FROM
TBIDB_DOCTYPE_HANDLING A INNER JOIN TBIDB_CATALOG B ON A.CHANGED_ACTION = B.GUID
WHERE
A.ACTIVE = 1
GO
CREATE OR ALTER VIEW VWIDB_DOCTYPES_DE
AS
select
TERM.TERM_VALUE as Doctype
FROM TBIDB_OBJECT_METADATA MD
INNER JOIN TBIDB_ATTRIBUTE T1 ON MD.ATTR_ID = T1.GUID
INNER JOIN TBIDB_LANGUAGE_TERM T2 ON MD.GUID = T2.[OBJECT_ID]
INNER JOIN TBIDB_TERM_VALUE_VARCHAR TERM ON T2.TERM_ID = TERM.GUID
INNER JOIN TBIDB_LANGUAGE T4 ON T2.LANG_ID = T4.GUID
INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE
OBJ.ACTIVE = 1 AND
T1.TITLE = 'Doctype'
AND T4.LANG_CODE = 'de-DE'
GROUP BY
TERM.TERM_VALUE
GO
CREATE OR ALTER VIEW VWIDB_LANGUAGE_TERM AS
SELECT
MD.GUID as MD_ID
,MD.IDB_OBJ_ID
,MD.ATTR_ID
,TERM.TERM_VALUE
,LTERM.LANG_ID
,LANG.LANG_CODE
,MD.ADDED_WHEN [Added When]
,MD.ADDED_WHO [Added Who]
,MD.CHANGED_WHEN [Changed When]
,MD.CHANGED_WHO [Changed Who]
FROM
TBIDB_OBJECT_METADATA MD
INNER JOIN TBIDB_LANGUAGE_TERM LTERM ON MD.GUID = LTERM.OBJECT_ID
INNER JOIN TBIDB_LANGUAGE LANG ON LTERM.LANG_ID = LANG.GUID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR TERM ON LTERM.TERM_ID = TERM.GUID
GO
CREATE OR ALTER VIEW VWIDB_DOCTYPE_LANGUAGE AS
SELECT
LT.GUID as ID
,LT.OBJECT_ID as Doctype_ID
,DT.TITLE AS SYS_TITLE
,LT.TERM_ID
,TERM.TERM_VALUE AS Doctype
,LT.LANG_ID
,LANG.LANG_CODE
,LT.ADDED_WHEN
,LT.CHANGED_WHEN
FROM
TBIDB_LANGUAGE_TERM LT INNER JOIN TBIDB_LANGUAGE_TERM_TYPE LT_T ON LT.KIND_TYPE = LT_T.GUID
INNER JOIN TBIDB_DOCTYPE DT ON LT.OBJECT_ID = DT.GUID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR TERM ON LT.TERM_ID = TERM.GUID
INNER JOIN TBIDB_LANGUAGE LANG ON LT.LANG_ID = LANG.GUID
WHERE LT.KIND_TYPE = 2
GO
CREATE VIEW VWIDB_DOCTYPE_OBJECT_STORE AS
select
A.DOCTYPE_ID
,A.OBJECT_ST_ID
,C.TITLE AS SYS_TITLE
,B.Objectstore
,B.REL_PATH
,LTERM.Doctype
,LTERM.LANG_CODE
,LTERM.LANG_ID
From
TBIDB_DOCTYPE_OBJECT_STORE A INNER JOIN VWIDB_OBJECT_STORE B ON A.OBJECT_ST_ID = B.GUID
INNER JOIN TBIDB_DOCTYPE C ON A.DOCTYPE_ID = C.GUID
INNER JOIN VWIDB_DOCTYPE_LANGUAGE LTERM ON C.GUID = LTERM.Doctype_ID
GO
CREATE OR ALTER VIEW VWIDB_DOCTYPE_BUSINESS_ENTITY AS
select
A.GUID ID,
A.DOCTYPE_ID
,A.BE_ID
,B.TITLE as BusinessEntity
,C.TITLE AS SYS_TITLE
,LTERM.Doctype
,LTERM.LANG_CODE
,LTERM.LANG_ID
,A.ADDED_WHEN
,A.ADDED_WHO
,A.CHANGED_WHO
,A.CHANGED_WHEN
From
TBIDB_DOCTYPE_BE A INNER JOIN TBIDB_BUSINESS_ENTITY B ON A.BE_ID = B.GUID
INNER JOIN TBIDB_DOCTYPE C ON A.DOCTYPE_ID = C.GUID
INNER JOIN VWIDB_DOCTYPE_LANGUAGE LTERM ON C.GUID = LTERM.Doctype_ID
GO
CREATE OR ALTER VIEW VWIDB_DOC_STATES AS
SELECT
A.GUID ID
,A.MY_OBJECT_ID AS IDB_OBJ_ID
,C.LANG_ID
,LANG.LANG_CODE
,TERM.TERM_VALUE AS STATE_LANG
,A.ADDED_WHEN
FROM
TBIDB_MYOBJECT_STATES A INNER JOIN TBIDB_OBJ_STATES B ON A.STATE_ID = B.GUID
INNER JOIN TBIDB_LANGUAGE_TERM C ON B.GUID = C.OBJECT_ID
INNER JOIN TBIDB_LANGUAGE LANG ON C.LANG_ID = LANG.GUID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR TERM ON C.TERM_ID = TERM.GUID
WHERE
C.KIND_TYPE = 3
GO
CREATE OR ALTER VIEW VWIDB_DOC_DOCTYPE AS
SELECT A.GUID,
A.IDB_OBJ_ID
,A.STRUCTURE_ID
,B.TITLE AS STRUCTURE_TITLE
,C.SYS_TITLE
,C.Doctype_ID
,C.Doctype
,C.TERM_ID
,C.LANG_CODE
,C.LANG_ID
,A.ADDED_WHO
,A.ADDED_WHEN
,B.CHANGED_WHO
,B.CHANGED_WHEN
,OBJ.ADDED_WHEN OBJ_ADDED_WHEN
,OBJ.CHANGED_WHEN OBJ_CHANGED_WHEN
,OBJ.ACTIVE OBJ_ACTIVE
FROM
TBIDB_OBJECT_STRUCTURE_TYPE A INNER JOIN TBIDB_STRUCTURE_TYPE B ON A.STRUCTURE_ID = B.GUID
INNER JOIN VWIDB_DOCTYPE_LANGUAGE C ON A.RELATION_ID = C.Doctype_ID
INNER JOIN TBIDB_OBJECT OBJ ON A.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE B.TITLE = 'DOC_DOCTYPE'
GO
CREATE OR ALTER VIEW VWIDB_STRUCTURE_NODES AS
select
T.GUID AS MetadataID,
T1.GUID AS AttributID,
T.IDB_OBJ_ID,
OBJ.PARENT_OBJ_ID,
T1.TITLE as Attribut,
T3.GUID as TERM_GUID,
T3.TERM_VALUE,
T4.LANG_CODE,
T.ADDED_WHO,
T.ADDED_WHEN,
T.CHANGED_WHO [Ge<EFBFBD>ndert wer],
T.CHANGED_WHEN [Ge<EFBFBD>ndert wann]
from TBIDB_OBJECT_METADATA T
INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTR_ID = T1.GUID
INNER JOIN TBIDB_LANGUAGE_TERM T2 ON T.GUID = T2.[OBJECT_ID]
INNER JOIN TBIDB_OBJECT OBJ ON T.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR T3 ON T2.TERM_ID = T3.GUID
INNER JOIN TBIDB_LANGUAGE T4 ON T2.LANG_ID = T4.GUID
WHERE OBJ.ACTIVE = 1 AND OBJ.KIND_TYPE_ID = 3 AND T1.GUID = (SELECT GUID FROM TBIDB_ATTRIBUTE WHERE TITLE = 'VIRTUAL_FOLDER_PART')
GO
CREATE VIEW VWOBJECT_CHECKED_OUT AS
SELECT
CHK.GUID ID,
CHK.IDB_OBJ_ID,
CHK.CHECKED_OUT_WHEN,
CHK.CHECKED_IN_WHEN,
USR.EMAIL,
USR.NAME + ', ' + USR.PRENAME USR_NAME_PRENAME
FROM TBIDB_OBJECT_CHECK_IN_OUT CHK INNER JOIN DD_ECM.dbo.TBDD_USER USR ON CHK.ADDED_WHO = USR.USERNAME
GO
CREATE VIEW [dbo].[VWIDB_OBJECT]
AS
SELECT
OBJ.IDB_OBJ_ID,
dbo.TBIDB_OBJECT_BE.BE_ID,
dbo.TBIDB_OBJECT_KIND.GUID AS KIND_ID,
dbo.TBIDB_OBJECT_KIND.KIND_NAME,
dbo.TBIDB_BUSINESS_ENTITY.TITLE AS BE_NAME,
dbo.TBIDB_OBJECT_STORE.GUID AS STORE_ID,
dbo.TBIDB_OBJECT_STORE.OBJECT_TITLE AS STORE_NAME,
DT.Doctype_ID,
DT.SYS_TITLE as DoxtypeSysTitle
FROM
dbo.TBIDB_OBJECT OBJ INNER JOIN
dbo.TBIDB_OBJECT_BE ON OBJ.IDB_OBJ_ID = dbo.TBIDB_OBJECT_BE.IDB_OBJ_ID INNER JOIN
dbo.TBIDB_OBJECT_KIND ON OBJ.KIND_TYPE_ID = dbo.TBIDB_OBJECT_KIND.GUID INNER JOIN
dbo.TBIDB_FILE_OBJECT ON dbo.TBIDB_FILE_OBJECT.IDB_OBJ_ID = OBJ.IDB_OBJ_ID INNER JOIN
dbo.TBIDB_OBJECT_STORE ON dbo.TBIDB_OBJECT_STORE.GUID = dbo.TBIDB_FILE_OBJECT.OBJ_ST_ID INNER JOIN
dbo.TBIDB_BUSINESS_ENTITY ON dbo.TBIDB_OBJECT_BE.BE_ID = dbo.TBIDB_BUSINESS_ENTITY.GUID INNER JOIN
VWIDB_DOC_DOCTYPE DT ON OBJ.IDB_OBJ_ID = DT.IDB_OBJ_ID
GO
/*###########################################
############## PROCEDURES ###################
#############################################*/
--CREATE PROCEDURE [dbo].[PRIDB_NEW_IDB_OBJECT_STATE] @pSYSSTATE VARCHAR(512),@pWHO VARCHAR(100)
--AS
--BEGIN
-- DECLARE
-- @LANG_ID TINYINT,
-- @pLANG_CODE VARCHAR(5),
-- @STATE_ID INTEGER
-- DECLARE @WHO_TERM_ID BIGINT
-- EXEC PRIDB_NEW_TERM 'VARCHAR',@pWHO,@pWHO,@TERM_ID = @WHO_TERM_ID OUTPUT;
-- DECLARE @STATE_TERM_ID BIGINT,@LANG_STATE_TERM_ID BIGINT
-- EXEC PRIDB_NEW_TERM 'VARCHAR',@pSYSSTATE,@pWHO,@TERM_ID = @STATE_TERM_ID OUTPUT;
-- IF NOT EXISTS(SELECT GUID FROM TBIDB_OBJ_STATES WHERE TITLE = @pSYSSTATE)
-- BEGIN
-- INSERT INTO TBIDB_OBJ_STATES (TITLE,ADDED_WHO) VALUES (@pSYSSTATE,@WHO_TERM_ID)
-- END
-- SELECT @STATE_ID = GUID FROM TBIDB_OBJ_STATES WHERE TITLE = @pSYSSTATE;
-- DECLARE c_PRIDB_NEW_IDB_OBJECT_STATE CURSOR FOR
-- select GUID,LANG_CODE FROM TBIDB_LANGUAGE
-- OPEN c_PRIDB_NEW_IDB_OBJECT_STATE
-- FETCH NEXT FROM c_PRIDB_NEW_IDB_OBJECT_STATE INTO @LANG_ID,@pLANG_CODE
-- WHILE @@FETCH_STATUS = 0
-- BEGIN
-- IF NOT EXISTS(SELECT GUID FROM TBIDB_OBJ_STATES_LANGUAGE WHERE STATE_ID = @STATE_ID AND LANG_ID = @LANG_ID)
-- INSERT INTO TBIDB_OBJ_STATES_LANGUAGE (STATE_ID,LANG_ID,TERM_ID,ADDED_WHO) VALUES (@STATE_ID,@LANG_ID,@STATE_TERM_ID,@WHO_TERM_ID)
-- FETCH NEXT FROM c_PRIDB_NEW_IDB_OBJECT_STATE INTO @LANG_ID,@pLANG_CODE
-- END
-- CLOSE c_PRIDB_NEW_IDB_OBJECT_STATE
-- DEALLOCATE c_PRIDB_NEW_IDB_OBJECT_STATE
--END
--GO
--EXEC PRIDB_NEW_IDB_OBJECT_STATE 'File Versioned', 'SYSTEM';
--EXEC PRIDB_NEW_IDB_OBJECT_STATE 'File opened', 'SYSTEM';
--EXEC PRIDB_NEW_IDB_OBJECT_STATE 'File added', 'SYSTEM';
--EXEC PRIDB_NEW_IDB_OBJECT_STATE 'File changed', 'SYSTEM';
--EXEC PRIDB_NEW_IDB_OBJECT_STATE 'File deleted', 'SYSTEM';
--EXEC PRIDB_NEW_IDB_OBJECT_STATE 'Metadata changed', 'SYSTEM';
--EXEC PRIDB_NEW_IDB_OBJECT_STATE 'Attributevalue deleted', 'SYSTEM';
--GO
--CREATE PROCEDURE [dbo].[PRIDB_UPDATE_IDB_OBJECT_STATE] @pOLD_TERM VARCHAR(512), @pNEW_TERM VARCHAR(512),@pLANG_CODE VARCHAR(5),@pWHO VARCHAR(100)
--AS
--BEGIN
-- DECLARE
-- @LANG_ID TINYINT,
-- @STATE_ID INTEGER
-- DECLARE @WHO_TERM_ID BIGINT
-- SELECT @LANG_ID = GUID FROM TBIDB_LANGUAGE WHERE LANG_CODE = @pLANG_CODE;
-- EXEC PRIDB_NEW_TERM 'VARCHAR',@pWHO,@pWHO,@TERM_ID = @WHO_TERM_ID OUTPUT;
-- DECLARE @NEW_STATE_TERM_ID BIGINT,@OLD_STATE_TERM_ID BIGINT
-- EXEC PRIDB_NEW_TERM 'VARCHAR',@pNEW_TERM,@pWHO,@TERM_ID = @NEW_STATE_TERM_ID OUTPUT;
-- EXEC PRIDB_NEW_TERM 'VARCHAR',@pOLD_TERM,@pWHO,@TERM_ID = @OLD_STATE_TERM_ID OUTPUT;
-- UPDATE TBIDB_OBJ_STATES_LANGUAGE SET TERM_ID = @NEW_STATE_TERM_ID,CHANGED_WHO = @WHO_TERM_ID WHERE TERM_ID = @OLD_STATE_TERM_ID AND LANG_ID = @LANG_ID
-- AND TERM_ID <> @NEW_STATE_TERM_ID
--END
--GO
CREATE OR ALTER VIEW [dbo].[VWIDB_STATES_LANGUAGE] AS
SELECT
A.GUID AS STATE_ID,
B.GUID LANG_TERM_ID,
A.TITLE AS STATE_TITLE,
D.TERM_VALUE AS STATE_TERM,
B.LANG_ID,
C.LANG_CODE,
E.TERM_VALUE ADDED_WHO,
A.ADDED_WHEN,
F.TERM_VALUE CHANGED_WHO,
B.CHANGED_WHEN
FROM
TBIDB_STATES A
INNER JOIN TBIDB_LANGUAGE_TERM B ON A.GUID = B.OBJECT_ID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR D ON B.TERM_ID = D.GUID
INNER JOIN TBIDB_LANGUAGE C ON B.LANG_ID = C.GUID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR E ON A.ADDED_WHO = E.GUID
INNER JOIN TBIDB_TERM_VALUE_VARCHAR F ON B.CHANGED_WHO = F.GUID
WHERE B.KIND_TYPE = 3
GO
-- =============================================
-- Author: DD MS
-- Changed: 25.11.2021 @TERM_TYPE_ID = 6
-- Changed: 25.08.2020 @TERM_TYPE_ID = 7 AND UPPER(@TERM)
-- =============================================
CREATE PROCEDURE [dbo].[PRIDB_NEW_TERM] @MD_TYPE VARCHAR(100),@TERM VARCHAR(MAX), @WHO VARCHAR(100), @TERM_ID BIGINT OUTPUT
AS
BEGIN
DECLARE @TERM_TYPE_ID TINYINT
SELECT @TERM_TYPE_ID = GUID FROM TBIDB_ATTRIBUTE_TYPE WHERE UPPER(NAME_TYPE) = UPPER(@MD_TYPE)
IF @TERM_TYPE_ID = 7 AND UPPER(@TERM) = 'TRUE'
SET @TERM = 1
ELSE IF @TERM_TYPE_ID = 7 AND UPPER(@TERM) = 'FALSE'
SET @TERM = 0
--PRINT 'PRIDB_NEW_TERM: TERM_TYPE_ID IS: ' + CONVERT(VARCHAR(2),@TERM_TYPE_ID) + ' # TERM: ' + @TERM
IF @TERM_TYPE_ID IN (1,8) --VARCHAR
IF NOT EXISTS(SELECT GUID FROM TBIDB_TERM_VALUE_VARCHAR WHERE UPPER(TERM_VALUE) = UPPER(@TERM))
BEGIN
INSERT INTO TBIDB_TERM_VALUE_VARCHAR (TERM_VALUE,ADDED_WHO) VALUES (@TERM,@WHO);
SELECT @TERM_ID = MAX(GUID) FROM TBIDB_TERM_VALUE_VARCHAR
END
ELSE
SELECT @TERM_ID = GUID FROM TBIDB_TERM_VALUE_VARCHAR WHERE UPPER(TERM_VALUE) = UPPER(@TERM)
ELSE IF @TERM_TYPE_ID IN (2,7,9) --BIGINT
IF NOT EXISTS(SELECT GUID FROM TBIDB_TERM_VALUE_INTEGER WHERE TERM_VALUE = CONVERT(BIGINT,@TERM))
BEGIN
INSERT INTO TBIDB_TERM_VALUE_INTEGER (TERM_VALUE,ADDED_WHO) VALUES (CONVERT(BIGINT,@TERM),@WHO);
SELECT @TERM_ID = MAX(GUID) FROM TBIDB_TERM_VALUE_INTEGER
END
ELSE
SELECT @TERM_ID = GUID FROM TBIDB_TERM_VALUE_INTEGER WHERE TERM_VALUE = CONVERT(BIGINT,@TERM)
ELSE IF @TERM_TYPE_ID = 3 --FLOAT
IF NOT EXISTS(SELECT GUID FROM TBIDB_TERM_VALUE_FLOAT WHERE TERM_VALUE = CONVERT(FLOAT,@TERM))
BEGIN
INSERT INTO TBIDB_TERM_VALUE_FLOAT (TERM_VALUE,ADDED_WHO) VALUES (CONVERT(FLOAT,@TERM),@WHO);
SELECT @TERM_ID = MAX(GUID) FROM TBIDB_TERM_VALUE_FLOAT
END
ELSE
SELECT @TERM_ID = GUID FROM TBIDB_TERM_VALUE_FLOAT WHERE TERM_VALUE = CONVERT(FLOAT,@TERM)
ELSE IF @TERM_TYPE_ID = 4 --DECIMAL
IF NOT EXISTS(SELECT GUID FROM TBIDB_TERM_VALUE_DECIMAL WHERE TERM_VALUE = CONVERT(DECIMAL(19,0),@TERM))
BEGIN
INSERT INTO TBIDB_TERM_VALUE_DECIMAL (TERM_VALUE,ADDED_WHO) VALUES (CONVERT(DECIMAL(19,0),@TERM),@WHO);
SELECT @TERM_ID = MAX(GUID) FROM TBIDB_TERM_VALUE_DECIMAL
END
ELSE
SELECT @TERM_ID = GUID FROM TBIDB_TERM_VALUE_DECIMAL WHERE TERM_VALUE = CONVERT(DECIMAL(19,0),@TERM)
ELSE IF @TERM_TYPE_ID = 5 --DATE
IF NOT EXISTS(SELECT GUID FROM TBIDB_TERM_VALUE_DATE WHERE TERM_VALUE = CONVERT(DATE,@TERM))
BEGIN
INSERT INTO TBIDB_TERM_VALUE_DATE (TERM_VALUE,ADDED_WHO) VALUES (CONVERT(DATE,@TERM),@WHO);
SELECT @TERM_ID = MAX(GUID) FROM TBIDB_TERM_VALUE_DATE
END
ELSE
SELECT @TERM_ID = GUID FROM TBIDB_TERM_VALUE_DATE WHERE TERM_VALUE = CONVERT(DATE,@TERM)
ELSE IF @TERM_TYPE_ID = 6 --DATETIME
IF NOT EXISTS(SELECT GUID FROM TBIDB_TERM_VALUE_DATETIME WHERE TERM_VALUE = CONVERT(DATETIME,@TERM))
BEGIN
INSERT INTO TBIDB_TERM_VALUE_DATETIME (TERM_VALUE,ADDED_WHO) VALUES (CONVERT(DATETIME,@TERM),@WHO);
SELECT @TERM_ID = MAX(GUID) FROM TBIDB_TERM_VALUE_DATETIME
END
ELSE
SELECT @TERM_ID = GUID FROM TBIDB_TERM_VALUE_DATE WHERE TERM_VALUE = CONVERT(DATE,@TERM)
PRINT '### PRIDB_NEW_TERM: TERM-ID: ' + CONVERT(VARCHAR(10),@TERM_ID) + '###'
END
GO
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_NEW_IDB_STATE] @pSTATE VARCHAR(512),@pWHO VARCHAR(100)
AS
BEGIN
DECLARE
@LANG_ID INTEGER,
@pLANG_CODE VARCHAR(5),
@STATE_ID INTEGER
DECLARE @STATE_TERM_ID BIGINT,@LANG_STATE_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@pSTATE,@pWHO,@TERM_ID = @STATE_TERM_ID OUTPUT;
DECLARE @ADDED_WHO_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@pWHO,@pWHO,@TERM_ID = @ADDED_WHO_TERM_ID OUTPUT;
IF NOT EXISTS(SELECT GUID FROM TBIDB_STATES WHERE TITLE = @pSTATE)
BEGIN
INSERT INTO TBIDB_STATES (TITLE,ADDED_WHO) VALUES (@pSTATE,@ADDED_WHO_TERM_ID);
END
SELECT @STATE_ID = GUID FROM TBIDB_STATES WHERE TITLE = @pSTATE;
DECLARE c_PRIDB_NEW_IDB_OBJECT_STATE CURSOR FOR
select GUID,LANG_CODE FROM TBIDB_LANGUAGE WHERE CREATE_DEFAULT_ENTRY = 1;
OPEN c_PRIDB_NEW_IDB_OBJECT_STATE
FETCH NEXT FROM c_PRIDB_NEW_IDB_OBJECT_STATE INTO @LANG_ID,@pLANG_CODE
WHILE @@FETCH_STATUS = 0
BEGIN
IF NOT EXISTS(SELECT GUID FROM TBIDB_LANGUAGE_TERM WHERE [OBJECT_ID] = @STATE_ID AND LANG_ID = @LANG_ID AND KIND_TYPE = 3)
INSERT INTO TBIDB_LANGUAGE_TERM (KIND_TYPE, [OBJECT_ID],TERM_ID,LANG_ID,ADDED_WHO) VALUES(3, @STATE_ID,@STATE_TERM_ID,@LANG_ID,@ADDED_WHO_TERM_ID);
ELSE
UPDATE TBIDB_LANGUAGE_TERM SET TERM_ID = @STATE_TERM_ID,CHANGED_WHO = @ADDED_WHO_TERM_ID WHERE [OBJECT_ID] = @STATE_ID AND LANG_ID = @LANG_ID
AND TERM_ID <> @STATE_TERM_ID;
FETCH NEXT FROM c_PRIDB_NEW_IDB_OBJECT_STATE INTO @LANG_ID,@pLANG_CODE
END
CLOSE c_PRIDB_NEW_IDB_OBJECT_STATE
DEALLOCATE c_PRIDB_NEW_IDB_OBJECT_STATE
END
GO
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_SET_IDB_STATE_LANG] @pSTATE VARCHAR(100),@pSTATE_LANG VARCHAR(100), @pLANG_CODE VARCHAR(5),@pWHO VARCHAR(100)
AS
BEGIN
DECLARE
@LANG_ID INTEGER,
@pSTATE_ID INTEGER
SELECT @LANG_ID = GUID FROM TBIDB_LANGUAGE WHERE LANG_CODE = @pLANG_CODE;
SELECT @pSTATE_ID = GUID FROM TBIDB_STATES WHERE TITLE = @pSTATE
DECLARE @STATE_TERM_ID BIGINT,@LANG_STATE_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@pSTATE_LANG,@pWHO,@TERM_ID = @STATE_TERM_ID OUTPUT;
DECLARE @CHANGED_WHO_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@pWHO,@pWHO,@TERM_ID = @CHANGED_WHO_TERM_ID OUTPUT;
IF NOT EXISTS(SELECT GUID FROM TBIDB_LANGUAGE_TERM WHERE [OBJECT_ID] = @pSTATE_ID AND LANG_ID = @LANG_ID AND KIND_TYPE = 3)
INSERT INTO TBIDB_LANGUAGE_TERM (KIND_TYPE, [OBJECT_ID],TERM_ID,LANG_ID,ADDED_WHO) VALUES(3, @pSTATE_ID,@STATE_TERM_ID,@LANG_ID,@CHANGED_WHO_TERM_ID);
ELSE
UPDATE TBIDB_LANGUAGE_TERM SET TERM_ID = @STATE_TERM_ID,CHANGED_WHO = @CHANGED_WHO_TERM_ID WHERE KIND_TYPE = 3 AND [OBJECT_ID] = @pSTATE_ID AND LANG_ID = @LANG_ID AND TERM_ID <> @STATE_TERM_ID;
END
GO
EXEC PRIDB_NEW_IDB_STATE 'Started', 'SYSTEM';
EXEC PRIDB_NEW_IDB_STATE 'Ended', 'SYSTEM';
EXEC PRIDB_NEW_IDB_STATE 'File Versioned','SYSTEM';
EXEC PRIDB_NEW_IDB_STATE 'File added', 'SYSTEM';
EXEC PRIDB_NEW_IDB_STATE 'File changed', 'SYSTEM';
EXEC PRIDB_NEW_IDB_STATE 'File deleted', 'SYSTEM';
EXEC PRIDB_NEW_IDB_STATE 'Metadata changed','SYSTEM';
EXEC PRIDB_NEW_IDB_STATE 'Attributevalue deleted','SYSTEM';
EXEC PRIDB_NEW_IDB_STATE 'File opened', 'SYSTEM';
EXEC PRIDB_NEW_IDB_STATE 'File Checked Out', 'SYSTEM';
EXEC PRIDB_NEW_IDB_STATE 'File Checked In', 'SYSTEM';
EXEC PRIDB_SET_IDB_STATE_LANG 'File Versioned','Datei versioniert', 'de-DE', 'SYSTEM';
EXEC PRIDB_SET_IDB_STATE_LANG 'File added','Datei erstellt', 'de-DE', 'SYSTEM';
EXEC PRIDB_SET_IDB_STATE_LANG 'File changed','Datei ge<67>ndert', 'de-DE', 'SYSTEM';
EXEC PRIDB_SET_IDB_STATE_LANG 'File deleted','Datei gel<65>scht', 'de-DE', 'SYSTEM';
EXEC PRIDB_SET_IDB_STATE_LANG 'Metadata changed','Attributwert ge<67>ndert', 'de-DE', 'SYSTEM';
EXEC PRIDB_SET_IDB_STATE_LANG 'Attributevalue deleted','Attributwert gel<65>scht', 'de-DE', 'SYSTEM';
EXEC PRIDB_SET_IDB_STATE_LANG 'File opened','Datei ge<67>ffnet', 'de-DE', 'SYSTEM';
EXEC PRIDB_SET_IDB_STATE_LANG 'File Checked Out','Datei ausgechecked', 'de-DE', 'SYSTEM';
EXEC PRIDB_SET_IDB_STATE_LANG 'File Checked In','Datei wieder eingecheckt', 'de-DE', 'SYSTEM';
GO
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_DELETE_ATTRIBUTE_DATA] @IDB_OBJ_ID BIGINT, @ATTRIBUTE VARCHAR(100), @WHO VARCHAR(100)
AS
BEGIN
DECLARE
@ATTR_ID INTEGER,
@ATTR_TYP_ID TINYINT,
@TYP_DESCR VARCHAR(100),
@MULTI BIT,
@TEXT_TERM BIGINT,
@TERM_ID BIGINT,
@USER_DELETE_ID INTEGER,
@ERROR as BIT,
@LTERM_GUID BIGINT
SET @ERROR = 0
SELECT @USER_DELETE_ID = COALESCE(MAX(USER_DELETE_ID),0) + 1 FROM TBIDB_OBJECT_METADATA_DELETE WHERE UPPER(DELETED_WHO) = UPPER(@WHO)
SELECT @ATTR_ID = T.GUID,@ATTR_TYP_ID = T.TYP_ID FROM TBIDB_ATTRIBUTE T WHERE UPPER(T.TITLE) = UPPER(@ATTRIBUTE)
IF @ATTR_TYP_ID IN (1,8) --VARCHAR
BEGIN TRY
DECLARE cursor_DeleteLog CURSOR LOCAL FOR
SELECT LTERM.GUID, MD.IDB_OBJ_ID,LTERM.TERM_ID
FROM
TBIDB_OBJECT_METADATA MD INNER JOIN TBIDB_LANGUAGE_TERM LTERM ON MD.GUID = LTERM.[OBJECT_ID]
WHERE MD.ATTR_ID = @ATTR_ID AND MD.IDB_OBJ_ID = @IDB_OBJ_ID
OPEN cursor_DeleteLog
FETCH NEXT FROM cursor_DeleteLog INTO @LTERM_GUID,@IDB_OBJ_ID,@TEXT_TERM
WHILE @@FETCH_STATUS = 0
BEGIN
INSERT INTO TBIDB_OBJECT_METADATA_DELETE (IDB_OBJ_ID,ATTR_ID,TEXT_TERM_ID,DELETED_WHO,USER_DELETE_ID)
VALUES (@IDB_OBJ_ID,@ATTR_ID, @TEXT_TERM, @WHO,@USER_DELETE_ID);
FETCH NEXT FROM cursor_DeleteLog INTO @LTERM_GUID,@IDB_OBJ_ID,@TEXT_TERM
END
CLOSE cursor_DeleteLog
DEALLOCATE cursor_DeleteLog
DELETE FROM TBIDB_LANGUAGE_TERM WHERE [OBJECT_ID] IN (SELECT GUID FROM TBIDB_OBJECT_METADATA
WHERE ATTR_ID = @ATTR_ID AND IDB_OBJ_ID = @IDB_OBJ_ID);
DELETE FROM TBIDB_OBJECT_METADATA
WHERE ATTR_ID = @ATTR_ID AND IDB_OBJ_ID = @IDB_OBJ_ID;
END TRY
BEGIN CATCH
PRINT 'ERROR WHILE DELETING FROM TBIDB_OBJECT_METADATA FOR ATTRIBUTE [' + @ATTRIBUTE + ']'
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
DELETE FROM TBIDB_OBJECT_METADATA_DELETE WHERE USER_DELETE_ID = @USER_DELETE_ID
SET @ERROR = 1
END CATCH
ELSE IF @ATTR_TYP_ID IN (2,7,9) --BIGINT
BEGIN TRY
DECLARE cursor_DeleteLog CURSOR LOCAL FOR
SELECT T.IDB_OBJ_ID,T.INT_TERM_ID FROM TBIDB_OBJECT_METADATA T WHERE T.ATTR_ID = @ATTR_ID AND T.IDB_OBJ_ID = @IDB_OBJ_ID
OPEN cursor_DeleteLog
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@TERM_ID
WHILE @@FETCH_STATUS = 0
BEGIN
INSERT INTO TBIDB_OBJECT_METADATA_DELETE (IDB_OBJ_ID,ATTR_ID,INT_TERM_ID,DELETED_WHO,USER_DELETE_ID)
VALUES (@IDB_OBJ_ID,@ATTR_ID, @TERM_ID, @WHO,@USER_DELETE_ID)
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@TERM_ID
END
CLOSE cursor_DeleteLog
DEALLOCATE cursor_DeleteLog
DELETE T
FROM TBIDB_OBJECT_METADATA T
WHERE T.ATTR_ID = @ATTR_ID AND T.IDB_OBJ_ID = @IDB_OBJ_ID
END TRY
BEGIN CATCH
PRINT 'ERROR WHILE DELETING (INTEGER) FROM TBIDB_OBJECT_METADATA FOR ATTRIBUTE [' + @ATTRIBUTE + ']'
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
DELETE FROM TBIDB_OBJECT_METADATA_DELETE WHERE USER_DELETE_ID = @USER_DELETE_ID
SET @ERROR = 1
END CATCH
ELSE IF @ATTR_TYP_ID = 3 --FLOAT
BEGIN TRY
DECLARE cursor_DeleteLog CURSOR LOCAL FOR
SELECT T.IDB_OBJ_ID,T.FLOAT_TERM_ID FROM TBIDB_OBJECT_METADATA T WHERE T.ATTR_ID = @ATTR_ID AND T.IDB_OBJ_ID = @IDB_OBJ_ID
OPEN cursor_DeleteLog
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@TERM_ID
WHILE @@FETCH_STATUS = 0
BEGIN
INSERT INTO TBIDB_OBJECT_METADATA_DELETE (IDB_OBJ_ID,ATTR_ID,FLOAT_TERM_ID,DELETED_WHO,USER_DELETE_ID)
VALUES (@IDB_OBJ_ID,@ATTR_ID, @TERM_ID, @WHO,@USER_DELETE_ID)
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@TERM_ID
END
CLOSE cursor_DeleteLog
DEALLOCATE cursor_DeleteLog
DELETE T
FROM TBIDB_OBJECT_METADATA T
WHERE T.ATTR_ID = @ATTR_ID AND T.IDB_OBJ_ID = @IDB_OBJ_ID
END TRY
BEGIN CATCH
PRINT 'ERROR WHILE DELETING (FLOAT) FROM TBIDB_OBJECT_METADATA FOR ATTRIBUTE [' + @ATTRIBUTE + ']'
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
DELETE FROM TBIDB_OBJECT_METADATA_DELETE WHERE USER_DELETE_ID = @USER_DELETE_ID
SET @ERROR = 1
END CATCH
ELSE IF @ATTR_TYP_ID = 4 --DECIMAL
BEGIN TRY
DECLARE cursor_DeleteLog CURSOR LOCAL FOR
SELECT T.IDB_OBJ_ID,T.DEC_TERM_ID FROM TBIDB_OBJECT_METADATA T WHERE T.ATTR_ID = @ATTR_ID AND T.IDB_OBJ_ID = @IDB_OBJ_ID
OPEN cursor_DeleteLog
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@TERM_ID
WHILE @@FETCH_STATUS = 0
BEGIN
INSERT INTO TBIDB_OBJECT_METADATA_DELETE (IDB_OBJ_ID,ATTR_ID,DEC_TERM_ID,DELETED_WHO,USER_DELETE_ID)
VALUES (@IDB_OBJ_ID,@ATTR_ID, @TERM_ID, @WHO,@USER_DELETE_ID)
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@TERM_ID
END
CLOSE cursor_DeleteLog
DEALLOCATE cursor_DeleteLog
DELETE T
FROM TBIDB_OBJECT_METADATA T
WHERE T.ATTR_ID = @ATTR_ID AND T.IDB_OBJ_ID = @IDB_OBJ_ID
END TRY
BEGIN CATCH
PRINT 'ERROR WHILE DELETING (DECIMAL) FROM TBIDB_OBJECT_METADATA FOR ATTRIBUTE [' + @ATTRIBUTE + ']'
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
DELETE FROM TBIDB_OBJECT_METADATA_DELETE WHERE USER_DELETE_ID = @USER_DELETE_ID
SET @ERROR = 1
END CATCH
ELSE IF @ATTR_TYP_ID = 5 --DATE
BEGIN TRY
DECLARE cursor_DeleteLog CURSOR LOCAL FOR
SELECT T.IDB_OBJ_ID,T.DATE_TERM_ID FROM TBIDB_OBJECT_METADATA T WHERE T.ATTR_ID = @ATTR_ID AND T.IDB_OBJ_ID = @IDB_OBJ_ID
OPEN cursor_DeleteLog
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@TERM_ID
WHILE @@FETCH_STATUS = 0
BEGIN
INSERT INTO TBIDB_OBJECT_METADATA_DELETE (IDB_OBJ_ID,ATTR_ID,DATE_TERM_ID,DELETED_WHO,USER_DELETE_ID)
VALUES (@IDB_OBJ_ID,@ATTR_ID, @TERM_ID, @WHO,@USER_DELETE_ID)
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@TERM_ID
END
CLOSE cursor_DeleteLog
DEALLOCATE cursor_DeleteLog
DELETE T
FROM TBIDB_OBJECT_METADATA T
WHERE T.ATTR_ID = @ATTR_ID AND T.IDB_OBJ_ID = @IDB_OBJ_ID
END TRY
BEGIN CATCH
PRINT 'ERROR WHILE DELETING (DATE) FROM TBIDB_OBJECT_METADATA FOR ATTRIBUTE [' + @ATTRIBUTE + ']'
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
DELETE FROM TBIDB_OBJECT_METADATA_DELETE WHERE USER_DELETE_ID = @USER_DELETE_ID
SET @ERROR = 1
END CATCH
--IF @ERROR = 0
-- BEGIN
-- UPDATE TBIDB_ATTRIBUTE SET DELETED = 1, DELETED_WHO = @WHO WHERE GUID = @ATTR_ID;
-- END
END
GO
CREATE PROCEDURE [dbo].[PRIDB_OBJECT_SET_DELETED] @IDB_OBJECT BIGINT, @WHO VARCHAR(100)
AS
BEGIN
UPDATE TBIDB_OBJECT SET DELETED = 1,CHANGED_WHO = @WHO WHERE IDB_OBJ_ID = @IDB_OBJECT
END
GO
CREATE PROCEDURE [dbo].[PRIDB_CHECK_DOCINFO] @IDB_OBJ_ID BIGINT, @OBJ_ST_ID INT, @REL_PATH VARCHAR(512),@WHO VARCHAR(100), @REF_DOCID BIGINT = 0, @BE VARCHAR(500) = '', @IDB_OBJ_ID_OUT BIGINT OUTPUT
AS
BEGIN
DECLARE
@SHARE_PATH VARCHAR(100),
@OBJ_STORE_PATH VARCHAR(250),
@NEW_FULL_PATH VARCHAR(512),
@FILENAME_EXT VARCHAR(250),
@FILENAME_ONLY VARCHAR(250),
@RELATIVE_PATH VARCHAR(512),
@RELATIVE_PATH_ONLY VARCHAR(512),
@EXT VARCHAR(10)
SELECT
@SHARE_PATH = T.CAT_STRING, @OBJ_STORE_PATH = T1.OBJ_PATH
FROM TBIDB_CATALOG T, TBIDB_OBJECT_STORE T1 WHERE T1.CAT_ID = T.GUID AND T1.GUID = @OBJ_ST_ID
SET @NEW_FULL_PATH = UPPER(@SHARE_PATH + '\' + @OBJ_STORE_PATH + '\' + @REL_PATH)
SET @NEW_FULL_PATH = REPLACE(@NEW_FULL_PATH,'\\','')
SET @RELATIVE_PATH = UPPER(@REL_PATH)
PRINT 'PRIDB_NEW_DOCUMENT - @NEW_FULL_PATH: ' + @NEW_FULL_PATH
PRINT 'PRIDB_NEW_DOCUMENT - @RELATIVE_PATH: ' + @RELATIVE_PATH
SELECT @FILENAME_EXT = [dbo].[FNGetFileName] (@NEW_FULL_PATH);
SELECT @FILENAME_ONLY = [dbo].[FNGetFileNameWithoutExtension] (@NEW_FULL_PATH);
SELECT @EXT = UPPER([dbo].[FNGetExtension] (@NEW_FULL_PATH));
SET @RELATIVE_PATH_ONLY = REPLACE(@REL_PATH,'\' + @FILENAME_EXT,'')
DECLARE @RELATIVE_PATH_ONLY_TERM BIGINT,@EXTENSION_TERM BIGINT
EXECUTE [dbo].[PRIDB_NEW_TERM] 'Varchar',@RELATIVE_PATH_ONLY,@WHO, @TERM_ID = @RELATIVE_PATH_ONLY_TERM OUTPUT
EXECUTE [dbo].[PRIDB_NEW_TERM] 'Varchar',@EXT,@WHO, @TERM_ID = @EXTENSION_TERM OUTPUT
PRINT 'PRIDB_NEW_DOCUMENT - @RELATIVE_PATH_ONLY: ' + @RELATIVE_PATH_ONLY
--PRINT '@EXT: ' + @EXT
IF EXISTS(SELECT GUID FROM TBIDB_DOC_INFO WHERE IDB_OBJ_ID = @IDB_OBJ_ID)
UPDATE [TBIDB_DOC_INFO] SET [OBJ_ST_ID] = @OBJ_ST_ID, [FILENAME_EXT] = @FILENAME_EXT,[FILENAME_ONLY] = @FILENAME_ONLY
,EXTENSION_TERM = @EXTENSION_TERM
,[RELATIVE_PATH] = @RELATIVE_PATH
,RELATIVE_PATH_ONLY_TERM = @RELATIVE_PATH_ONLY_TERM
,CHANGED_WHO = @WHO
WHERE IDB_OBJ_ID = @IDB_OBJ_ID
ELSE
BEGIN
INSERT INTO [dbo].[TBIDB_DOC_INFO]
([IDB_OBJ_ID]
,[OBJ_ST_ID]
,[FILENAME_EXT]
,[FILENAME_ONLY]
,EXTENSION_TERM
,[RELATIVE_PATH]
,RELATIVE_PATH_ONLY_TERM
,[ADDED_WHO])
VALUES
(@IDB_OBJ_ID
,@OBJ_ST_ID
,@FILENAME_EXT
,@FILENAME_ONLY
,@EXTENSION_TERM
,@RELATIVE_PATH
,@RELATIVE_PATH_ONLY_TERM
,@WHO)
END
SET @IDB_OBJ_ID_OUT = @IDB_OBJ_ID
END
GO
CREATE PROCEDURE [dbo].[PRIDB_NEW_OBJ_DATA] @IDB_OBJ_ID BIGINT,@ATTRIBUTE VARCHAR(100),@WHO VARCHAR(100), @TERM_VAL VARCHAR(MAX),
@LANG_CODE VARCHAR(5) = 'de-DE', @FOREIGN_KEY BIGINT = 0, @OMD_ID BIGINT OUTPUT
AS
BEGIN
DECLARE
@ATTR_ID INTEGER,
@TYP_ID TINYINT,
@TYP_DESCR VARCHAR(100),
@MULTI BIT,
@LANG_ID INT,
@WHO_TERM_ID BIGINT,
@ATTR_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@WHO,@WHO,@TERM_ID = @WHO_TERM_ID OUTPUT;
--PRINT 'GETTIN ATTR-TERMID...'
EXEC PRIDB_NEW_TERM 'VARCHAR',@ATTRIBUTE,@WHO,@TERM_ID = @ATTR_TERM_ID OUTPUT;
--PRINT '@FOREIGN_KEY: ' + CONVERT(VARCHAR(50),@FOREIGN_KEY)
IF @FOREIGN_KEY <> 0 AND @IDB_OBJ_ID <> @FOREIGN_KEY
BEGIN
IF NOT EXISTS(SELECT IDB_OBJ_ID FROM TBIDB_OBJECT WHERE REFERENCE_KEY = @FOREIGN_KEY)
BEGIN
PRINT 'FOUND NO IDB-OBJECT FOR REFERENCE KEY: ' + CONVERT(VARCHAR(50),@FOREIGN_KEY)
END
ELSE
BEGIN
SELECT @IDB_OBJ_ID = IDB_OBJ_ID FROM TBIDB_OBJECT WHERE REFERENCE_KEY = @FOREIGN_KEY
--Print 'PRIDB_NEW_OBJ_DATA: Checked the DocID as Reference: ' + Convert(Varchar(10),@IDB_OBJ_ID)
END
END
--IF NOT EXISTS(SELECT ATTR_ID FROM VWIDB_BE_ATTRIBUTE WHERE ATTR_TERM_ID = @ATTR_TERM_ID AND LANG_CODE = @LANG_CODE)
-- BEGIN
-- DECLARE @MSG VARCHAR(100)
-- SET @MSG = 'NO VALID ATTRIBUTE [' + @ATTRIBUTE + ']'
-- RAISERROR (@MSG,16,1)
-- END
SELECT @ATTR_ID = T.ATTR_ID, @TYP_ID = T.TYP_ID, @MULTI = T.MULTI_CONTEXT,@TYP_DESCR = T.TYPE_NAME FROM VWIDB_BE_ATTRIBUTE T
WHERE ATTR_TERM_ID = @ATTR_TERM_ID AND LANG_CODE = @LANG_CODE
--PRINT 'ATTRIBUTID: ' + CONVERT(VARCHAR(10),@ATTR_ID)
IF LEN(@ATTR_ID) = 0
BEGIN
DECLARE @MSG VARCHAR(100)
SET @MSG = 'NO VALID ATTRIBUTE [' + @ATTRIBUTE + ']'
RAISERROR (@MSG,16,1)
END
SELECT @LANG_ID = GUID FROM TBIDB_LANGUAGE WHERE LANG_CODE = @LANG_CODE
DECLARE @MY_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM @TYP_DESCR,@TERM_VAL,@WHO,@TERM_ID = @MY_TERM_ID OUTPUT;
--PRINT 'PRIDB_NEW_OBJ_DATA: @TYP_ID is: ' + Convert(Varchar(10),@TYP_ID)
IF @TYP_ID IN (1,8) --VARCHAR
BEGIN
IF NOT EXISTS(SELECT GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID)
BEGIN
PRINT 'OBJ_METADATA_ENTRY NOT EXISTING...'
INSERT INTO [dbo].[TBIDB_OBJECT_METADATA]
([IDB_OBJ_ID]
,[ATTR_ID]
,[ADDED_WHO])
VALUES
(@IDB_OBJ_ID
,@ATTR_ID
,@WHO);
END
SELECT @OMD_ID = GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID
IF @TYP_ID = 1 --Single Varchar
BEGIN
IF NOT EXISTS(SELECT GUID FROM TBIDB_LANGUAGE_TERM WHERE LANG_ID = @LANG_ID AND [OBJECT_ID] = @OMD_ID)
BEGIN
PRINT 'INSERT LANGUAGE-TERM...'
INSERT INTO TBIDB_LANGUAGE_TERM (KIND_TYPE, [OBJECT_ID],TERM_ID,LANG_ID,ADDED_WHO) VALUES(1, @OMD_ID,@MY_TERM_ID,@LANG_ID,@WHO_TERM_ID);
EXEC PRIDB_OBJECT_SUBSTRUCTURE_CHANGED @IDB_OBJ_ID,@WHO;
END
ELSE
BEGIN
PRINT 'UPDATE LANGUAGE-TERM...'
DECLARE @OLD_TERM_ID BIGINT
SELECT @OLD_TERM_ID = TERM_ID FROM TBIDB_LANGUAGE_TERM WHERE LANG_ID = @LANG_ID AND [OBJECT_ID] = @OMD_ID;
IF @OLD_TERM_ID <> @MY_TERM_ID
BEGIN
UPDATE TBIDB_LANGUAGE_TERM SET ADDED_WHO = @WHO_TERM_ID, TERM_ID = @MY_TERM_ID WHERE [OBJECT_ID] = @OMD_ID AND LANG_ID = @LANG_ID;
EXEC PRIDB_OBJECT_SUBSTRUCTURE_CHANGED @IDB_OBJ_ID,@WHO;
INSERT INTO TBIDB_OBJECT_METADATA_CHANGE (
IDB_OBJ_ID, ATTR_ID, OLD_TEXT_TERM, NEW_TEXT_TERM, CHANGED_WHO) VALUES (
@IDB_OBJ_ID,@ATTR_ID, @OLD_TERM_ID, @MY_TERM_ID, @WHO);
END
END
END
END
ELSE IF @TYP_ID IN (2,7,9) --BIGINT
BEGIN
IF NOT EXISTS(SELECT GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID)
BEGIN
INSERT INTO [dbo].[TBIDB_OBJECT_METADATA]
([IDB_OBJ_ID]
,[ATTR_ID]
,[INT_TERM_ID]
,[ADDED_WHO])
VALUES
(@IDB_OBJ_ID
,@ATTR_ID
,@MY_TERM_ID
,@WHO)
END
ELSE
IF EXISTS(SELECT GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND [INT_TERM_ID] <> @MY_TERM_ID)
UPDATE TBIDB_OBJECT_METADATA SET [INT_TERM_ID] = @MY_TERM_ID, CHANGED_WHO = @WHO WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID
SELECT @OMD_ID = GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND INT_TERM_ID = @MY_TERM_ID
END
ELSE IF @TYP_ID = 3 --FLOAT
BEGIN
IF NOT EXISTS(SELECT GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID)
BEGIN
INSERT INTO [dbo].[TBIDB_OBJECT_METADATA]
([IDB_OBJ_ID]
,[ATTR_ID]
,[FLOAT_TERM_ID]
,[ADDED_WHO])
VALUES
(@IDB_OBJ_ID
,@ATTR_ID
,@MY_TERM_ID
,@WHO)
END
ELSE
IF EXISTS(SELECT GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND [FLOAT_TERM_ID] <> @MY_TERM_ID)
UPDATE TBIDB_OBJECT_METADATA SET [FLOAT_TERM_ID] = @MY_TERM_ID, CHANGED_WHO = @WHO WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID
SELECT @OMD_ID = GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND FLOAT_TERM_ID = @MY_TERM_ID
END
ELSE IF @TYP_ID = 4 --DECIMAL
BEGIN
IF NOT EXISTS(SELECT GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID)
BEGIN
INSERT INTO [dbo].[TBIDB_OBJECT_METADATA]
([IDB_OBJ_ID]
,[ATTR_ID]
,[DEC_TERM_ID]
,[ADDED_WHO])
VALUES
(@IDB_OBJ_ID
,@ATTR_ID
,@MY_TERM_ID
,@WHO)
END
ELSE
IF EXISTS(SELECT GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND DEC_TERM_ID <> @MY_TERM_ID)
UPDATE TBIDB_OBJECT_METADATA SET [DEC_TERM_ID] = @MY_TERM_ID, CHANGED_WHO = @WHO WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID
SELECT @OMD_ID = GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND DEC_TERM_ID = @MY_TERM_ID
END
ELSE IF @TYP_ID = 5 --DATE
BEGIN
IF NOT EXISTS(SELECT GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID)
BEGIN
INSERT INTO [dbo].[TBIDB_OBJECT_METADATA]
([IDB_OBJ_ID]
,[ATTR_ID]
,[DATE_TERM_ID]
,[ADDED_WHO])
VALUES
(@IDB_OBJ_ID
,@ATTR_ID
,@MY_TERM_ID
,@WHO)
END
ELSE
UPDATE TBIDB_OBJECT_METADATA SET [DATE_TERM_ID] = @MY_TERM_ID, CHANGED_WHO = @WHO WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID;
SELECT @OMD_ID = GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND DATE_TERM_ID = @MY_TERM_ID;
END
ELSE IF @TYP_ID = 6 --DATETIME
BEGIN
IF NOT EXISTS(SELECT GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID)
BEGIN
INSERT INTO [dbo].[TBIDB_OBJECT_METADATA]
([IDB_OBJ_ID]
,[ATTR_ID]
,[DATETIME_TERM_ID]
,[ADDED_WHO])
VALUES
(@IDB_OBJ_ID
,@ATTR_ID
,@MY_TERM_ID
,@WHO);
END
ELSE
UPDATE TBIDB_OBJECT_METADATA SET [DATETIME_TERM_ID] = @MY_TERM_ID, CHANGED_WHO = @WHO WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID;
EXEC PRIDB_OBJECT_CHANGED_SUBSTRUCTURE @IDB_OBJ_ID,@WHO;
SELECT @OMD_ID = GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND DATE_TERM_ID = @MY_TERM_ID;
END
--PRINT 'PRIDB_NEW_OBJ_DATA - Got the new @OMD_ID: ' + CONVERT(VARCHAR(20),@OMD_ID)
END
GO
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_CREATE_VIEW_DOC_DATA] @pLANGCODE VARCHAR(5) ,@pVar VARCHAR(15) = 'DEFAULT'
AS
DECLARE
@ATTR_ID INT,
@TITLE VARCHAR(100),
@TYPID INT,
@SQL1 NVARCHAR(MAX),
@Date Varchar(20),
@Bool4 Varchar(1),
@Integer24 Varchar(20),
@Float Varchar(20),
@RELPATH Varchar(200),
@SEQUENCE Integer,
@NAME_VIEW VARCHAR(20)
IF @pVar = 'DEFAULT'
SET @NAME_VIEW = 'VWIDB_DOC_DATA_'
ELSE
SET @NAME_VIEW = 'VWIDB_DOCRESULT_'
SET @SQL1 = 'CREATE VIEW ' + @NAME_VIEW + UPPER(LEFT(@pLANGCODE,2)) + ' AS '+ char(10) + 'SELECT ' + char(10) + char(9)
IF @pVar = 'DEFAULT'
SET @SQL1 += +'T.IDB_OBJ_ID' + char(10)
ELSE
SET @SQL1 += +'T.IDB_OBJ_ID as DocID' + char(10)
SET @SQL1 += char(9) + ',DT.Doctype as Doctype' + char(10)
BEGIN
DECLARE c_PRIDB_CREATE_VIEW_DOC_DATA CURSOR FOR
SELECT DISTINCT ATTR_ID,ATTR_TITLE,TYPE_ID,VIEW_SEQUENCE
FROM VWIDB_BE_ATTRIBUTE WHERE VIEW_VISIBLE = 1 AND LANG_CODE = @pLANGCODE AND ATTR_ID IS NOT NULL
ORDER BY VIEW_SEQUENCE
OPEN c_PRIDB_CREATE_VIEW_DOC_DATA
FETCH NEXT FROM c_PRIDB_CREATE_VIEW_DOC_DATA INTO @ATTR_ID,@TITLE,@TYPID,@SEQUENCE
WHILE @@FETCH_STATUS = 0
BEGIN
DECLARE @FN_COMMAND as VARCHAR(100), @FN_TYP as VARCHAR(50)
IF @TYPID IN (1,8)
BEGIN
SET @FN_COMMAND = '(SELECT [dbo].[FNIDB_GET_TERM_@TYPE] (@OBJ_ID,@ATTR_ID,''@LANG_CODE''))'
SET @FN_COMMAND = REPLACE(@FN_COMMAND,'@LANG_CODE',@pLANGCODE)
END
ELSE
SET @FN_COMMAND = '(SELECT [dbo].[FNIDB_GET_TERM_@TYPE] (@OBJ_ID,@ATTR_ID))'
SET @FN_COMMAND = REPLACE(@FN_COMMAND,'@OBJ_ID','T.IDB_OBJ_ID')
SET @FN_COMMAND = REPLACE(@FN_COMMAND,'@ATTR_ID',@ATTR_ID)
IF @TYPID = 1
SET @FN_TYP = 'TEXT'
ELSE IF @TYPID = 2
SET @FN_TYP = 'INTEGER'
ELSE IF @TYPID = 3
SET @FN_TYP = 'FLOAT'
ELSE IF @TYPID = 4
SET @FN_TYP = 'DECIMAL'
ELSE IF @TYPID = 5
SET @FN_TYP = 'DATE'
ELSE IF @TYPID = 6
SET @FN_TYP = 'DATE_TIME'
ELSE IF @TYPID = 7
SET @FN_TYP = 'BIT'
ELSE IF @TYPID = 8
SET @FN_TYP = 'TEXT_VECTOR'
ELSE IF @TYPID = 8
SET @FN_TYP = 'INTEGER_VECTOR'
SET @FN_COMMAND = REPLACE(@FN_COMMAND,'@TYPE',@FN_TYP)
--PRINT '@FN_COMMAND: ' + @FN_COMMAND
SET @SQL1 += char(9) + ',' + @FN_COMMAND + char(9) + char(9) + ' AS ''' + @TITLE + '''' + char(10)
--PRINT @SQL1
FETCH NEXT FROM c_PRIDB_CREATE_VIEW_DOC_DATA INTO @ATTR_ID,@TITLE,@TYPID,@SEQUENCE
END
CLOSE c_PRIDB_CREATE_VIEW_DOC_DATA
DEALLOCATE c_PRIDB_CREATE_VIEW_DOC_DATA
IF @pVar = 'DEFAULT'
BEGIN
SET @SQL1 += char(9) + ',T5.TERM_VALUE AS DocExtension' + char(10)
+ char(9) + ',T5.TERM_VALUE AS DocName' + char(10)
+ char(9) + ',CONCAT(T4.TERM_VALUE,''\'',T5.TERM_VALUE) AS DocRelativePath' + char(10)
+ char(9) + ',T4.TERM_VALUE AS DocRelativePathOnly' + char(10)
END
SET @SQL1 += char(9) + ',T.ADDED_WHEN AS [Added when]' + char(10)
+ char(9) + ',T.ADDED_WHO AS [Added who]' + char(10)
+ char(9) + ',T.CHANGED_WHEN_SUBSTRUCTURE AS [Changed when]' + char(10)
+ char(9) + ',T.CHANGED_WHO_SUBSTRUCTURE AS [Changed who]' + char(10)
SET @SQL1 += 'FROM' + char(10)
IF @pVar = 'DEFAULT'
SET @SQL1 += char(9)+'TBIDB_OBJECT T INNER JOIN TBIDB_FILE_OBJECT T2 ON T.IDB_OBJ_ID = T2.IDB_OBJ_ID' + char(10)
+ char(9) + 'INNER JOIN VWIDB_DOC_DOCTYPE DT ON T.IDB_OBJ_ID = DT.IDB_OBJ_ID' + char(10)
+ char(9) + 'INNER JOIN TBIDB_OBJECT_STORE T3 ON T2.OBJ_ST_ID = T3.GUID' + char(10)
+ char(9) + 'INNER JOIN TBIDB_TERM_VALUE_VARCHAR T4 ON T2.RELPATH_TERM_ID = T4.GUID' + char(10)
+ char(9) + 'INNER JOIN TBIDB_TERM_VALUE_VARCHAR T5 ON T2.FILENAME_TERM_ID = T5.GUID' + char(10)
ELSE
SET @SQL1 += char(9) + 'TBIDB_OBJECT T ' + char(10)
+ char(9) + 'INNER JOIN VWIDB_DOC_DOCTYPE DT ON T.IDB_OBJ_ID = DT.IDB_OBJ_ID' + char(10)
SET @SQL1 += 'WHERE' + char(10)
+ char(9) + 'DT.LANG_CODE = ''' + @pLANGCODE + ''' AND' + char(10)
+ char(9) + 'T.KIND_TYPE_ID = 1 AND T.DELETED = 0 AND T.ACTIVE = 1'
PRINT @SQL1
IF EXISTS (SELECT * FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = @NAME_VIEW + UPPER(LEFT(@pLANGCODE,2)))
BEGIN
DECLARE @DELETE NVARCHAR(100)
SET @DELETE = 'DROP VIEW [dbo].[' + @NAME_VIEW + UPPER(LEFT(@pLANGCODE,2)) + ']'
EXEC sp_executesql @DELETE
END
EXEC sp_executesql @SQL1
END
GO
--EXEC PRIDB_CREATE_VIEW_DOC_DATA 'de-DE','DEFAULT'
--GO
--EXEC PRIDB_CREATE_VIEW_DOC_DATA 'de-DE',''
--GO
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_DELETE_TERM_OBJECT_METADATA] @IDB_OBJ_ID BIGINT, @ATTRIBUTE VARCHAR(100), @TERM VARCHAR(900), @WHO VARCHAR(100),@LANG_CODE VARCHAR(5) = 'de-DE',@ID_ISFOREIGN as BIT = False
AS
BEGIN
DECLARE
@ATTR_ID INTEGER,
@TYP_ID TINYINT,
@TYP_DESCR VARCHAR(100),
@MULTI BIT,
@LANG_ID INT
--IF @ID_ISFOREIGN = 1
-- BEGIN
-- SELECT @IDB_OBJ_ID = IDB_OBJ_ID FROM TBIDB_OBJECT WHERE REFERENCE_KEY = @IDB_OBJ_ID
-- END
SELECT @ATTR_ID = T.GUID, @TYP_ID = T.TYP_ID, @MULTI = T.MULTI_CONTEXT,@TYP_DESCR = T1.NAME_TYPE FROM TBIDB_ATTRIBUTE T, TBIDB_ATTRIBUTE_TYPE T1
WHERE T.TYP_ID = T1.GUID AND UPPER(T.TITLE) = UPPER(@ATTRIBUTE)
SELECT @LANG_ID = GUID FROM TBIDB_LANGUAGE WHERE LANG_CODE = @LANG_CODE
DECLARE @MY_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM @TYP_DESCR,@TERM,'',@TERM_ID = @MY_TERM_ID OUTPUT;
PRINT '@MY_TERM_ID: ' + CONVERT(VARCHAR(10),@MY_TERM_ID)
IF @TYP_ID IN (1,8) --VARCHAR
BEGIN
PRINT 'Attribute is varchar...'
IF EXISTS(SELECT GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID)
BEGIN
DELETE FROM TBIDB_LANGUAGE_TERM WHERE [OBJECT_ID] = (SELECT GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID);
DELETE FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID;
PRINT 'PRIDB_DEL_TERM_OBJECT_METADATA: DELETED TEXT ROW!'
INSERT INTO TBIDB_OBJECT_METADATA_DELETE (IDB_OBJ_ID,ATTR_ID,TEXT_TERM_ID,DELETED_WHO, ADDED_WHO,ADDED_WHEN)
SELECT @IDB_OBJ_ID,@ATTR_ID, @MY_TERM_ID,@WHO,ADDED_WHO,ADDED_WHEN FROM TBIDB_OBJECT_METADATA
WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID;
END
ELSE
PRINT 'TERM SEEMS NOT TO EXIST'
END
ELSE IF @TYP_ID IN (2,7,9) --BIGINT
BEGIN
IF EXISTS(SELECT GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND INT_TERM_ID = @MY_TERM_ID)
BEGIN
DELETE FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND INT_TERM_ID = @MY_TERM_ID
PRINT 'PRIDB_DEL_TERM_OBJECT_METADATA: DELETED INTEGER ROW!'
INSERT INTO TBIDB_OBJECT_METADATA_DELETE (IDB_OBJ_ID,ATTR_ID,INT_TERM_ID,DELETED_WHO, ADDED_WHO,ADDED_WHEN)
SELECT @IDB_OBJ_ID,@ATTR_ID, @MY_TERM_ID,@WHO,ADDED_WHO,ADDED_WHEN FROM TBIDB_OBJECT_METADATA
WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND INT_TERM_ID = @MY_TERM_ID
END
END
ELSE IF @TYP_ID = 3 --FLOAT
BEGIN
IF EXISTS(SELECT GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND FLOAT_TERM_ID = @MY_TERM_ID)
BEGIN
DELETE FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND FLOAT_TERM_ID = @MY_TERM_ID
PRINT 'PRIDB_DEL_TERM_OBJECT_METADATA: DELETED FLOAT ROW!'
INSERT INTO TBIDB_OBJECT_METADATA_DELETE (IDB_OBJ_ID,ATTR_ID,FLOAT_TERM_ID,DELETED_WHO, ADDED_WHO,ADDED_WHEN)
SELECT @IDB_OBJ_ID,@ATTR_ID, @MY_TERM_ID,@WHO,ADDED_WHO,ADDED_WHEN FROM TBIDB_OBJECT_METADATA
WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND FLOAT_TERM_ID = @MY_TERM_ID
END
END
ELSE IF @TYP_ID = 4 --DECIMAL
BEGIN
IF EXISTS(SELECT GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND DEC_TERM_ID = @MY_TERM_ID)
BEGIN
DELETE FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND DEC_TERM_ID = @MY_TERM_ID
PRINT 'PRIDB_DEL_TERM_OBJECT_METADATA: DELETED DECIMAL ROW!'
INSERT INTO TBIDB_OBJECT_METADATA_DELETE (IDB_OBJ_ID,ATTR_ID,DEC_TERM_ID,DELETED_WHO, ADDED_WHO,ADDED_WHEN)
SELECT @IDB_OBJ_ID,@ATTR_ID, @MY_TERM_ID,@WHO,ADDED_WHO,ADDED_WHEN FROM TBIDB_OBJECT_METADATA
WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND DEC_TERM_ID = @MY_TERM_ID
END
END
ELSE IF @TYP_ID = 5 --DATE
BEGIN
IF EXISTS(SELECT GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND DATE_TERM_ID = @MY_TERM_ID)
BEGIN
DELETE FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND DATE_TERM_ID = @MY_TERM_ID
PRINT 'PRIDB_DEL_TERM_OBJECT_METADATA: DELETED DATE ROW!'
INSERT INTO TBIDB_OBJECT_METADATA_DELETE (IDB_OBJ_ID,ATTR_ID,DATE_TERM_ID,DELETED_WHO, ADDED_WHO,ADDED_WHEN)
SELECT @IDB_OBJ_ID,@ATTR_ID, @MY_TERM_ID,@WHO,ADDED_WHO,ADDED_WHEN FROM TBIDB_OBJECT_METADATA
WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID AND DATE_TERM_ID = @MY_TERM_ID
END
END
END
GO
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_DELETE_ATTRIBUTE] @ATTR_ID INTEGER, @WHO VARCHAR(100)
AS
BEGIN
DECLARE
@ATTR_TYP_ID TINYINT,
@ATTRIBUTE VARCHAR(100),
@IDB_OBJ_ID BIGINT,
@TYP_DESCR VARCHAR(100),
@MULTI BIT,
@TERM_ID BIGINT,
@USER_DELETE_ID INTEGER,
@ERROR as BIT
SET @ERROR = 0
SELECT @USER_DELETE_ID = GUID FROM DD_ECM.dbo.TBDD_USER WHERE USERNAME = @WHO
SELECT @ATTR_TYP_ID = T.TYP_ID, @ATTRIBUTE = TITLE FROM TBIDB_ATTRIBUTE T WHERE GUID = @ATTR_ID;
IF @ATTR_TYP_ID IN (1,8) --VARCHAR
BEGIN TRY
DECLARE @OMD_ID BIGINT
DECLARE cursor_DeleteLog CURSOR LOCAL FOR
SELECT MD.IDB_OBJ_ID, MD.GUID,TT.TERM_ID FROM TBIDB_OBJECT_METADATA MD INNER JOIN TBIDB_LANGUAGE_TERM TT ON MD.GUID = TT.[OBJECT_ID]
WHERE MD.ATTR_ID = @ATTR_ID
OPEN cursor_DeleteLog
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@OMD_ID,@TERM_ID
WHILE @@FETCH_STATUS = 0
BEGIN
INSERT INTO TBIDB_OBJECT_METADATA_DELETE (IDB_OBJ_ID,ATTR_ID,TEXT_TERM_ID,DELETED_WHO,USER_DELETE_ID)
VALUES (@IDB_OBJ_ID,@ATTR_ID, @TERM_ID, @WHO,@USER_DELETE_ID);
DELETE FROM TBIDB_LANGUAGE_TERM WHERE [OBJECT_ID] = @OMD_ID;
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@OMD_ID,@TERM_ID
END
CLOSE cursor_DeleteLog
DEALLOCATE cursor_DeleteLog
DELETE
FROM TBIDB_OBJECT_METADATA
WHERE ATTR_ID = @ATTR_ID;
END TRY
BEGIN CATCH
PRINT 'ERROR WHILE DELETING FROM TBIDB_OBJECT_METADATA FOR ATTRIBUTE [' + @ATTRIBUTE + ']'
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
DELETE FROM TBIDB_OBJECT_METADATA_DELETE WHERE USER_DELETE_ID = @USER_DELETE_ID
SET @ERROR = 1
END CATCH
ELSE IF @ATTR_TYP_ID IN (2,7,9) --BIGINT
BEGIN TRY
DECLARE cursor_DeleteLog CURSOR LOCAL FOR
SELECT T.IDB_OBJ_ID,T.INT_TERM_ID FROM TBIDB_OBJECT_METADATA T WHERE T.ATTR_ID = @ATTR_ID
OPEN cursor_DeleteLog
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@TERM_ID
WHILE @@FETCH_STATUS = 0
BEGIN
INSERT INTO TBIDB_OBJECT_METADATA_DELETE (IDB_OBJ_ID,ATTR_ID,INT_TERM_ID,DELETED_WHO,USER_DELETE_ID)
VALUES (@IDB_OBJ_ID,@ATTR_ID, @TERM_ID, @WHO,@USER_DELETE_ID)
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@TERM_ID
END
CLOSE cursor_DeleteLog
DEALLOCATE cursor_DeleteLog
DELETE T
FROM TBIDB_OBJECT_METADATA T
WHERE T.ATTR_ID = @ATTR_ID
END TRY
BEGIN CATCH
PRINT 'ERROR WHILE DELETING (INTEGER) FROM TBIDB_OBJECT_METADATA FOR ATTRIBUTE [' + @ATTRIBUTE + ']'
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
DELETE FROM TBIDB_OBJECT_METADATA_DELETE WHERE USER_DELETE_ID = @USER_DELETE_ID
SET @ERROR = 1
END CATCH
ELSE IF @ATTR_TYP_ID = 3 --FLOAT
BEGIN TRY
DECLARE cursor_DeleteLog CURSOR LOCAL FOR
SELECT T.IDB_OBJ_ID,T.FLOAT_TERM_ID FROM TBIDB_OBJECT_METADATA T WHERE T.ATTR_ID = @ATTR_ID
OPEN cursor_DeleteLog
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@TERM_ID
WHILE @@FETCH_STATUS = 0
BEGIN
INSERT INTO TBIDB_OBJECT_METADATA_DELETE (IDB_OBJ_ID,ATTR_ID,FLOAT_TERM_ID,DELETED_WHO,USER_DELETE_ID)
VALUES (@IDB_OBJ_ID,@ATTR_ID, @TERM_ID, @WHO,@USER_DELETE_ID)
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@TERM_ID
END
CLOSE cursor_DeleteLog
DEALLOCATE cursor_DeleteLog
DELETE T
FROM TBIDB_OBJECT_METADATA T
WHERE T.ATTR_ID = @ATTR_ID
END TRY
BEGIN CATCH
PRINT 'ERROR WHILE DELETING (FLOAT) FROM TBIDB_OBJECT_METADATA FOR ATTRIBUTE [' + @ATTRIBUTE + ']'
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
DELETE FROM TBIDB_OBJECT_METADATA_DELETE WHERE USER_DELETE_ID = @USER_DELETE_ID
SET @ERROR = 1
END CATCH
ELSE IF @ATTR_TYP_ID = 4 --DECIMAL
BEGIN TRY
DECLARE cursor_DeleteLog CURSOR LOCAL FOR
SELECT T.IDB_OBJ_ID,T.DEC_TERM_ID FROM TBIDB_OBJECT_METADATA T WHERE T.ATTR_ID = @ATTR_ID
OPEN cursor_DeleteLog
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@TERM_ID
WHILE @@FETCH_STATUS = 0
BEGIN
INSERT INTO TBIDB_OBJECT_METADATA_DELETE (IDB_OBJ_ID,ATTR_ID,DEC_TERM_ID,DELETED_WHO,USER_DELETE_ID)
VALUES (@IDB_OBJ_ID,@ATTR_ID, @TERM_ID, @WHO,@USER_DELETE_ID)
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@TERM_ID
END
CLOSE cursor_DeleteLog
DEALLOCATE cursor_DeleteLog
DELETE T
FROM TBIDB_OBJECT_METADATA T
WHERE T.ATTR_ID = @ATTR_ID
END TRY
BEGIN CATCH
PRINT 'ERROR WHILE DELETING (DECIMAL) FROM TBIDB_OBJECT_METADATA FOR ATTRIBUTE [' + @ATTRIBUTE + ']'
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
DELETE FROM TBIDB_OBJECT_METADATA_DELETE WHERE USER_DELETE_ID = @USER_DELETE_ID
SET @ERROR = 1
END CATCH
ELSE IF @ATTR_TYP_ID = 5 --DATE
BEGIN TRY
DECLARE cursor_DeleteLog CURSOR LOCAL FOR
SELECT T.IDB_OBJ_ID,T.DATE_TERM_ID FROM TBIDB_OBJECT_METADATA T WHERE T.ATTR_ID = @ATTR_ID
OPEN cursor_DeleteLog
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@TERM_ID
WHILE @@FETCH_STATUS = 0
BEGIN
INSERT INTO TBIDB_OBJECT_METADATA_DELETE (IDB_OBJ_ID,ATTR_ID,DATE_TERM_ID,DELETED_WHO,USER_DELETE_ID)
VALUES (@IDB_OBJ_ID,@ATTR_ID, @TERM_ID, @WHO,@USER_DELETE_ID)
FETCH NEXT FROM cursor_DeleteLog INTO @IDB_OBJ_ID,@TERM_ID
END
CLOSE cursor_DeleteLog
DEALLOCATE cursor_DeleteLog
DELETE T
FROM TBIDB_OBJECT_METADATA T
WHERE T.ATTR_ID = @ATTR_ID
END TRY
BEGIN CATCH
PRINT 'ERROR WHILE DELETING (DATE) FROM TBIDB_OBJECT_METADATA FOR ATTRIBUTE [' + @ATTRIBUTE + ']'
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
DELETE FROM TBIDB_OBJECT_METADATA_DELETE WHERE USER_DELETE_ID = @USER_DELETE_ID
SET @ERROR = 1
END CATCH
IF @ERROR = 0
BEGIN
UPDATE TBIDB_ATTRIBUTE SET DELETED = 1, DELETED_WHO = @WHO WHERE GUID = @ATTR_ID;
END
END
GO
--delete from TBIDB_CONVERSATION_OBJECT
CREATE PROCEDURE [dbo].[PRIDB_NEW_CONVERSATION] @pIDB_OBJ_ID BIGINT, @pTITLE VARCHAR(512),@pWHO VARCHAR(100),@pLANG_CODE VARCHAR(5) = 'de-DE'
AS
BEGIN
DECLARE
@LANG_ID INTEGER
SELECT @LANG_ID = GUID FROM TBIDB_LANGUAGE WHERE LANG_CODE = @pLANG_CODE
DECLARE @TITLE_TERM_ID BIGINT,@LANG_TITLE_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@pTITLE,@pWHO,@TERM_ID = @TITLE_TERM_ID OUTPUT;
DECLARE @ADDED_WHO_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@pWHO,@pWHO,@TERM_ID = @ADDED_WHO_TERM_ID OUTPUT;
IF NOT EXISTS(SELECT GUID FROM TBIDB_CONVERSATION_OBJECT WHERE IDB_OBJ_ID = @pIDB_OBJ_ID AND TITLE_TERM_ID = @LANG_TITLE_TERM_ID)
INSERT INTO TBIDB_CONVERSATION_OBJECT (TITLE_TERM_ID,IDB_OBJ_ID,ADDED_WHO) VALUES (@LANG_TITLE_TERM_ID,@pIDB_OBJ_ID,@ADDED_WHO_TERM_ID)
DECLARE @STARTED_STATE BIGINT
SELECT @STARTED_STATE = GUID FROM TBIDB_STATES T WHERE dbo.[FNIDB_GET_TERM_FOR_LANG_TERM_ID] (T.TITLE,'de-DE') = 'Started'
DECLARE @CONVERSATION_ID BIGINT
SELECT @CONVERSATION_ID = GUID FROM TBIDB_CONVERSATION_OBJECT WHERE TITLE_TERM_ID = @LANG_TITLE_TERM_ID AND IDB_OBJ_ID = @pIDB_OBJ_ID
IF NOT EXISTS(SELECT GUID FROM TBIDB_MYOBJECT_STATES WHERE MY_OBJECT_ID = @CONVERSATION_ID AND STATE_ID = @STARTED_STATE)
INSERT INTO TBIDB_MYOBJECT_STATES (MY_OBJECT_ID,STATE_ID,ADDED_WHO) VALUES (@CONVERSATION_ID,@STARTED_STATE,@ADDED_WHO_TERM_ID)
END
GO
CREATE OR ALTER PROCEDURE dbo.PRIDB_OBJECT_SET_STATE @pOBJECT_ID BIGINT, @pSTATE VARCHAR(512),@pWHO VARCHAR(100)
AS
BEGIN
DECLARE
@STATE_ID INTEGER
SELECT @STATE_ID = GUID FROM TBIDB_STATES WHERE TITLE = @pSTATE
DECLARE @ADDED_WHO_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@pWHO,@pWHO,@TERM_ID = @ADDED_WHO_TERM_ID OUTPUT;
IF NOT EXISTS(SELECT GUID FROM TBIDB_MYOBJECT_STATES WHERE MY_OBJECT_ID = @pOBJECT_ID AND STATE_ID = @STATE_ID AND DATEDIFF(SECOND,ADDED_WHEN,GETDATE()) <= 1)
INSERT INTO TBIDB_MYOBJECT_STATES (MY_OBJECT_ID,STATE_ID,ADDED_WHO) VALUES (@pOBJECT_ID,@STATE_ID,@ADDED_WHO_TERM_ID)
--ELSE
-- PRINT 'ALREADY WRITTEN IN THIS SECOND'
END
GO
CREATE PROCEDURE [dbo].[PRIDB_END_CONVERSATION] @pCONVID BIGINT, @pWHO VARCHAR(100), @pLANG_CODE VARCHAR(5) = 'de-DE'
AS
BEGIN
DECLARE
@LANG_ID INTEGER
,@ENDED_STATE BIGINT
SELECT @LANG_ID = GUID FROM TBIDB_LANGUAGE WHERE LANG_CODE = @pLANG_CODE
SELECT @ENDED_STATE = GUID FROM TBIDB_STATES T WHERE dbo.[FNIDB_GET_TERM_FOR_LANG_TERM_ID] (T.TITLE,'de-DE') = 'Ended'
DECLARE @WHO_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@pWHO,@pWHO,@TERM_ID = @WHO_TERM_ID OUTPUT;
IF NOT EXISTS(SELECT MY_OBJECT_ID FROM TBIDB_MYOBJECT_STATES WHERE MY_OBJECT_ID = @pCONVID AND STATE_ID = @ENDED_STATE)
INSERT INTO TBIDB_MYOBJECT_STATES (
MY_OBJECT_ID
,STATE_ID
,ADDED_WHO) VALUES (
@pCONVID
,@ENDED_STATE
,@WHO_TERM_ID)
END
GO
CREATE PROCEDURE [dbo].[PRIDB_ADD_USER_2_CONVERSATION] @pCONV_ID BIGINT, @pUSERID INTEGER,@pWHO VARCHAR(100)
AS
BEGIN
DECLARE @ADDED_WHO_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@pWHO,@pWHO,@TERM_ID = @ADDED_WHO_TERM_ID OUTPUT;
IF NOT EXISTS(SELECT GUID FROM TBIDB_CONVERSATION_USER WHERE CONV_ID = @pCONV_ID AND USER_OR_GROUP_ID = @pUSERID AND IS_USER = 1)
INSERT INTO TBIDB_CONVERSATION_USER (CONV_ID,USER_OR_GROUP_ID,IS_USER,ADDED_WHO) VALUES (@pCONV_ID,@pUSERID,1,@ADDED_WHO_TERM_ID)
END
GO
CREATE PROCEDURE [dbo].[PRIDB_NEW_CONVERSATION_MESSAGE] @pCONV_ID BIGINT, @pMESSAGE VARCHAR(100), @pWHO VARCHAR(100),@pTO_USER INTEGER = 0, @pLANG_CODE VARCHAR(5) = 'de-DE'
AS
BEGIN
DECLARE
@LANG_ID INTEGER
SELECT @LANG_ID = GUID FROM TBIDB_LANGUAGE WHERE LANG_CODE = @pLANG_CODE
DECLARE @MESSAGE_TERM_ID BIGINT,@LANG_MESSAGE_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@pMESSAGE,@pWHO,@TERM_ID = @MESSAGE_TERM_ID OUTPUT;
DECLARE @ADDED_WHO_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@pWHO,@pWHO,@TERM_ID = @ADDED_WHO_TERM_ID OUTPUT;
IF NOT EXISTS(SELECT GUID FROM TBIDB_TERM_LANGUAGE WHERE LANGUAGE_ID = @LANG_ID AND TEXT_TERM_ID = @MESSAGE_TERM_ID)
INSERT INTO TBIDB_TERM_LANGUAGE (LANGUAGE_ID,TEXT_TERM_ID,ADDED_WHO) VALUES (@LANG_ID,@MESSAGE_TERM_ID,@pWHO)
SELECT @LANG_MESSAGE_TERM_ID = MAX(GUID) FROM TBIDB_TERM_LANGUAGE WHERE LANGUAGE_ID = @LANG_ID AND TEXT_TERM_ID = @MESSAGE_TERM_ID
--IF NOT EXISTS(SELECT GUID FROM TBIDB_CONVERSATION_MESSAGE WHERE CONV_ID = @pCONV_ID AND FROM_USER = FROM_USER AND MESSAGE_TERM_ID = @LANG_MESSAGE_TERM_ID)
INSERT INTO TBIDB_CONVERSATION_MESSAGE (CONV_ID,FROM_USER,TO_USER, MESSAGE_TERM_ID, ADDED_WHO) VALUES (@pCONV_ID,@ADDED_WHO_TERM_ID,@pTO_USER, @LANG_MESSAGE_TERM_ID,@ADDED_WHO_TERM_ID)
END
GO
CREATE PROCEDURE PRIDB_GET_VALUE_TYPE @pVALUE VARCHAR(900)--,@oType VARCHAR(10) OUTPUT
AS
BEGIN
declare @TBTYPE_RESULT table(pTYPE varchar(10))
DECLARE @oTYPE as Varchar(10)
SET @oType = 'NONE'
DECLARE @BIGINT as BIGINT, @FLOAT FLOAT,@DECIMAL DECIMAL(19,2),@DATE DATE
BEGIN TRY
SET @BIGINT = CONVERT(bigint,@pVALUE)
SET @oType = 'BIGINT'
INSERT INTO @TBTYPE_RESULT (pTYPE) VALUES (@oType)
END TRY
BEGIN CATCH
PRINT 'NO BIGINT'
END CATCH
--IF @oType = 'NONE'
BEGIN TRY
SET @FLOAT = CONVERT(FLOAT,@pVALUE)
SET @oType = 'FLOAT'
INSERT INTO @TBTYPE_RESULT (pTYPE) VALUES (@oType)
END TRY
BEGIN CATCH
PRINT 'NO FLOAT'
END CATCH
--IF @oType = 'NONE'
BEGIN TRY
SET @DECIMAL = CONVERT(DECIMAL(19,2),@pVALUE)
SET @oType = 'DECIMAL'
INSERT INTO @TBTYPE_RESULT (pTYPE) VALUES (@oType)
END TRY
BEGIN CATCH
PRINT 'NO DECIMAL'
END CATCH
--IF @oType = 'NONE'
BEGIN TRY
SET @DATE = CONVERT(DATE,@pVALUE)
SET @oType = 'DATE'
INSERT INTO @TBTYPE_RESULT (pTYPE) VALUES (@oType)
END TRY
BEGIN CATCH
PRINT 'NO DATE'
END CATCH
--IF @oType = 'NONE'
BEGIN TRY
SET @oType = 'VARCHAR'
INSERT INTO @TBTYPE_RESULT (pTYPE) VALUES (@oType)
END TRY
BEGIN CATCH
PRINT 'NO VARCHAR'
END CATCH
PRINT '@TYPE: ' + @oType
SELECT * FROM @TBTYPE_RESULT
END
GO
CREATE PROCEDURE [dbo].[PRIDB_NEW_SEARCH_RESULT_ATTRIBUTE] @pSEARCHID INTEGER,@pATTRIBUTE_ID INTEGER,@pWHO_TERM_ID BIGINT,@pSequence INTEGER = 0
AS
BEGIN
IF @pSequence = 0
SELECT @pSEQUENCE = COALESCE(MAX([SEQUENCE]),0) + 1 FROM TBIDB_SEARCH_RESULT_ATTRIBUTES
WHERE SEARCH_PROFIL_ID = @pSEARCHID
IF NOT EXISTS(SELECT GUID FROM TBIDB_SEARCH_RESULT_ATTRIBUTES WHERE ATTRIBUTE_ID = @pATTRIBUTE_ID AND SEARCH_PROFIL_ID = @pSEARCHID)
BEGIN
INSERT INTO TBIDB_SEARCH_RESULT_ATTRIBUTES (SEARCH_PROFIL_ID,ATTRIBUTE_ID,SEQUENCE,ADDED_WHO) VALUES (@pSEARCHID,@pATTRIBUTE_ID,@pSequence, @pWHO_TERM_ID)
EXEC [dbo].[PRIDB_NEW_SEARCH_ATTRIBUTE] @pSEARCHID,@pATTRIBUTE_ID,@pWHO_TERM_ID,0
END
ELSE
UPDATE TBIDB_SEARCH_RESULT_ATTRIBUTES SET SEQUENCE = @pSequence
WHERE ATTRIBUTE_ID = @pATTRIBUTE_ID AND SEARCH_PROFIL_ID = @pSEARCHID
--SELECT
-- T.GUID,
-- T.ATTRIBUTE_ID,
-- T1.TITLE
-- ,[dbo].[FNIDB_GET_TERM_FOR_TERM_ID] (T.ADDED_WHO) AS ADDED_WHO
-- ,T.ADDED_WHEN
--FROM TBIDB_SEARCH_RESULT_ATTRIBUTES T INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTRIBUTE_ID = T1.GUID
--WHERE SEARCH_PROFIL_ID = @pSEARCHID
END
GO
CREATE PROCEDURE [dbo].[PRIDB_NEW_SEARCH_PROFILE] @BE_ID INT, @pTITLE VARCHAR(512),@pWHO VARCHAR(100),@pCOMMENT VARCHAR(900) = NULL, @pLANG_CODE VARCHAR(5) = 'de-DE'
AS
BEGIN
DECLARE
@LANG_ID INTEGER, @SQL_RESULT VARCHAR(912),
@SEARCH_ID INTEGER,
@WHO_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@pWHO,@pWHO,@TERM_ID = @WHO_TERM_ID OUTPUT;
SELECT @LANG_ID = GUID FROM TBIDB_LANGUAGE WHERE LANG_CODE = @pLANG_CODE
DECLARE @MY_TITLE_TERM_ID BIGINT,@MY_LANG_TERM_ID BIGINT,@MY_RESULT_SQL_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@pTITLE,@pWHO,@TERM_ID = @MY_TITLE_TERM_ID OUTPUT;
IF NOT EXISTS(SELECT GUID FROM TBIDB_SEARCH_PROFILE WHERE COMMENT = @pCOMMENT)
INSERT INTO TBIDB_SEARCH_PROFILE (ADDED_WHO,COMMENT) VALUES (@WHO_TERM_ID,@pCOMMENT)
SELECT @SEARCH_ID = MAX(GUID) FROM TBIDB_SEARCH_PROFILE T
WHERE COMMENT = @pCOMMENT
DECLARE @VIEW_LANG VARCHAR(50)
IF @pLANG_CODE = 'de-DE'
SET @VIEW_LANG = 'VWIDB_DOC_DATA_DE'
ELSE
SET @VIEW_LANG = 'VWIDB_DOC_DATA_EN'
SET @SQL_RESULT = 'SELECT T.IDB_OBJ_ID as DocID, [dbo].[FNIDB_GET_FILE_PATH] (T.IDB_OBJ_ID) as FULL_FILENAME, T.DocName as Filename, * FROM ' + @VIEW_LANG + ' WHERE '
DECLARE @ATTR_ID INT,@SEQUENCE TINYINT
SET @SEQUENCE = 0
DECLARE cursorDefaultAttributes CURSOR FOR
SELECT
T1.GUID
FROM TBIDB_ATTRIBUTE T1 INNER JOIN TBIDB_BE_ATTRIBUTE T2 ON T1.GUID = T2.ATTR_ID
WHERE T2.BE_ID = @BE_ID AND DEFAULT_SEARCH_ATTRIBUTE = 1
ORDER BY T1.VIEW_SEQUENCE
OPEN cursorDefaultAttributes
FETCH NEXT FROM cursorDefaultAttributes INTO @ATTR_ID
WHILE @@FETCH_STATUS = 0
BEGIN
IF NOT EXISTS (SELECT GUID FROM TBIDB_SEARCH_RESULT_ATTRIBUTES WHERE SEARCH_PROFIL_ID = @SEARCH_ID AND ATTRIBUTE_ID = @ATTR_ID)
EXEC PRIDB_NEW_SEARCH_RESULT_ATTRIBUTE @SEARCH_ID,@ATTR_ID,@WHO_TERM_ID,@SEQUENCE
SET @SEQUENCE += 1
FETCH NEXT FROM cursorDefaultAttributes INTO @ATTR_ID
END
CLOSE cursorDefaultAttributes
DEALLOCATE cursorDefaultAttributes
END
GO
--CREATE PROCEDURE [dbo].[PRIDB_NEW_SEARCH_SQL_RESULT] @SEARCH_ID INT,@pWHO_TERMID BIGINT
--AS
--BEGIN
-- DECLARE
-- @LANG_ID TINYINT,
-- @SQL_RESULT VARCHAR(912),
-- @WHO_TERM VARCHAR(100),
-- @MY_RESULT_SQL_TERM_ID BIGINT
-- SELECT @WHO_TERM = TERM_VALUE FROM TBIDB_TERM_VALUE_VARCHAR WHERE GUID = @pWHO_TERMID
-- DECLARE cursorLang CURSOR FOR
-- select GUID from TBIDB_LANGUAGE WHERE CREATE_DEFAULT_ENTRY = 1
-- OPEN cursorLang
-- FETCH NEXT FROM cursorLang INTO @LANG_ID
-- WHILE @@FETCH_STATUS = 0
-- BEGIN
-- SET @SQL_RESULT = 'SELECT T.IDB_OBJ_ID as DocID, [dbo].[FNIDB_GET_FILE_PATH] (T.IDB_OBJ_ID) as FULL_FILENAME, T.DocName as Filename'
-- DECLARE @ATTR_TITLE VARCHAR(100)
-- DECLARE cursorSRA CURSOR FOR
-- SELECT T3.TERM_VALUE
-- FROM TBIDB_SEARCH_RESULT_ATTRIBUTES T INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTRIBUTE_ID = T1.GUID
-- INNER JOIN TBIDB_ATTRIBUTE_LANGUAGE T2 ON T1.GUID = T2.ATTRIBUTE_ID
-- INNER JOIN TBIDB_TERM_VALUE_VARCHAR T3 ON T2.TERM_ID = T3.GUID
-- WHERE T.SEARCH_PROFIL_ID = @SEARCH_ID --@SEARCH_ID
-- AND T2.LANGUAGE_ID = @LANG_ID
-- ORDER BY T.SEQUENCE
-- OPEN cursorSRA
-- FETCH NEXT FROM cursorSRA INTO @ATTR_TITLE
-- WHILE @@FETCH_STATUS = 0
-- BEGIN
-- SET @SQL_RESULT += ', T.[' + @ATTR_TITLE + ']'
-- FETCH NEXT FROM cursorSRA INTO @ATTR_TITLE
-- END
-- CLOSE cursorSRA
-- DEALLOCATE cursorSRA
-- SET @SQL_RESULT += ' FROM VWIDB_DOC_DATA T INNER JOIN [dbo].[FNIDB_SEARCH_RESULT_GET_OBJECTS] (@UserID,@SearchID) T1 ON T.IDB_OBJ_ID = T1.IDB_OBJ_ID '
-- EXEC PRIDB_NEW_TERM 'VARCHAR',@SQL_RESULT,@WHO_TERM,@TERM_ID = @MY_RESULT_SQL_TERM_ID OUTPUT;
-- PRINT @SQL_RESULT
-- IF NOT EXISTS(SELECT GUID FROM TBIDB_SEARCH_LANGUAGE_SQL_RESULT WHERE SEARCH_PROFIL_ID = @SEARCH_ID AND LANGUAGE_ID = @LANG_ID)
-- INSERT INTO TBIDB_SEARCH_LANGUAGE_SQL_RESULT (SEARCH_PROFIL_ID,LANGUAGE_ID,SEARCH_TERM_ID,ADDED_WHO) VALUES
-- (@SEARCH_ID,@LANG_ID,@MY_RESULT_SQL_TERM_ID,@pWHO_TERMID)
-- ELSE
-- UPDATE TBIDB_SEARCH_LANGUAGE_SQL_RESULT SET SEARCH_TERM_ID = @MY_RESULT_SQL_TERM_ID,CHANGED_WHO = @pWHO_TERMID WHERE SEARCH_PROFIL_ID = @SEARCH_ID AND LANGUAGE_ID = @LANG_ID
-- FETCH NEXT FROM cursorLang INTO @LANG_ID
-- END
-- CLOSE cursorLang
-- DEALLOCATE cursorLang
--END
--GO
--CREATE PROCEDURE [dbo].[PRIDB_NEW_RELATION_SEARCH_USER] @pSEARCHID INTEGER,@pUSER_ID INTEGER,@pWHO_TERM_ID BIGINT
--AS
--BEGIN
-- IF NOT EXISTS(SELECT GUID FROM TBIDB_SEARCH_PROFILE_USER WHERE USER_ID = @pUSER_ID AND SEARCH_PROFIL_ID = @pSEARCHID)
-- INSERT INTO TBIDB_SEARCH_PROFILE_USER (USER_ID,ADDED_WHO,SEARCH_PROFIL_ID) VALUES (@pUSER_ID,@pWHO_TERM_ID,@pSEARCHID)
-- SELECT
-- GUID,USER_ID,SEARCH_PROFIL_ID
-- ,[dbo].[FNIDB_GET_TERM_FOR_TERM_ID] (ADDED_WHO) AS ADDED_WHO
-- ,ADDED_WHEN
-- FROM TBIDB_SEARCH_PROFILE_USER
-- WHERE SEARCH_PROFIL_ID = @pSEARCHID
--END
--GO
--CREATE PROCEDURE [dbo].[PRIDB_NEW_RELATION_SEARCH_GROUP] @pSEARCHID INTEGER,@pGROUP_ID INTEGER,@pWHO_TERM_ID BIGINT
--AS
--BEGIN
-- IF NOT EXISTS(SELECT GUID FROM TBIDB_SEARCH_PROFILE_GROUP WHERE GROUP_ID = @pGROUP_ID AND SEARCH_PROFIL_ID = @pSEARCHID)
-- INSERT INTO TBIDB_SEARCH_PROFILE_GROUP (GROUP_ID,ADDED_WHO,SEARCH_PROFIL_ID) VALUES (@pGROUP_ID,@pWHO_TERM_ID,@pSEARCHID)
-- SELECT
-- GUID,GROUP_ID,SEARCH_PROFIL_ID
-- ,[dbo].[FNIDB_GET_TERM_FOR_TERM_ID] (ADDED_WHO) AS ADDED_WHO
-- ,ADDED_WHEN
-- FROM TBIDB_SEARCH_PROFILE_GROUP
-- WHERE SEARCH_PROFIL_ID = @pSEARCHID
--END
--GO
CREATE PROCEDURE [dbo].[PRIDB_NEW_SEARCH_ATTRIBUTE] @pSEARCH_PROFIL_ID INTEGER,@pATTRIBUTE_ID INTEGER,@MULTISELECT BIT, @WHO_TERM_ID INTEGER, @pSEQUENCE INTEGER,@pHEIGHT SMALLINT = 0,@pWIDTH SMALLINT = 0
AS
BEGIN
DECLARE @pWHO_USERNAME VARCHAR(100),@USER_LANGUAGE VARCHAR(5),@USER_LANGUAGE_ID INT, @ATTRTYPE as VARCHAR(20)--,@USER_ID INTEGER
SELECT @pWHO_USERNAME = TERM_VALUE FROM TBIDB_TERM_VALUE_VARCHAR WHERE GUID = @WHO_TERM_ID
SELECT @USER_LANGUAGE = LANGUAGE,@USER_LANGUAGE_ID = T1.GUID FROM DD_ECM.dbo.TBDD_USER T INNER JOIN IDB.dbo.TBIDB_LANGUAGE T1 ON T.LANGUAGE = T1.LANG_CODE WHERE UPPER(USERNAME) = UPPER(@pWHO_USERNAME)
SELECT @ATTRTYPE = T1.NAME_TYPE FROM TBIDB_ATTRIBUTE T INNER JOIN TBIDB_ATTRIBUTE_TYPE T1 ON T.TYP_ID = T1.GUID WHERE T.GUID = @pATTRIBUTE_ID
IF @ATTRTYPE IN ('VARCHAR','BIG INTEGER')
BEGIN
IF @pHEIGHT = 0
SET @pHEIGHT = 200
IF @pWIDTH = 0
SET @pWIDTH = 200
END
ELSE IF @ATTRTYPE ='DATE'
BEGIN
IF @pHEIGHT = 0
SET @pHEIGHT = 20
IF @pWIDTH = 0
SET @pWIDTH = 100
END
ELSE IF @ATTRTYPE ='BIT'
BEGIN
IF @pHEIGHT = 0
SET @pHEIGHT = 20
IF @pWIDTH = 0
SET @pWIDTH = 200
END
DECLARE @SOURCE_TERM_ID BIGINT,@SOURCE_DEFAULT_SQL VARCHAR(900)
SET @SOURCE_DEFAULT_SQL = 'select DISTINCT TERM.TERM_VALUE AS @RESULT_TITLE
FROM
TBIDB_TERM_VALUE_VARCHAR TERM INNER JOIN TBIDB_TERM_LANGUAGE TLANG ON TERM.GUID = TLANG.TEXT_TERM_ID
INNER JOIN TBIDB_LANGUAGE_TERM_METADATA T1 ON TLANG.GUID = T1.LANG_TERM_ID
INNER JOIN TBIDB_OBJECT_METADATA MD ON T1.GUID = MD.TEXT_TERM_LANG_ID
INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE
MD.ATTR_ID = ' + CONVERT(VARCHAR(3),@pATTRIBUTE_ID) + ' AND TLANG.LANGUAGE_ID = ' + CONVERT(VARCHAR(3),@USER_LANGUAGE_ID) + '
AND OBJ.DELETED = 0 AND ACTIVE = 1'
--IF @pDEPENDING_ATTRIBUTE1 <> 0
-- SET @SOURCE_DEFAULT_SQL = REPLACE(@SOURCE_DEFAULT_SQL,'@pUSER_ID) ','@pUSER_ID) where IDB_OBJECT_ID = @DEPENDING_IDB_OBJECT ')
--ELSE
-- SET @SOURCE_DEFAULT_SQL = REPLACE(@SOURCE_DEFAULT_SQL,'@JOIN ','')
IF @ATTRTYPE = 'DATE'
SET @SOURCE_DEFAULT_SQL = 'select DISTINCT TERM.TERM_VALUE AS @RESULT_TITLE
FROM
TBIDB_TERM_VALUE_DATE TERM INNER JOIN TBIDB_OBJECT_METADATA MD ON TERM.GUID = MD.DATE_TERM_ID
INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE
MD.ATTR_ID = ' + CONVERT(VARCHAR(3),@pATTRIBUTE_ID) + '
AND OBJ.DELETED = 0 AND ACTIVE = 1'
ELSE IF @ATTRTYPE = 'BIG INTEGER'
SET @SOURCE_DEFAULT_SQL = 'select DISTINCT TERM.TERM_VALUE AS @RESULT_TITLE
FROM
TBIDB_TERM_VALUE_INTEGER TERM INNER JOIN TBIDB_OBJECT_METADATA MD ON TERM.GUID = MD.INT_TERM_ID
INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE
MD.ATTR_ID = ' + CONVERT(VARCHAR(3),@pATTRIBUTE_ID) + '
AND OBJ.DELETED = 0 AND ACTIVE = 1'
ELSE IF @ATTRTYPE = 'BIT'
SET @SOURCE_DEFAULT_SQL = 'select DISTINCT CONVERT(BIT,TERM.TERM_VALUE) AS @RESULT_TITLE
FROM
TBIDB_TERM_VALUE_INTEGER TERM INNER JOIN TBIDB_OBJECT_METADATA MD ON TERM.GUID = MD.INT_TERM_ID
INNER JOIN TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE
MD.ATTR_ID = ' + CONVERT(VARCHAR(3),@pATTRIBUTE_ID) + '
AND OBJ.DELETED = 0 AND ACTIVE = 1'
EXEC PRIDB_NEW_TERM 'VARCHAR',@SOURCE_DEFAULT_SQL,@pWHO_USERNAME,@TERM_ID = @SOURCE_TERM_ID OUTPUT;
IF @pSEQUENCE = 0
SELECT @pSEQUENCE = COALESCE(MAX([SEQUENCE]),0) + 1 FROM TBIDB_SEARCH_PROFILE_ATTRIBUTES WHERE SEARCH_PROFIL_ID = @pSEARCH_PROFIL_ID
IF NOT EXISTS(SELECT GUID FROM TBIDB_SEARCH_PROFILE_ATTRIBUTES WHERE SEARCH_PROFIL_ID = @pSEARCH_PROFIL_ID AND ATTRIBUTE_ID = @pATTRIBUTE_ID)
INSERT INTO TBIDB_SEARCH_PROFILE_ATTRIBUTES (SEARCH_PROFIL_ID,ATTRIBUTE_ID,SOURCE_SQL, [SEQUENCE], ADDED_WHO,HEIGHT,WIDTH,MULTISELECT)
VALUES (@pSEARCH_PROFIL_ID,@pATTRIBUTE_ID,@SOURCE_TERM_ID,@pSEQUENCE, @WHO_TERM_ID,@pHEIGHT,@pWIDTH,@MULTISELECT)
ELSE
BEGIN
UPDATE TBIDB_SEARCH_PROFILE_ATTRIBUTES SET
SOURCE_SQL = @SOURCE_TERM_ID
,[SEQUENCE] = @pSEQUENCE
,HEIGHT = @pHEIGHT
,WIDTH = @pWIDTH
,MULTISELECT = @MULTISELECT
WHERE SEARCH_PROFIL_ID = @pSEARCH_PROFIL_ID AND ATTRIBUTE_ID = @pATTRIBUTE_ID
END
SELECT
T.SEARCH_PROFIL_ID,
T.GUID,
T.ATTRIBUTE_ID,
T1.TITLE AS ATTRIBUTE_TITLE,
T.MULTISELECT,
T.HEIGHT,
T.WIDTH,
T2.NAME_TYPE AS ATTRIBUTE_TYPE
,[dbo].[FNIDB_GET_TERM_FOR_TERM_ID] (T.SOURCE_SQL) AS SOURCE_SQL
,[dbo].[FNIDB_GET_TERM_FOR_TERM_ID] (T.ADDED_WHO) AS ADDED_WHO
,T.ADDED_WHEN
,[dbo].[FNIDB_GET_TERM_FOR_TERM_ID] (T.CHANGED_WHO) AS CHANGED_WHO
,T.CHANGED_WHEN
FROM TBIDB_SEARCH_PROFILE_ATTRIBUTES T INNER JOIN TBIDB_ATTRIBUTE T1 ON T.ATTRIBUTE_ID = T1.GUID
INNER JOIN TBIDB_ATTRIBUTE_TYPE T2 ON T1.TYP_ID = T2.GUID
WHERE T.SEARCH_PROFIL_ID = @pSEARCH_PROFIL_ID --AND ATTRIBUTE_ID = @pATTRIBUTE_ID
ORDER BY [SEQUENCE]
END
GO
-- =============================================
-- Author: DD MS
-- Create date 05.11.2020
-- =============================================
CREATE PROCEDURE [dbo].[PRIDB_NEW_TERM_FOR_ATTRIBUTE] @ATTRIBUTE VARCHAR(100),@TERM VARCHAR(MAX), @WHO VARCHAR(100), @TERM_ID BIGINT OUTPUT
AS
BEGIN
DECLARE @TERM_TYPE_ID TINYINT
SELECT @TERM_TYPE_ID = TYP_ID FROM TBIDB_ATTRIBUTE WHERE UPPER(TITLE) = UPPER(@ATTRIBUTE)
IF @TERM_TYPE_ID = 7 AND UPPER(@TERM) = 'TRUE'
SET @TERM = 1
ELSE IF @TERM_TYPE_ID = 7 AND UPPER(@TERM) = 'FALSE'
SET @TERM = 0
--PRINT 'PRIDB_NEW_TERM: TERM_TYPE_ID IS: ' + CONVERT(VARCHAR(2),@TERM_TYPE_ID) + ' # TERM: ' + @TERM
IF @TERM_TYPE_ID IN (1,8) --VARCHAR
IF NOT EXISTS(SELECT GUID FROM TBIDB_TERM_VALUE_VARCHAR WHERE UPPER(TERM_VALUE) = UPPER(@TERM))
BEGIN
INSERT INTO TBIDB_TERM_VALUE_VARCHAR (TERM_VALUE,ADDED_WHO) VALUES (@TERM,@WHO)
SELECT @TERM_ID = GUID FROM TBIDB_TERM_VALUE_VARCHAR where TERM_VALUE = @TERM
END
ELSE
SELECT @TERM_ID = GUID FROM TBIDB_TERM_VALUE_VARCHAR WHERE UPPER(TERM_VALUE) = UPPER(@TERM)
ELSE IF @TERM_TYPE_ID IN (2,7,9) --BIGINT
IF NOT EXISTS(SELECT GUID FROM TBIDB_TERM_VALUE_INTEGER WHERE TERM_VALUE = CONVERT(BIGINT,@TERM))
BEGIN
INSERT INTO TBIDB_TERM_VALUE_INTEGER (TERM_VALUE,ADDED_WHO) VALUES (CONVERT(BIGINT,@TERM),@WHO)
SELECT @TERM_ID =GUID FROM TBIDB_TERM_VALUE_INTEGER where TERM_VALUE = @TERM
END
ELSE
SELECT @TERM_ID = GUID FROM TBIDB_TERM_VALUE_INTEGER WHERE TERM_VALUE = CONVERT(BIGINT,@TERM)
ELSE IF @TERM_TYPE_ID = 3 --FLOAT
IF NOT EXISTS(SELECT GUID FROM TBIDB_TERM_VALUE_FLOAT WHERE TERM_VALUE = CONVERT(FLOAT,@TERM))
BEGIN
INSERT INTO TBIDB_TERM_VALUE_FLOAT (TERM_VALUE,ADDED_WHO) VALUES (CONVERT(FLOAT,@TERM),@WHO)
SELECT @TERM_ID =GUID FROM TBIDB_TERM_VALUE_FLOAT where TERM_VALUE = @TERM
END
ELSE
SELECT @TERM_ID = GUID FROM TBIDB_TERM_VALUE_FLOAT WHERE TERM_VALUE = CONVERT(FLOAT,@TERM)
ELSE IF @TERM_TYPE_ID = 4 --DECIMAL
IF NOT EXISTS(SELECT GUID FROM TBIDB_TERM_VALUE_DECIMAL WHERE TERM_VALUE = CONVERT(DECIMAL(19,0),@TERM))
BEGIN
INSERT INTO TBIDB_TERM_VALUE_DECIMAL (TERM_VALUE,ADDED_WHO) VALUES (CONVERT(DECIMAL(19,0),@TERM),@WHO)
SELECT @TERM_ID =GUID FROM TBIDB_TERM_VALUE_DECIMAL where TERM_VALUE = @TERM
END
ELSE
SELECT @TERM_ID = GUID FROM TBIDB_TERM_VALUE_DECIMAL WHERE TERM_VALUE = CONVERT(DECIMAL(19,0),@TERM)
ELSE IF @TERM_TYPE_ID = 5 --DATE
IF NOT EXISTS(SELECT GUID FROM TBIDB_TERM_VALUE_DATE WHERE TERM_VALUE = CONVERT(DATE,@TERM))
BEGIN
INSERT INTO TBIDB_TERM_VALUE_DATE (TERM_VALUE,ADDED_WHO) VALUES (CONVERT(DATE,@TERM),@WHO)
SELECT @TERM_ID =GUID FROM TBIDB_TERM_VALUE_DATE where TERM_VALUE = @TERM
END
ELSE
SELECT @TERM_ID = GUID FROM TBIDB_TERM_VALUE_DATE WHERE TERM_VALUE = CONVERT(DATE,@TERM)
PRINT '### PRIDB_NEW_TERM: TERM-ID: ' + CONVERT(VARCHAR(10),@TERM_ID) + '###'
END
GO
--CREATE PROCEDURE [dbo].[PRIDB_NEW_USER_SEARCH_CRITERIA] @pSEARCHID INTEGER,@pUSER_ID INTEGER,@pATTRIBUTE_ID INTEGER,@pTERM VARCHAR(900), @pWHO VARCHAR(100)
--AS
--BEGIN
-- DECLARE @WHO_TERM_ID BIGINT,@ATTR_TYPE INT, @ATTR_TERM_ID BIGINT,@ATTRIBUTE VARCHAR(100)
-- SELECT @ATTR_TYPE = TYP_ID,@ATTRIBUTE = TITLE FROM TBIDB_ATTRIBUTE WHERE GUID = @pATTRIBUTE_ID
-- EXEC PRIDB_NEW_TERM 'VARCHAR',@pWHO,@pWHO,@TERM_ID = @WHO_TERM_ID OUTPUT;
-- EXEC PRIDB_NEW_TERM_FOR_ATTRIBUTE @ATTRIBUTE,@pTERM,@pWHO,@TERM_ID = @ATTR_TERM_ID OUTPUT;
---- GUID NAME_TYPE
----3 FLOAT
----4 DECIMAL
----5 DATE
----6 DATETIME
----9 VECTOR INTEGER
-- INSERT INTO TBIDB_USER_SEARCH_CRITERIA (SEARCH_PROFIL_ID, USERID, ATTRIBUTE_ID, ADDED_WHO, TERM_TEXT, TERM_ID) VALUES
-- (@pSEARCHID, @pUSER_ID, @pATTRIBUTE_ID, @WHO_TERM_ID, @pTERM, @ATTR_TERM_ID)
-- /*IF @ATTR_TYPE IN (1,2,7,8)
-- BEGIN
-- INSERT INTO TBIDB_USER_SEARCH_CRITERIA ( SEARCH_PROFIL_ID, USERID, ATTRIBUTE_ID, TERM_TEXT, ADDED_WHO,TERM_ID) VALUES
-- ( @pSEARCHID, @pUSER_ID, @pATTRIBUTE_ID, @pTERM, @WHO_TERM_ID,@ATTR_TERM_ID)
-- END
-- ELSE IF @ATTR_TYPE = 5
-- INSERT INTO TBIDB_USER_SEARCH_CRITERIA ( SEARCH_PROFIL_ID, USERID, ATTRIBUTE_ID, TERM_DATE, ADDED_WHO,TERM_ID) VALUES
-- ( @pSEARCHID, @pUSER_ID, @pATTRIBUTE_ID, Convert(Date,@pTERM), @WHO_TERM_ID,@ATTR_TERM_ID)
-- ELSE IF @ATTR_TYPE = 3
-- INSERT INTO TBIDB_USER_SEARCH_CRITERIA ( SEARCH_PROFIL_ID, USERID, ATTRIBUTE_ID, TERM_FLOAT, ADDED_WHO,TERM_ID) VALUES
-- ( @pSEARCHID, @pUSER_ID, @pATTRIBUTE_ID, Convert(float,@pTERM), @WHO_TERM_ID,@ATTR_TERM_ID)
--*/
--END
--GO
--CREATE PROCEDURE [dbo].[PRIDB_SEARCH_CRITERIA_SAVE] @pSEARCHID INTEGER,@pUserID INT, @pWHO VARCHAR(100)
--AS
--BEGIN
-- DECLARE @WHO_TERM_ID BIGINT
-- EXEC PRIDB_NEW_TERM 'VARCHAR',@pWHO,@pWHO,@TERM_ID = @WHO_TERM_ID OUTPUT;
-- DELETE FROM TBIDB_SEARCH_CRITERIA_SAVE WHERE SEARCH_PROFIL_ID = @pSEARCHID
-- INSERT INTO [dbo].[TBIDB_SEARCH_CRITERIA_SAVE]
-- ([SEARCH_PROFIL_ID]
-- ,[ATTRIBUTE_ID]
-- ,[TERM_TEXT]
-- ,TERM_ID
-- --,[TERM_DATE]
-- --,[TERM_FLOAT]
-- --,[TERM_DEC]
-- ,[ADDED_WHO])
-- SELECT [SEARCH_PROFIL_ID]
-- ,[ATTRIBUTE_ID]
-- ,[TERM_TEXT]
-- ,TERM_ID
-- --,[TERM_DATE]
-- --,[TERM_FLOAT]
-- --,[TERM_DEC]
-- ,@WHO_TERM_ID FROM TBIDB_USER_SEARCH_CRITERIA WHERE USERID = @pUserID AND SEARCH_PROFIL_ID = @pSEARCHID
--END
--GO
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_NEW_OBJECT] @KIND_TYPE VARCHAR(20),@WHO VARCHAR(100),@FOREIGN_REFID Bigint = 0,@PARENT_OBJ_ID BIGINT = 0, @IDB_OBJ_ID BIGINT OUTPUT
AS
BEGIN
DECLARE
@KINDTYPE_ID TINYINT
SELECT @KINDTYPE_ID = GUID FROM TBIDB_OBJECT_KIND WHERE KIND_NAME = @KIND_TYPE;
IF @FOREIGN_REFID <> 0
BEGIN
IF EXISTS(SELECT IDB_OBJ_ID FROM TBIDB_OBJECT WHERE REFERENCE_KEY = @FOREIGN_REFID)
SELECT @IDB_OBJ_ID = IDB_OBJ_ID FROM TBIDB_OBJECT WHERE REFERENCE_KEY = @FOREIGN_REFID
ELSE
BEGIN
INSERT INTO [dbo].[TBIDB_OBJECT]
([KIND_TYPE_ID],[REFERENCE_KEY],PARENT_OBJ_ID,[ADDED_WHO]) VALUES (@KINDTYPE_ID,@FOREIGN_REFID,@PARENT_OBJ_ID,@WHO);
END
END
ELSE
BEGIN
INSERT INTO [dbo].[TBIDB_OBJECT]
([KIND_TYPE_ID],[REFERENCE_KEY],PARENT_OBJ_ID,[ADDED_WHO]) VALUES (@KINDTYPE_ID,@FOREIGN_REFID,@PARENT_OBJ_ID,@WHO);
END
SELECT @IDB_OBJ_ID = MAX(IDB_OBJ_ID) FROM TBIDB_OBJECT WHERE ADDED_WHO = @WHO;
END
GO
-- =============================================
-- Author: DD MS
-- =============================================
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_NEW_DOC_DOCTYPE] @pIDB_OBJ_ID BIGINT,@pDoctypeID INTEGER, @pWHO VARCHAR(100)
AS
BEGIN
IF NOT EXISTS(SELECT GUID FROM TBIDB_OBJECT_STRUCTURE_TYPE WHERE IDB_OBJ_ID = @pIDB_OBJ_ID AND STRUCTURE_ID = 1 AND RELATION_ID = @pDoctypeID )
INSERT INTO TBIDB_OBJECT_STRUCTURE_TYPE (IDB_OBJ_ID,STRUCTURE_ID,RELATION_ID,ADDED_WHO) VALUES (@pIDB_OBJ_ID,1 ,@pDoctypeID,@pWHO);
UPDATE TBIDB_OBJECT_STRUCTURE_TYPE SET RELATION_ID = @pDoctypeID,CHANGED_WHO = @pWHO
WHERE
IDB_OBJ_ID = @pIDB_OBJ_ID AND STRUCTURE_ID = 1
AND RELATION_ID <> @pDoctypeID;
EXEC PRIDB_OBJECT_CHANGED_SUBSTRUCTURE @pIDB_OBJ_ID,@pWHO
END
GO
-- =============================================
-- Author: DD MS
-- =============================================
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_OBJECT_CHANGED_SUBSTRUCTURE] @pIDB_OBJ_ID BIGINT,@pWHO VARCHAR(100)
AS
BEGIN
UPDATE TBIDB_OBJECT SET
CHANGED_WHEN_SUBSTRUCTURE = GETDATE()
,CHANGED_WHO_SUBSTRUCTURE = @pWHO WHERE IDB_OBJ_ID = @pIDB_OBJ_ID
END
GO
-- =============================================
-- Author: DD MS 15.03.2021
-- Change: 13.07.2021 Filesize
-- =============================================
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_NEW_IDBFO] @REL_PATH VARCHAR(512),@FILE_NAME VARCHAR(200),@FILE_EXT VARCHAR(10), @FILE_SIZE BIGINT, @FILE_HASH VARCHAR(500),
@WHO VARCHAR(100), @IDB_OBJ_ID BIGINT,@OBJ_ST_ID INT,@IDB_DOCTYPE_ID INTEGER
AS
BEGIN
DECLARE
@FILENAME_EXT VARCHAR(250),
@RELATIVE_PATH VARCHAR(512)
--PRINT @FILENAME_ONLY
--PRINT @REL_PATH
--PRINT 'PRIDB_NEW_IDBFO - @RELATIVE_PATH_ONLY1: ' + @RELATIVE_PATH_ONLY
DECLARE @RELPATH_TERM_ID BIGINT,@EXTENSION_TERM_ID BIGINT,@FILENAME_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@REL_PATH,@WHO,@TERM_ID = @RELPATH_TERM_ID OUTPUT;
EXEC PRIDB_NEW_TERM 'VARCHAR',@FILE_EXT,@WHO,@TERM_ID = @EXTENSION_TERM_ID OUTPUT;
EXEC PRIDB_NEW_TERM 'VARCHAR',@FILE_NAME,@WHO,@TERM_ID = @FILENAME_TERM_ID OUTPUT;
--SELECT @FILENAME_EXT = [dbo].[FNGetFileName] (@REL_PATH);
--SELECT @FILENAME_ONLY = [dbo].[FNGetFileNameWithoutExtension] (@REL_PATH);
--SELECT @EXT = UPPER([dbo].[FNGetExtension] (@REL_PATH));
--PRINT 'PRIDB_NEW_IDBFO: ' + @REL_PATH
INSERT INTO TBIDB_OBJECT_BE (IDB_OBJ_ID,BE_ID, ADDED_WHO)
SELECT @IDB_OBJ_ID,BE_ID,@WHO FROM TBIDB_DOCTYPE_BE WHERE DOCTYPE_ID = @IDB_DOCTYPE_ID;
--ADD THE DOCTYPE
EXEC PRIDB_NEW_DOC_DOCTYPE @IDB_OBJ_ID,@IDB_DOCTYPE_ID, @WHO;
BEGIN
IF NOT EXISTS(SELECT IDB_OBJ_ID FROM TBIDB_FILE_OBJECT WHERE IDB_OBJ_ID = @IDB_OBJ_ID)
INSERT INTO [dbo].[TBIDB_FILE_OBJECT]
([IDB_OBJ_ID]
,[OBJ_ST_ID]
,EXTENSION_TERM_ID
,RELPATH_TERM_ID
,FILENAME_TERM_ID
,FILE_SIZE
,FILE_HASH
,[ADDED_WHO])
VALUES
(@IDB_OBJ_ID
,@OBJ_ST_ID
,@EXTENSION_TERM_ID
,@RELPATH_TERM_ID
,@FILENAME_TERM_ID
,@FILE_SIZE
,@FILE_HASH
,@WHO)
ELSE
BEGIN
--PRINT 'OBJECT ' + CONVERT(VARCHAR(20),@IDB_OBJ_ID) + ' ALREADY EXISTING ---- So ONLY UPDATE WITH NEW FILE PARAMS'
UPDATE TBIDB_FILE_OBJECT SET
EXTENSION_TERM_ID = @EXTENSION_TERM_ID
,RELPATH_TERM_ID = @RELPATH_TERM_ID
,FILENAME_TERM_ID = @FILENAME_TERM_ID
,FILE_SIZE = @FILE_SIZE
,FILE_HASH = @FILE_HASH
,CHANGED_WHO = @WHO
WHERE IDB_OBJ_ID = @IDB_OBJ_ID
IF EXISTS(SELECT IDB_OBJ_ID FROM TBIDB_OBJECT WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND DELETED = 1)
BEGIN
PRINT 'PRIDB_NEW_IDBFO - IDB_OBJ_ID: ' + CONVERT(VARCHAR(20),@IDB_OBJ_ID) + ' DELETED FLAG ACTIVE!!'
UPDATE TBIDB_OBJECT SET DELETED = 0 WHERE IDB_OBJ_ID = @IDB_OBJ_ID
END
END
END
END
GO
-- =============================================
-- Author: DD MS
-- Creation date: 05.07.2021
-- =============================================
CREATE PROCEDURE [dbo].[PRIDB_GET_VALUE_DT] @IDB_OBJ_ID BIGINT, @LANG_CODE VARCHAR(5)
AS
DECLARE @ATTR_ID INTEGER,@ATTR_TITLE VARCHAR(100), @TYPE_NAME VARCHAR(100)
DECLARE
@TBRESULT TABLE (AttributID INT, AttributTitle VARCHAR(100), AttributType VARCHAR(100),ValueBigInt BIGINT, ValueText Varchar(912), ValueDec Decimal(19,2), ValueDate Date,
ADDED_WHEN DATETIME, CHANGED_WHEN DATETIME)
DECLARE cursorAttributes CURSOR LOCAL FOR
SELECT A.ATTR_ID, B.ATTR_TITLE, B.TYPE_NAME FROM TBIDB_OBJECT_METADATA A INNER JOIN VWIDB_BE_ATTRIBUTE B On A.ATTR_ID = B.ATTR_ID
WHERE A.IDB_OBJ_ID = @IDB_OBJ_ID AND B.LANG_CODE = @LANG_CODE
OPEN cursorAttributes
FETCH NEXT FROM cursorAttributes INTO @ATTR_ID,@ATTR_TITLE,@TYPE_NAME
WHILE @@FETCH_STATUS = 0
BEGIN
PRINT CONVERT(VARCHAR(2),@ATTR_ID) + '#' + @TYPE_NAME + '#' + @ATTR_TITLE
IF @TYPE_NAME IN ('VARCHAR','VECTOR STRING')
INSERT INTO @TBRESULT (AttributID,AttributTitle,AttributType,ValueText,ADDED_WHEN,CHANGED_WHEN)
select
@ATTR_ID,@ATTR_TITLE,@TYPE_NAME,[dbo].[FNIDB_GET_TERM_TEXT] (@IDB_OBJ_ID,@ATTR_ID,@LANG_CODE),T.ADDED_WHEN,T.CHANGED_WHEN
from
TBIDB_OBJECT_METADATA T
WHERE T.IDB_OBJ_ID = @IDB_OBJ_ID AND T.ATTR_ID = @ATTR_ID
ELSE IF @TYPE_NAME IN ('BIT','BIG INTEGER')
INSERT INTO @TBRESULT (AttributID,AttributTitle,AttributType,ValueBigInt,ADDED_WHEN,CHANGED_WHEN)
select
@ATTR_ID,@ATTR_TITLE,@TYPE_NAME,[dbo].[FNIDB_GET_TERM_INTEGER] (@IDB_OBJ_ID,@ATTR_ID),T.ADDED_WHEN,T.CHANGED_WHEN
from
TBIDB_OBJECT_METADATA T
WHERE T.IDB_OBJ_ID = @IDB_OBJ_ID AND T.ATTR_ID = @ATTR_ID
ELSE IF @TYPE_NAME = 'DATE'
INSERT INTO @TBRESULT (AttributID,AttributTitle,AttributType,ValueDate,ADDED_WHEN,CHANGED_WHEN)
select
@ATTR_ID,@ATTR_TITLE,@TYPE_NAME,[dbo].[FNIDB_GET_TERM_DATE] (@IDB_OBJ_ID,@ATTR_ID),T.ADDED_WHEN,T.CHANGED_WHEN
from
TBIDB_OBJECT_METADATA T
WHERE T.IDB_OBJ_ID = @IDB_OBJ_ID AND T.ATTR_ID = @ATTR_ID
ELSE IF @TYPE_NAME = 'DECIMAL'
INSERT INTO @TBRESULT (AttributID,AttributTitle,AttributType,ValueDec,ADDED_WHEN,CHANGED_WHEN)
select
@ATTR_ID,@ATTR_TITLE,@TYPE_NAME,[dbo].[FNIDB_GET_TERM_DECIMAL] (@IDB_OBJ_ID,@ATTR_ID),T.ADDED_WHEN,T.CHANGED_WHEN
from
TBIDB_OBJECT_METADATA T
WHERE T.IDB_OBJ_ID = @IDB_OBJ_ID AND T.ATTR_ID = @ATTR_ID
FETCH NEXT FROM cursorAttributes INTO @ATTR_ID,@ATTR_TITLE,@TYPE_NAME
END
CLOSE cursorAttributes
DEALLOCATE cursorAttributes
SELECT * FROM @TBRESULT order BY AttributID,ADDED_WHEN
GO
-- =============================================
-- Author: SYSTEM, MS
-- Create date: 12.10.2021
-- =============================================
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_GET_ATTRIBUTE_VALUE] @IDB_OBJ_ID BIGINT,@ATTRIBUTE VARCHAR(100), @LANG_CODE VARCHAR(5), @VALUE VARCHAR(MAX) OUTPUT
AS
BEGIN
DECLARE
@ATTR_ID INTEGER,
@TYP_ID TINYINT,
@TYP_DESCR VARCHAR(100),
@LANG_ID INT
IF NOT EXISTS(SELECT ATTR_ID FROM VWIDB_BE_ATTRIBUTE WHERE ATTR_TITLE = @ATTRIBUTE AND LANG_CODE = @LANG_CODE)
RAISERROR ('NO VALID ATTRIBUTE',16,1)
SELECT @ATTR_ID = ATTR_ID, @TYP_ID = TYPE_ID, @TYP_DESCR = TYPE_NAME,@LANG_ID = LANG_ID
FROM VWIDB_BE_ATTRIBUTE
WHERE ATTR_TITLE = @ATTRIBUTE AND LANG_CODE = @LANG_CODE
IF @TYP_ID IN (1,8) --VARCHAR
BEGIN
select
@VALUE = TERM.TERM_VALUE
FROM
IDB.dbo.TBIDB_TERM_VALUE_VARCHAR TERM INNER JOIN IDB.dbo.TBIDB_LANGUAGE_TERM TLANG ON TERM.GUID = TLANG.TERM_ID
INNER JOIN TBIDB_LANGUAGE LANG ON TLANG.LANG_ID = LANG.GUID
INNER JOIN IDB.dbo.TBIDB_OBJECT_METADATA MD ON TLANG.[OBJECT_ID] = MD.GUID
INNER JOIN IDB.dbo.TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE
OBJ.DELETED = 0 AND
MD.IDB_OBJ_ID = @IDB_OBJ_ID AND
MD.ATTR_ID = @ATTR_ID AND TLANG.LANG_ID = @LANG_ID
END
ELSE IF @TYP_ID IN (2,7,9) --BIGINT
BEGIN
select
@VALUE = CONVERT(VARCHAR(20),TERM.TERM_VALUE)
FROM
IDB.dbo.TBIDB_TERM_VALUE_INTEGER TERM INNER JOIN TBIDB_OBJECT_METADATA MD ON TERM.GUID = MD.INT_TERM_ID
INNER JOIN IDB.dbo.TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE
OBJ.DELETED = 0 AND
MD.IDB_OBJ_ID = @IDB_OBJ_ID ANd
MD.ATTR_ID = @ATTR_ID
END
ELSE IF @TYP_ID = 3 --FLOAT
BEGIN
select
@VALUE = CONVERT(VARCHAR(20),TERM.TERM_VALUE)
FROM
IDB.dbo.TBIDB_TERM_VALUE_FLOAT TERM INNER JOIN TBIDB_OBJECT_METADATA MD ON TERM.GUID = MD.INT_TERM_ID
INNER JOIN IDB.dbo.TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE
OBJ.DELETED = 0 AND
MD.IDB_OBJ_ID = @IDB_OBJ_ID ANd
MD.ATTR_ID = @ATTR_ID
END
ELSE IF @TYP_ID = 4 --DECIMAL
BEGIN
select
@VALUE = CONVERT(VARCHAR(20),TERM.TERM_VALUE)
FROM
IDB.dbo.TBIDB_TERM_VALUE_DECIMAL TERM INNER JOIN TBIDB_OBJECT_METADATA MD ON TERM.GUID = MD.INT_TERM_ID
INNER JOIN IDB.dbo.TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE
OBJ.DELETED = 0 AND
MD.IDB_OBJ_ID = @IDB_OBJ_ID ANd
MD.ATTR_ID = @ATTR_ID
END
ELSE IF @TYP_ID = 5 --DATE
BEGIN
select
@VALUE = CONVERT(VARCHAR(20),TERM.TERM_VALUE)
FROM
IDB.dbo.TBIDB_TERM_VALUE_DATE TERM INNER JOIN TBIDB_OBJECT_METADATA MD ON TERM.GUID = MD.INT_TERM_ID
INNER JOIN IDB.dbo.TBIDB_OBJECT OBJ ON MD.IDB_OBJ_ID = OBJ.IDB_OBJ_ID
WHERE
OBJ.DELETED = 0 AND
MD.IDB_OBJ_ID = @IDB_OBJ_ID ANd
MD.ATTR_ID = @ATTR_ID
END
END
GO
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_REPLACE_ATTRIBUTE_DATA] @IDB_OBJ_ID BIGINT, @ATTRIBUTE VARCHAR(100), @OLD_TERM VARCHAR(900), @NEW_TERM VARCHAR(900),@LANGUAGE VARCHAR(5), @WHO VARCHAR(100)
AS
BEGIN
DECLARE
@UPD_GUID BIGINT,
@ATTR_ID INTEGER,
@ATTR_TYP_ID TINYINT,
@TYP_DESCR VARCHAR(100),
@MULTI BIT,
@TEXT_TERM_ID BIGINT,
@TERM_ID BIGINT,
@USER_DELETE_ID INTEGER,
@ERROR as BIT,
@LANGUAGE_ID TINYINT,
@WHO_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@WHO,@WHO,@TERM_ID = @WHO_TERM_ID OUTPUT;
PRINT 'IN PRIDB_REPLACE_ATTRIBUTE_DATA...'
SET @ERROR = 0
SELECT @USER_DELETE_ID = COALESCE(MAX(USER_DELETE_ID),0) + 1 FROM TBIDB_OBJECT_METADATA_DELETE WHERE UPPER(DELETED_WHO) = UPPER(@WHO)
SELECT @LANGUAGE_ID = GUID FROM TBIDB_LANGUAGE WHERE UPPER(LANG_CODE) = UPPER(@LANGUAGE)
SELECT @ATTR_ID = T.GUID, @ATTR_TYP_ID = T.TYP_ID, @MULTI = T.MULTI_CONTEXT,@TYP_DESCR = T1.NAME_TYPE FROM TBIDB_ATTRIBUTE T, TBIDB_ATTRIBUTE_TYPE T1
WHERE T.TYP_ID = T1.GUID AND UPPER(T.TITLE) = UPPER(@ATTRIBUTE)
DECLARE @MY_OLD_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM @TYP_DESCR,@OLD_TERM,@WHO,@TERM_ID = @MY_OLD_TERM_ID OUTPUT;
DECLARE @MY_NEW_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM @TYP_DESCR,@NEW_TERM,@WHO,@TERM_ID = @MY_NEW_TERM_ID OUTPUT;
IF @ATTR_TYP_ID IN (1,8) --VARCHAR
BEGIN TRY
DECLARE @OMD_ID BIGINT
SELECT @OMD_ID = GUID FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND ATTR_ID = @ATTR_ID;
UPDATE TBIDB_LANGUAGE_TERM SET
TERM_ID = @MY_NEW_TERM_ID,
CHANGED_WHO = @WHO_TERM_ID
WHERE
[OBJECT_ID] = @OMD_ID AND LANG_ID = @LANGUAGE_ID AND TERM_ID = @MY_OLD_TERM_ID;
END TRY
BEGIN CATCH
PRINT 'ERROR WHILE UPDATING FROM TBIDB_OBJECT_METADATA FOR ATTRIBUTE [' + @ATTRIBUTE + ']'
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
SET @ERROR = 1
END CATCH
ELSE IF @ATTR_TYP_ID IN (2,7,9) --BIGINT
BEGIN TRY
DECLARE cursor_REPLACE CURSOR LOCAL FOR
SELECT T.GUID FROM TBIDB_OBJECT_METADATA T WHERE T.INT_TERM_ID = @MY_OLD_TERM_ID
OPEN cursor_REPLACE
FETCH NEXT FROM cursor_REPLACE INTO @UPD_GUID
WHILE @@FETCH_STATUS = 0
BEGIN
UPDATE TBIDB_OBJECT_METADATA SET INT_TERM_ID = @MY_NEW_TERM_ID WHERE GUID = @UPD_GUID
FETCH NEXT FROM cursor_REPLACE INTO @UPD_GUID
END
CLOSE cursor_REPLACE
DEALLOCATE cursor_REPLACE
END TRY
BEGIN CATCH
PRINT 'ERROR WHILE DELETING (INTEGER) FROM TBIDB_OBJECT_METADATA FOR ATTRIBUTE [' + @ATTRIBUTE + ']'
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
SET @ERROR = 1
END CATCH
ELSE IF @ATTR_TYP_ID = 3 --FLOAT
BEGIN TRY
DECLARE cursor_REPLACE CURSOR LOCAL FOR
SELECT T.GUID FROM TBIDB_OBJECT_METADATA T WHERE T.FLOAT_TERM_ID = @MY_OLD_TERM_ID
OPEN cursor_REPLACE
FETCH NEXT FROM cursor_REPLACE INTO @UPD_GUID
WHILE @@FETCH_STATUS = 0
BEGIN
UPDATE TBIDB_OBJECT_METADATA SET FLOAT_TERM_ID = @MY_NEW_TERM_ID WHERE GUID = @UPD_GUID
FETCH NEXT FROM cursor_REPLACE INTO @UPD_GUID
END
CLOSE cursor_REPLACE
DEALLOCATE cursor_REPLACE
END TRY
BEGIN CATCH
PRINT 'ERROR WHILE DELETING (FLOAT) FROM TBIDB_OBJECT_METADATA FOR ATTRIBUTE [' + @ATTRIBUTE + ']'
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
SET @ERROR = 1
END CATCH
ELSE IF @ATTR_TYP_ID = 4 --DECIMAL
BEGIN TRY
DECLARE cursor_REPLACE CURSOR LOCAL FOR
SELECT T.GUID FROM TBIDB_OBJECT_METADATA T WHERE T.DEC_TERM_ID = @MY_OLD_TERM_ID
OPEN cursor_REPLACE
FETCH NEXT FROM cursor_REPLACE INTO @UPD_GUID
WHILE @@FETCH_STATUS = 0
BEGIN
UPDATE TBIDB_OBJECT_METADATA SET DEC_TERM_ID = @MY_NEW_TERM_ID WHERE GUID = @UPD_GUID
FETCH NEXT FROM cursor_REPLACE INTO @UPD_GUID
END
CLOSE cursor_REPLACE
DEALLOCATE cursor_REPLACE
END TRY
BEGIN CATCH
PRINT 'ERROR WHILE DELETING (DECIMAL) FROM TBIDB_OBJECT_METADATA FOR ATTRIBUTE [' + @ATTRIBUTE + ']'
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
SET @ERROR = 1
END CATCH
ELSE IF @ATTR_TYP_ID = 5 --DATE
BEGIN TRY
DECLARE cursor_REPLACE CURSOR LOCAL FOR
SELECT T.GUID FROM TBIDB_OBJECT_METADATA T WHERE T.DATE_TERM_ID = @MY_OLD_TERM_ID
OPEN cursor_REPLACE
FETCH NEXT FROM cursor_REPLACE INTO @UPD_GUID
WHILE @@FETCH_STATUS = 0
BEGIN
UPDATE TBIDB_OBJECT_METADATA SET DATE_TERM_ID = @MY_NEW_TERM_ID WHERE GUID = @UPD_GUID
FETCH NEXT FROM cursor_REPLACE INTO @UPD_GUID
END
CLOSE cursor_REPLACE
DEALLOCATE cursor_REPLACE
END TRY
BEGIN CATCH
PRINT 'ERROR WHILE DELETING (DATE) FROM TBIDB_OBJECT_METADATA FOR ATTRIBUTE [' + @ATTRIBUTE + ']'
+ ' - ERROR-MESSAGE: '
+ CONVERT(VARCHAR(500),ERROR_MESSAGE())
SET @ERROR = 1
END CATCH
--IF @ERROR = 0
-- BEGIN
-- UPDATE TBIDB_ATTRIBUTE SET DELETED = 1, DELETED_WHO = @WHO WHERE GUID = @ATTR_ID;
-- END
END
GO
-- =============================================
-- Author: DD MS
-- Changed: 01.11.2021 MS TERM_COLUMNS
-- Changed: 10.08.2020 MS Anpassung
-- =============================================
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_NEW_DOCUMENT] @OBJ_ST_ID INT, @REL_PATH VARCHAR(512),@WHO VARCHAR(100), @REF_DOCID BIGINT = 0, @BE VARCHAR(500) = '', @IDB_OBJ_ID BIGINT OUTPUT
AS
BEGIN
DECLARE
@SHARE_PATH VARCHAR(100),
@OBJ_STORE_PATH VARCHAR(250),
@NEW_FULL_PATH VARCHAR(512),
@FILENAME_EXT VARCHAR(250),
@FILENAME_ONLY VARCHAR(250),
@RELATIVE_PATH VARCHAR(512),
@RELATIVE_PATH_ONLY VARCHAR(512),
@EXT VARCHAR(10)
SELECT
@SHARE_PATH = T.CAT_STRING, @OBJ_STORE_PATH = T1.OBJ_PATH
FROM TBIDB_CATALOG T, TBIDB_OBJECT_STORE T1 WHERE T1.CAT_ID = T.GUID AND T1.GUID = @OBJ_ST_ID
SET @NEW_FULL_PATH = UPPER(@SHARE_PATH + '\' + @OBJ_STORE_PATH + '\' + @REL_PATH)
SET @NEW_FULL_PATH = REPLACE(@NEW_FULL_PATH,'\\','')
SET @RELATIVE_PATH = UPPER(@REL_PATH)
PRINT 'PRIDB_NEW_DOCUMENT - @NEW_FULL_PATH: ' + @NEW_FULL_PATH
PRINT 'PRIDB_NEW_DOCUMENT - @RELATIVE_PATH: ' + @RELATIVE_PATH
--SELECT @RELATIVE_PATH_ONLY = [dbo].[FNGetDirectoryPath] (@NEW_FULL_PATH);
--PRINT 'PRIDB_NEW_DOCUMENT - @RELATIVE_PATH_ONLY1: ' + @RELATIVE_PATH_ONLY
SELECT @FILENAME_EXT = [dbo].[FNGetFileName] (@NEW_FULL_PATH);
SELECT @FILENAME_ONLY = [dbo].[FNGetFileNameWithoutExtension] (@NEW_FULL_PATH);
SELECT @EXT = UPPER([dbo].[FNGetExtension] (@NEW_FULL_PATH));
SET @RELATIVE_PATH_ONLY = REPLACE(@REL_PATH,'\' + @FILENAME_EXT,'')
PRINT 'PRIDB_NEW_DOCUMENT - @RELATIVE_PATH_ONLY: ' + @RELATIVE_PATH_ONLY
DECLARE @RELATIVE_PATH_ONLY_TERM BIGINT,@EXTENSION_TERM BIGINT
EXECUTE [dbo].[PRIDB_NEW_TERM] 'Varchar',@RELATIVE_PATH_ONLY,@WHO, @TERM_ID = @RELATIVE_PATH_ONLY_TERM OUTPUT
EXECUTE [dbo].[PRIDB_NEW_TERM] 'Varchar',@EXT,@WHO, @TERM_ID = @EXTENSION_TERM OUTPUT
--PRINT '@EXT: ' + @EXT
--IF NOT EXISTS(SELECT [IDB_OBJ_ID] FROM [TBIDB_DOC_INFO] WHERE [OBJ_ST_ID] = @OBJ_ST_ID AND UPPER([RELATIVE_PATH]) = @RELATIVE_PATH)
EXEC PRIDB_NEW_OBJECT 'DOC',@WHO,@BE,@REF_DOCID, 0,@IDB_OBJ_ID = @IDB_OBJ_ID OUTPUT;
PRINT 'PRIDB_NEW_DOCUMENT - @IDB_OBJ_ID from PRIDB_NEW_OBJECT: ' + CONVERT(VARCHAR(20),@IDB_OBJ_ID)
BEGIN
IF NOT EXISTS(SELECT IDB_OBJ_ID FROM [TBIDB_DOC_INFO] WHERE IDB_OBJ_ID = @IDB_OBJ_ID)
INSERT INTO [dbo].[TBIDB_DOC_INFO]
([IDB_OBJ_ID]
,[OBJ_ST_ID]
,[FILENAME_ONLY]
,RELATIVE_PATH
,RELATIVE_PATH_ONLY_TERM
,EXTENSION_TERM
,[ADDED_WHO])
VALUES
(@IDB_OBJ_ID
,@OBJ_ST_ID
,@FILENAME_ONLY
,@RELATIVE_PATH
,@RELATIVE_PATH_ONLY_TERM
,@EXTENSION_TERM
,@WHO)
ELSE
BEGIN
PRINT 'OBJECT ' + CONVERT(VARCHAR(20),@IDB_OBJ_ID) + ' ALREADY EXISTING ---- So ONLY UPDATE WITH NEW FILE PARAMS'
UPDATE [TBIDB_DOC_INFO] SET [FILENAME_EXT] = @FILENAME_EXT,[FILENAME_ONLY] = @FILENAME_ONLY
,@EXTENSION_TERM = @EXTENSION_TERM
,[RELATIVE_PATH] = @RELATIVE_PATH
,RELATIVE_PATH_ONLY_TERM = @RELATIVE_PATH_ONLY_TERM
,CHANGED_WHO = @WHO
WHERE IDB_OBJ_ID = @IDB_OBJ_ID
IF EXISTS(SELECT IDB_OBJ_ID FROM TBIDB_OBJECT WHERE IDB_OBJ_ID = @IDB_OBJ_ID AND DELETED = 1)
BEGIN
PRINT 'PRIDB_NEW_DOCUMENT - IDB_OBJ_ID: ' + CONVERT(VARCHAR(20),@IDB_OBJ_ID) + ' DELETED FLAG ACTIVE!!'
UPDATE TBIDB_OBJECT SET DELETED = 0 WHERE IDB_OBJ_ID = @IDB_OBJ_ID
END
END
END
END
GO
-- =============================================
-- Author: DD MS 21.01.2022
-- =============================================
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_NEW_VERSION_OBJECT] @IDB_OBJ_ID BIGINT,@NEW_IDB_OBJ_ID BIGINT, @WHO VARCHAR(100)
AS
BEGIN
UPDATE TBIDB_OBJECT SET ACTIVE = 0, CHANGED_WHO = @WHO WHERE IDB_OBJ_ID = @IDB_OBJ_ID;
UPDATE TBIDB_OBJECT SET IS_VERSION = 1,ACTIVE = 1,PARENT_OBJ_ID = @IDB_OBJ_ID WHERE IDB_OBJ_ID = @NEW_IDB_OBJ_ID;
EXEC PRIDB_OBJECT_SET_STATE @IDB_OBJ_ID, 'File Versioned',@WHO;
DELETE FROM TBIDB_LANGUAGE_TERM WHERE OBJECT_ID IN (select GUID from idb.dbo.TBIDB_OBJECT_METADATA where IDB_OBJ_ID = @NEW_IDB_OBJ_ID);
DELETE FROM TBIDB_OBJECT_METADATA where IDB_OBJ_ID = @NEW_IDB_OBJ_ID;
INSERT INTO [dbo].[TBIDB_OBJECT_METADATA]
([IDB_OBJ_ID]
,[ATTR_ID]
,[INT_TERM_ID]
,[DEC_TERM_ID]
,[FLOAT_TERM_ID]
,[DATE_TERM_ID]
,[ADDED_WHO]
,[ADDED_WHEN]
,[CHANGED_WHO]
,[CHANGED_WHEN]
,[DATETIME_TERM_ID])
SELECT @NEW_IDB_OBJ_ID
,[ATTR_ID]
,[INT_TERM_ID]
,[DEC_TERM_ID]
,[FLOAT_TERM_ID]
,[DATE_TERM_ID]
,[ADDED_WHO]
,[ADDED_WHEN]
,[CHANGED_WHO]
,[CHANGED_WHEN]
,[DATETIME_TERM_ID] FROM TBIDB_OBJECT_METADATA WHERE IDB_OBJ_ID = @IDB_OBJ_ID ORDER BY GUID;
INSERT INTO TBIDB_LANGUAGE_TERM (
OBJECT_ID
,TERM_ID
,LANG_ID
,KIND_TYPE
,ADDED_WHO
,ADDED_WHEN
,CHANGED_WHO
,CHANGED_WHEN)
SELECT MD.GUID, LTERM_VERS.TERM_ID,LTERM_VERS.LANG_ID,LTERM_VERS.KIND_TYPE,LTERM_VERS.ADDED_WHO,LTERM_VERS.ADDED_WHEN,LTERM_VERS.CHANGED_WHO,LTERM_VERS.CHANGED_WHEN FROM
(SELECT
MD.ATTR_ID, LTERM.LANG_ID, LTERM.TERM_ID,LTERM.ADDED_WHO,LTERM.ADDED_WHEN,LTERM.CHANGED_WHO,LTERM.CHANGED_WHEN, LTERM.KIND_TYPE
FROM TBIDB_LANGUAGE_TERM LTERM INNER JOIN TBIDB_OBJECT_METADATA MD ON LTERM.OBJECT_ID = MD.GUID
WHERE LTERM.OBJECT_ID IN (select GUID from idb.dbo.TBIDB_OBJECT_METADATA where IDB_OBJ_ID = @IDB_OBJ_ID)
) LTERM_VERS INNER JOIN TBIDB_OBJECT_METADATA MD ON MD.ATTR_ID = LTERM_VERS.ATTR_ID
WHERE MD.IDB_OBJ_ID = @NEW_IDB_OBJ_ID;
INSERT INTO TBIDB_MYOBJECT_STATES
(MY_OBJECT_ID
,[STATE_ID]
,[ADDED_WHO]
,[ADDED_WHEN]
,[CHANGED_WHO]
,[CHANGED_WHEN])
SELECT @NEW_IDB_OBJ_ID
,[STATE_ID]
,[ADDED_WHO]
,[ADDED_WHEN]
,[CHANGED_WHO]
,[CHANGED_WHEN] FROM TBIDB_MYOBJECT_STATES WHERE MY_OBJECT_ID = @IDB_OBJ_ID;
END
GO
-- =============================================
-- Author: DD MS
-- Changed:
-- =============================================
CREATE PROCEDURE PRIDB_NEW_DYNAMIC_FOLDER_FOR_OBJECT @pIDB_OBJ_ID BIGINT, @pDYNAMIC_FOLDER VARCHAR(900),@pWHO VARCHAR(100),@pLANG_CODE VARCHAR(5)
AS
DECLARE
@FOLD_PART VARCHAR(250)
BEGIN
DECLARE @FOLDER_DEPTH TINYINT,@FOLDER_PART VARCHAR(900)
SET @FOLDER_DEPTH = 0
DECLARE @PARENT_OBJ_ID BIGINT
--SPLIT FOR FOLDER PARTS
DECLARE cursSplitFolder CURSOR FOR
SELECT Item FROM [dbo].[FN_SPLIT_STRING] (@pDYNAMIC_FOLDER,'\')
OPEN cursSplitFolder
FETCH NEXT FROM cursSplitFolder INTO @FOLD_PART
WHILE @@FETCH_STATUS = 0
BEGIN
--EACH FOLDER PART WORKED SEPERATELY
IF @FOLDER_DEPTH = 0
BEGIN
SET @PARENT_OBJ_ID = 0
SET @FOLDER_PART = @FOLD_PART
END
ELSE
BEGIN
SET @FOLDER_PART += '\' + @FOLD_PART
END
PRINT '##############################'
PRINT '@FOLDER_PART: ' + @FOLDER_PART
DECLARE @PATH_PART_ID BIGINT,@FOLDER_PART_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@FOLD_PART,@pWHO,@TERM_ID = @PATH_PART_ID OUTPUT;
--EXEC PRIDB_NEW_TERM 'VARCHAR',@FOLDER_PART,'DD MS',@TERM_ID = @FOLDER_PART_ID OUTPUT;
DECLARE @FOLD_PART_IDB_OBJ_ID BIGINT
IF NOT EXISTS(SELECT * FROM VWIDB_STRUCTURE_NODES WHERE TERM_GUID = @PATH_PART_ID AND PARENT_OBJ_ID = @PARENT_OBJ_ID)
BEGIN
PRINT 'FOLDER-PART ' + @FOLD_PART + ' muss angelegt werden'
EXEC PRIDB_NEW_OBJECT 'DYNAMIC_FOLDER',@pWHO,0, @PARENT_OBJ_ID, @IDB_OBJ_ID = @FOLD_PART_IDB_OBJ_ID OUTPUT;
DECLARE @NEW_OBJ_MD_ID BIGINT
EXEC PRIDB_NEW_OBJ_DATA @FOLD_PART_IDB_OBJ_ID, 'VIRTUAL_FOLDER_PART', @pWHO, @FOLD_PART, @pLANG_CODE, 0, @OMD_ID = @NEW_OBJ_MD_ID OUTPUT
END
ELSE
BEGIN
SELECT @FOLD_PART_IDB_OBJ_ID = MAX(IDB_OBJ_ID) FROM VWIDB_STRUCTURE_NODES WHERE TERM_GUID = @PATH_PART_ID AND PARENT_OBJ_ID = @PARENT_OBJ_ID
PRINT 'FOLDER-PART ' + @FOLD_PART + ' EXISTIERT BEREITS'
END
SET @PARENT_OBJ_ID = @FOLD_PART_IDB_OBJ_ID
SET @FOLDER_DEPTH += 1
FETCH NEXT FROM cursSplitFolder INTO @FOLD_PART
END
CLOSE cursSplitFolder
DEALLOCATE cursSplitFolder
IF NOT EXISTS(SELECT GUID FROM TBIDB_OBJECT_DYNAMIC_FOLDER WHERE IDB_OBJ_ID = @pIDB_OBJ_ID AND DYN_FOLD_ID = @FOLD_PART_IDB_OBJ_ID)
INSERT INTO TBIDB_OBJECT_DYNAMIC_FOLDER (IDB_OBJ_ID,DYN_FOLD_ID,ADDED_WHO) VALUES (@pIDB_OBJ_ID,@FOLD_PART_IDB_OBJ_ID,@pWHO);
END
GO
--INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE) VALUES ('Doctype',1,1);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE,VIEW_VISIBLE) VALUES ('OriginFileName',1,1,0);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE,VIEW_VISIBLE) VALUES ('OriginCreationDatetime',6,1,0);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE,VIEW_VISIBLE) VALUES ('OriginChangedDatetime',6,1,0);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE,VIEW_VISIBLE) VALUES ('DisplayFileName',1,1,0);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE,VIEW_VISIBLE) VALUES ('DisplayFileName1',1,1,0);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE,VIEW_VISIBLE) VALUES ('Dynamic Folder',1,1,0);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE,VIEW_VISIBLE) VALUES ('EmailMessageID',1,1,0);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE,VIEW_VISIBLE) VALUES ('EmailSubject',1,1,0);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE,VIEW_VISIBLE) VALUES ('EmailFrom',1,1,0);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE,VIEW_VISIBLE) VALUES ('EmailDate',5,1,0);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE,MULTI_CONTEXT,VIEW_VISIBLE) VALUES ('PM-LOGGING',8,0,1,0);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE,VIEW_VISIBLE) VALUES ('VIRTUAL_FOLDER',1,1,0);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE,VIEW_VISIBLE) VALUES ('VIRTUAL_FOLDER_PART',1,1,0);
--INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE,MULTI_CONTEXT) VALUES ('ObjectEvents',1,1,1);
INSERT INTO TBIDB_BE_ATTRIBUTE (BE_ID,ATTR_ID,DEFAULT_SEARCH_ATTRIBUTE) SELECT 1,GUID, 1 FROM TBIDB_ATTRIBUTE WHERE TITLE NOT IN ('PM-LOGGING','ObjectEvents') ;
INSERT INTO TBIDB_BE_ATTRIBUTE (BE_ID,ATTR_ID,DEFAULT_SEARCH_ATTRIBUTE) SELECT 1,GUID, 0 FROM TBIDB_ATTRIBUTE where TITLE IN ('PM-LOGGING','ObjectEvents') ;
GO
CREATE OR ALTER PROCEDURE PRIDB_NEW_CATALOG_USER @USRID INTEGER
AS
BEGIN
IF NOT EXISTS(SELECT GUID FROM TBIDB_CATALOG_USER WHERE USR_ID = @USRID AND CAT_TITLE = 'QUICKSEARCH1_TITLE')
INSERT INTO TBIDB_CATALOG_USER (USR_ID,CAT_TITLE,CAT_STRING,ADDED_WHO) VALUES (
@USRID,'QUICKSEARCH1_TITLE','Schnellsuche1','System');
IF NOT EXISTS(SELECT GUID FROM TBIDB_CATALOG_USER WHERE USR_ID = @USRID AND CAT_TITLE = 'QUICKSEARCH1_POS')
INSERT INTO TBIDB_CATALOG_USER (USR_ID,CAT_TITLE,CAT_STRING,ADDED_WHO) VALUES (
@USRID,'QUICKSEARCH1_POS','Top','System');
IF NOT EXISTS(SELECT GUID FROM TBIDB_CATALOG_USER WHERE USR_ID = @USRID AND CAT_TITLE = 'APPLICATION_THEME')
INSERT INTO TBIDB_CATALOG_USER (USR_ID,CAT_TITLE,CAT_STRING,ADDED_WHO) VALUES (
@USRID,'APPLICATION_THEME','DEFAULT','System');
IF NOT EXISTS(SELECT GUID FROM TBIDB_CATALOG_USER WHERE USR_ID = @USRID AND CAT_TITLE = 'GLOBIX_DROPAREA')
INSERT INTO TBIDB_CATALOG_USER (USR_ID,CAT_TITLE,CAT_STRING,ADDED_WHO) VALUES (
@USRID,'GLOBIX_DROPAREA','PROGRESSIVE','System');
END
GO
CREATE OR ALTER PROCEDURE [dbo].[PRIDB_NEW_DOCTYPE] @pDoctypeUnique VARCHAR(100),@pDoctype_Lang VARCHAR(100),@pWHO VARCHAR(100),@LANG_CODE VARCHAR(5) = 'de-DE'
AS
BEGIN
DECLARE
@DOCTYPE_ID INTEGER,
@TYP_ID TINYINT,
@TYP_DESCR VARCHAR(100),
@MULTI BIT,
@LANG_ID INT,
@WHO_TERM_ID BIGINT,
@MY_DOCTYPE_TERM_ID BIGINT
EXEC PRIDB_NEW_TERM 'VARCHAR',@pWHO,@pWHO,@TERM_ID = @WHO_TERM_ID OUTPUT;
EXEC PRIDB_NEW_TERM 'VARCHAR',@pDoctype_Lang,@pWHO,@TERM_ID = @MY_DOCTYPE_TERM_ID OUTPUT;
SELECT @LANG_ID = GUID FROM TBIDB_LANGUAGE WHERE LANG_CODE = @LANG_CODE
IF NOT EXISTS(SELECT GUID FROM TBIDB_DOCTYPE WHERE TITLE = @pDoctypeUnique)
BEGIN
INSERT INTO TBIDB_DOCTYPE (TITLE,ADDED_WHO) VALUES (@pDoctypeUnique, @pWHO);
END
SELECT @DOCTYPE_ID = GUID FROM TBIDB_DOCTYPE WHERE TITLE = @pDoctypeUnique;
PRINT '##@DOCTYPE_ID is: ' + Convert(Varchar(10),@DOCTYPE_ID)
IF NOT EXISTS(SELECT GUID FROM TBIDB_LANGUAGE_TERM WHERE OBJECT_ID = @DOCTYPE_ID AND LANG_ID = @LANG_ID AND KIND_TYPE = 2)
BEGIN
PRINT 'TBIDB_LANGUAGE_TERM_ENTRY NOT EXISTING...'
INSERT INTO [dbo].[TBIDB_LANGUAGE_TERM]
([OBJECT_ID]
,TERM_ID
,LANG_ID
,KIND_TYPE
,ADDED_WHO)
VALUES
(@DOCTYPE_ID
,@MY_DOCTYPE_TERM_ID
,@LANG_ID
,2
,@WHO_TERM_ID);
END
ELSE
IF EXISTS(SELECT GUID FROM TBIDB_LANGUAGE_TERM WHERE OBJECT_ID = @DOCTYPE_ID AND LANG_ID = @LANG_ID AND TERM_ID <> @MY_DOCTYPE_TERM_ID AND KIND_TYPE = 2)
BEGIN
UPDATE [dbo].[TBIDB_LANGUAGE_TERM] SET TERM_ID = @MY_DOCTYPE_TERM_ID, CHANGED_WHO = @WHO_TERM_ID
WHERE OBJECT_ID = @DOCTYPE_ID AND LANG_ID = @LANG_ID AND KIND_TYPE = 2 AND TERM_ID <> @MY_DOCTYPE_TERM_ID;
END
END
GO
EXEC PRIDB_NEW_DOCTYPE 'Ausgangsrechnung','Ausgangsrechnung','System','de-DE';
EXEC PRIDB_NEW_DOCTYPE 'Ausgangsrechnung','Outgoing invoice','System','en-EN';
EXEC PRIDB_NEW_DOCTYPE 'Eingangsrechnung','Eingangsrechnung','System','de-DE';
EXEC PRIDB_NEW_DOCTYPE 'Eingangsrechnung','Incoming invoice','System','en-EN';
EXEC PRIDB_NEW_DOCTYPE 'Gutschrift','Gutschrift','System','de-DE';
EXEC PRIDB_NEW_DOCTYPE 'Gutschrift','Credit note','System','en-EN';
EXEC PRIDB_NEW_DOCTYPE 'Quittung','Quittung','System','de-DE';
GO
CREATE PROCEDURE [dbo].[PRIDB_OBJECT_SUBSTRUCTURE_CHANGED] @IDB_OBJ_ID BIGINT,@WHO VARCHAR(100)
AS
BEGIN
UPDATE TBIDB_OBJECT
SET CHANGED_WHO_SUBSTRUCTURE = @WHO, CHANGED_WHEN_SUBSTRUCTURE = GETDATE()
WHERE
IDB_OBJ_ID = @IDB_OBJ_ID
END
GO
CREATE VIEW [dbo].[VWGI_ADMIN_OVERVIEW] AS
SELECT
T3.GUID as ID,
'GROUP' As Relation,
T.USERNAME,
--T2.NAME AS GROUP_NAME,
T4.BEZEICHNUNG AS DOCTYPE,
T5.OBJECT_TITLE as OBJECT_ST_NAME,
T1.ADDED_WHEN
FROM
DD_ECM.dbo.TBDD_USER T,
DD_ECM.dbo.TBDD_GROUPS_USER T1,
DD_ECM.dbo.TBDD_GROUPS T2,
DD_ECM.dbo.TBDD_USRGRP_DOKTYPE T3,
DD_ECM.dbo.TBDD_DOKUMENTART T4,
IDB.dbo.TBIDB_OBJECT_STORE T5
WHERE
T4.AKTIV = 1 AND
T.GUID = T1.[USER_ID] AND
T1.GROUP_ID = T2.GUID AND
T2.GUID = T3.GROUP_ID AND
T3.DOCTYPE_ID = T4.GUID AND
T4.IDB_OBJECT_STORE_ID = T5.GUID AND
T4.GUID in (SELECT DOKART_ID FROM DD_ECM.dbo.TBDD_DOKUMENTART_MODULE WHERE MODULE_ID = (SELECT GUID FROM DD_ECM.dbo.TBDD_MODULES WHERE UPPER(SHORT_NAME) = ('GLOBIX')))
UNION
SELECT DISTINCT
T3.GUID as ID,
'USER' As Relation,
T.USERNAME,
T4.BEZEICHNUNG AS DOCTYPE,
T5.OBJECT_TITLE as OBJECT_ST_NAME,
T3.ADDED_WHEN
FROM
DD_ECM.dbo.TBDD_USER T,
DD_ECM.dbo.TBDD_USER_DOKTYPE T3,
DD_ECM.dbo.TBDD_DOKUMENTART T4,
IDB.dbo.TBIDB_OBJECT_STORE T5
WHERE
T4.AKTIV = 1 AND
T.GUID = T3.[USER_ID] AND
T3.DOCTYPE_ID = T4.GUID AND
T4.IDB_OBJECT_STORE_ID = T5.GUID AND
T4.GUID in (SELECT DOKART_ID FROM DD_ECM.dbo.TBDD_DOKUMENTART_MODULE WHERE MODULE_ID = (SELECT GUID FROM DD_ECM.dbo.TBDD_MODULES WHERE UPPER(SHORT_NAME) = ('GLOBIX')))
GO
DECLARE @USR_GUID INTEGER
DECLARE c_CATALOG_USR CURSOR FOR
select GUID FROM DD_ECM.dbo.TBDD_USER
OPEN c_CATALOG_USR
FETCH NEXT FROM c_CATALOG_USR INTO @USR_GUID
WHILE @@FETCH_STATUS = 0
BEGIN
EXEC PRIDB_NEW_CATALOG_USER @USR_GUID;
FETCH NEXT FROM c_CATALOG_USR INTO @USR_GUID
END
CLOSE c_CATALOG_USR
DEALLOCATE c_CATALOG_USR;
GO
USE DD_ECM
GO
CREATE VIEW VWGI_DOCTYPE_USER AS
SELECT DISTINCT
T.GUID AS [USER_ID],
T.USERNAME,
--T2.NAME AS GROUP_NAME,
T3.DOCTYPE_ID,
T4.BEZEICHNUNG AS DOCTYPE,
T4.BEZEICHNUNG AS DOCTYPE_ONLY,
T4.KURZNAME,
T4.ZIEL_PFAD,
T4.AKTIV,
T4.NAMENKONVENTION,
T4.OBJEKTTYP,
T4.IDB_OBJECT_STORE_ID OBJECT_ST_ID,
T5.OBJECT_TITLE as OBJECT_ST_NAME,
T4.SEQUENCE
FROM
DD_ECM.dbo.TBDD_USER T,
DD_ECM.dbo.TBDD_GROUPS_USER T1,
DD_ECM.dbo.TBDD_GROUPS T2,
DD_ECM.dbo.TBDD_USRGRP_DOKTYPE T3,
DD_ECM.dbo.TBDD_DOKUMENTART T4,
IDB.dbo.TBIDB_OBJECT_STORE T5
WHERE
T4.AKTIV = 1 AND
T.GUID = T1.[USER_ID] AND
T1.GROUP_ID = T2.GUID AND
T2.GUID = T3.GROUP_ID AND
T3.DOCTYPE_ID = T4.GUID AND
T4.IDB_OBJECT_STORE_ID = T5.GUID AND
T4.GUID in (SELECT DOKART_ID FROM DD_ECM.dbo.TBDD_DOKUMENTART_MODULE WHERE MODULE_ID = (SELECT GUID FROM DD_ECM.dbo.TBDD_MODULES WHERE UPPER(SHORT_NAME) = ('GLOBIX')))
UNION
SELECT DISTINCT
T.GUID AS [USER_ID],
T.USERNAME,
--'' AS GROUP_NAME,
T4.GUID as DOCTYPE_ID,
T4.BEZEICHNUNG AS DOCTYPE,
T4.BEZEICHNUNG AS DOCTYPE_ONLY,
T4.KURZNAME,
T4.ZIEL_PFAD,
T4.AKTIV,
T4.NAMENKONVENTION,
T4.OBJEKTTYP,
T4.IDB_OBJECT_STORE_ID OBJECT_ST_ID,
T5.OBJECT_TITLE as OBJECT_ST_NAME,
T4.SEQUENCE
FROM
DD_ECM.dbo.TBDD_USER T,
DD_ECM.dbo.TBDD_USER_DOKTYPE T3,
DD_ECM.dbo.TBDD_DOKUMENTART T4,
IDB.dbo.TBIDB_OBJECT_STORE T5
WHERE
T4.AKTIV = 1 AND
T.GUID = T3.[USER_ID] AND
T3.DOCTYPE_ID = T4.GUID AND
T4.IDB_OBJECT_STORE_ID = T5.GUID AND
T4.GUID in (SELECT DOKART_ID FROM DD_ECM.dbo.TBDD_DOKUMENTART_MODULE WHERE MODULE_ID = (SELECT GUID FROM DD_ECM.dbo.TBDD_MODULES WHERE UPPER(SHORT_NAME) = ('GLOBIX')))
GO
------------------------------------------------------------------------------
CREATE OR ALTER VIEW [dbo].[VWGI_DOCTYPE_IDB] AS
SELECT
T4.GUID as DOCTYPE_ID,
T4.BEZEICHNUNG AS DOCTYPE,
T4.BEZEICHNUNG AS DOCTYPE_ONLY,
T4.KURZNAME,
T4.FOLDER_FOR_INDEX DYNAMIC_FOLDER,
T4.AKTIV,
T4.NAMENKONVENTION,
T4.OBJEKTTYP,
T6.OBJECT_TITLE AS OBJECT_STORE,
T4.IDB_OBJECT_STORE_ID OBJECT_ST_ID,
T7.CAT_TITLE AS OBJECT_ST_PATH,
T4.ERSTELLTWANN,
T4.GEAENDERTWANN,
T4.SEQUENCE,
T4.IDB_DOCTYPE_ID
FROM
DD_ECM.dbo.TBDD_DOKUMENTART T4 LEFT JOIN IDB.dbo.TBIDB_OBJECT_STORE T6 ON T4.IDB_OBJECT_STORE_ID = T6.GUID
LEFT JOIN IDB.dbo.TBIDB_CATALOG T7 On T6.CAT_ID = T7.GUID
WHERE
T4.GUID in (SELECT DOKART_ID FROM DD_ECM.dbo.TBDD_DOKUMENTART_MODULE WHERE MODULE_ID = (SELECT GUID FROM DD_ECM.dbo.TBDD_MODULES WHERE UPPER(SHORT_NAME) = ('GLOBIX')))
GO
Reference in New Issue View Git Blame Copy Permalink