--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

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');
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
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
	,[ATTR_ID]
	,T6.TERM_VALUE AS ATTR_TITLE
	,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.0.1')
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
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_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_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 PROCEDURE PRIDB_SEARCH_AUTOSUGGEST @pLANGCODE VARCHAR(5),@pUSRID INT
AS
DECLARE @TBRESULT TABLE(TERM VARCHAR(900))
INSERT INTO @TBRESULT (TERM)
select DISTINCT TERM.TERM_VALUE
	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
	WHERE 
	OBJ.ACTIVE = 1 AND LANG.LANG_CODE = @pLANGCODE;
INSERT INTO @TBRESULT (TERM)
select Doctype FROM VWIDB_DOC_DOCTYPE where LANG_CODE = @pLANGCODE;
SELECT * FROM @TBRESULT;
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

ALTER TABLE [dbo].[TBIDB_LANGUAGE_TERM_METADATA] CHECK CONSTRAINT [FK_TBIDB_LTMD_LANG_TERM_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öschter Wert],
	T.DELETED_WHO [Gelöscht wer],
	T.DELETED_WHEN [Gelö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ändert wer],
	T.CHANGED_WHEN [Geä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ändert wann] as LAST_CHANGE
FROM
	VWIDB_VALUE_TEXT where [Geändert wann] IS NOT NULL
UNION
SELECT TOP 100 PERCENT 
	*, [ADDED_WHEN] as LAST_CHANGE
FROM 
	VWIDB_VALUE_TEXT where [Geä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ändert wer],
	T.CHANGED_WHEN [Geä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ändert', 'de-DE', 'SYSTEM';
EXEC PRIDB_SET_IDB_STATE_LANG 'File deleted','Datei gelöscht', 'de-DE', 'SYSTEM';
EXEC PRIDB_SET_IDB_STATE_LANG 'Metadata changed','Attributwert geändert', 'de-DE', 'SYSTEM';
EXEC PRIDB_SET_IDB_STATE_LANG 'Attributevalue deleted','Attributwert gelöscht', 'de-DE', 'SYSTEM';
EXEC PRIDB_SET_IDB_STATE_LANG 'File opened','Datei geö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 OR ALTER 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

	EXEC PRIDB_NEW_TERM 'VARCHAR',@WHO,@WHO,@TERM_ID = @WHO_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 GUID FROM TBIDB_ATTRIBUTE WHERE TITLE = @ATTRIBUTE)
		BEGIN
			DECLARE @MSG VARCHAR(100)
			SET @MSG = 'NO VALID ATTRIBUTE [' + @ATTRIBUTE + ']'
			RAISERROR (@MSG,16,1)
		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)
	PRINT @TYP_DESCR
	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);
						END
					ELSE
						BEGIN
							PRINT 'UPDATE LANGUAGE-TERM...'
							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;
						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
		AND SYS_ATTRIBUTE = 0
		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),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) VALUES ('OriginFileName',1,1);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE) VALUES ('OriginCreationDatetime',6,1);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE) VALUES ('OriginChangedDatetime',6,1);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE) VALUES ('DisplayFileName',1,1);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE) VALUES ('DisplayFileName1',1,1);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE) VALUES ('Dynamic Folder',1,1);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE) VALUES ('EmailMessageID',1,1);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE) VALUES ('EmailSubject',1,1);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE) VALUES ('EmailFrom',1,1);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE) VALUES ('EmailDate',5,1);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE,MULTI_CONTEXT) VALUES ('PM-LOGGING',8,0,1);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE) VALUES ('VIRTUAL_FOLDER',1,1);
INSERT INTO TBIDB_ATTRIBUTE (TITLE,TYP_ID,SYS_ATTRIBUTE) VALUES ('VIRTUAL_FOLDER_PART',1,1);
--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 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