#wip: ORM building.

.gitignore

@@ -8,3 +8,6 @@
 __pycache__
 .sass-cache
 /Public/fonts/FontAwesome-6.7.2
+/Dockers/SQLServer/data
+/Dockers/SQLServer/scripts
+/Dockers/SQLServer/temporary

Dockers/SQLServer/Dockerfile

@@ -0,0 +1,5 @@
+from mcr.microsoft.com/mssql/server:2022-latest
+expose 1433/tcp
+user root
+env ACCEPT_EULA=Y
+# env MSSQL_SA_PASSWORD=Abc123.. # Incompatible with lastest Docker versions.

Dockers/SQLServer/rebuild.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+directory=`dirname $(readlink -f "$0")`
+[ "$(docker images -q anp:sql-server 2>/dev/null)" ] && docker image remove anp:sql-server --force
+docker build -f $directory/Dockerfile -t anp:sql-server $directory --no-cache

Files/ORM/SQLServer/entity.historical.server.sql

@@ -0,0 +1,101 @@
+use DATABASE
+
+-- [[sql_server_entity_historical_creator]] --
+
+if object_id(N'dbo.snake_tables_drop', N'P') is not null drop procedure dbo.snake_tables_drop
+go
+create procedure dbo.snake_tables_drop as begin set nocount on 
+
+    if object_id(N'dbo._Pascal') is not null drop table dbo._Pascal
+    if object_id(N'dbo.Pascal') is not null drop table dbo.Pascal
+
+end
+go
+
+if object_id(N'dbo.snake_tables_create', N'P') is not null drop procedure dbo.snake_tables_create
+go
+create procedure dbo.snake_tables_create as begin set nocount on 
+
+    if object_id(N'dbo.Pascal', N'U') is null create table dbo.Pascal(
+        id integer not null identity(1, 1), 
+        [procedure] integer not null, 
+        [session] integer not null, -- attributes_definition --
+        date_in datetime not null constraint df_snake_date_in default getdate(),
+        date_out datetime, 
+        constraint pk_snake primary key clustered(id), 
+        constraint fk_snake_procedure foreign key([procedure]) references AnPDB.dbo.Procedures(id)
+            on update no action 
+            on delete no action, 
+        constraint fk_snake_session foreign key([session]) references AnPDB.dbo.Sessions(id) 
+            on update no action 
+            on delete no action -- contrains_definition --
+    )
+
+    if object_id(N'dbo._Pascal', N'U') is null create table dbo._Pascal(
+        id integer not null identity(1, 1), 
+        entity integer not null, 
+        history_mode integer not null, 
+        [procedure] integer not null, 
+        [session] integer not null, -- attributes_history_definition --
+        date_in datetime not null,
+        date_out datetime, 
+        history_date datetime2 not null constraint df__snake_history_date default sysutcdatetime(),
+        constraint pk__snake primary key clustered(id), 
+        constraint fk__snake_history_mode foreign key(history_mode) references HistoryModes.dbo.HistoryModes(id)
+            on update no action 
+            on delete no action, 
+        constraint fk__snake_procedure foreign key([procedure]) references AnPDB.dbo.Procedures(id)
+            on update no action 
+            on delete no action, 
+        constraint fk__snake_session foreign key([session]) references AnPDB.dbo.Sessions(id) 
+            on update no action 
+            on delete no action -- contrains_history_definition --
+    )
+
+end
+go
+
+if object_id(N'dbo.snake_tables_update', N'P') is not null drop procedure dbo.snake_tables_update
+go
+create procedure dbo.snake_tables_update as begin set nocount on -- attributes_update --
+
+end
+go
+
+if object_id(N'dbo.snake_trigger', N'TR') is not null drop trigger dbo.snake_trigger
+go
+create trigger dbo.snake_trigger on dbo.Pascal for insert, update, delete as begin set nocount on 
+
+    declare @insert integer, @update integer, @delete integer, @unknown integer
+
+    execute AnPDB.dbo.history_mode_get @insert output, @update output, @delete output, @unknown output
+
+    -- update.
+    insert into dbo._Pascal(history_mode, entity, [procedure], [session], /* attributes */, date_in, date_out) 
+    select @update, inserted.id, inserted.[procedure], inserted.[session], /* attributes_insert */, inserted.date_in, inserted.date_out 
+    from inserted inserted 
+    join deleted deleted on inserted.id = deleted.id 
+    where 
+        inserted.[procedure] != deleted.[procedure] or 
+        inserted.[session] != deleted.[session] or -- attributes_where_diferent --
+        inserted.date_in != deleted.date_in or 
+        isnull(inserted.date_out, '0001-01-01') != isnull(deleted.date_out, '0001-01-01')
+
+    -- Insert.
+    insert into dbo._Pascal(history_mode, entity, [procedure], [session], /* attributes */, date_in, date_out) 
+    select @insert, inserted.id, inserted.[procedure], inserted.[session], /* attributes_insert */, inserted.date_in, inserted.date_out 
+    from inserted inserted 
+    left join deleted deleted on inserted.id = deleted.id 
+    where deleted.id is null
+
+    -- deleted.
+    insert into dbo._Pascal(history_mode, entity, [procedure], [session], /* attributes */, date_in, date_out) 
+    select @delete, deleted.id, deleted.[procedure], deleted.[session], /* attributes_delete */, deleted.date_in, deleted.date_out 
+    from deleted deleted 
+    left join inserted inserted on deleted.id = inserted.id 
+    where inserted.id is null
+
+end
+go
+
+-- [[sql_server_entity_historical_creator]] --

Public/ecma/Application/Components.ecma.js

@@ -324,6 +324,7 @@ export const Components = (function(){
                     ...self.set_attributes([
                         ["id", "identifier"], 
                         ["maxlength", "maximum_length"], 
+                        "required", 
                         "pattern", 
                         "value"
                     ], inputs)
@@ -336,6 +337,7 @@ export const Components = (function(){
                     ...self.set_attributes([
                         ["id", "identifier"], 
                         ["maxlength", "maximum_length"], 
+                        "required", 
                         "pattern", 
                         "value"
                     ], inputs)
@@ -364,6 +366,7 @@ export const Components = (function(){
                   maximum_length = Common.get_value("maximum_length", inputs, null);
 
             return Span({
+                class : "input input-password",
                 data_i18n : name, 
                 data_i18n_without : true,
                 title : text
@@ -377,6 +380,7 @@ export const Components = (function(){
                     ...self.set_attributes([
                         ["id", "identifier"], 
                         ["maxlength", "maximum_length"], 
+                        "required", 
                         "pattern", 
                         "value"
                     ], inputs)
@@ -401,6 +405,7 @@ export const Components = (function(){
             const text = anp.i18n.get(name);
 
             return Span({
+                class : "input input-email",
                 data_i18n : name, 
                 data_i18n_without : true,
                 title : text
@@ -411,7 +416,12 @@ export const Components = (function(){
                     data_i18n : name, 
                     data_i18n_without : true, 
                     placeholder : text + "...", 
-                    pattern : "[a-z0-9._%+-]+@[a-z0-9.-]+\\.[a-z]{2,}$"
+                    pattern : "[a-z0-9._%+-]+@[a-z0-9.-]+\\.[a-z]{2,}$", 
+                    ...self.set_attributes([
+                        ["id", "identifier"], 
+                        "required", 
+                        "value"
+                    ], inputs)
                 })
             ]);
         };
@@ -434,6 +444,7 @@ export const Components = (function(){
                   value = Common.get_value("value", inputs, null);
 
             return Span({
+                class : "input input-number",
                 data_i18n : name, 
                 data_i18n_without : true,
                 title : text
@@ -449,6 +460,7 @@ export const Components = (function(){
                         ["min", "minimum"], 
                         ["max", "maximum"], 
                         "step", 
+                        "required", 
                         "value"
                     ], inputs)
                 }), 

Public/ecma/Components/FormsComponent.ecma.js

@@ -1,6 +1,8 @@
 "use strict";
 
-import {Fieldset, Div, Form, UL} from "../Utils/HTMLDSL.ecma.js";
+import {Common} from "../Utils/Common.ecma.js";
+import {Check} from "../Utils/Checks.ecma.js";
+import {Fieldset, Div, Form, UL, Label, Span} from "../Utils/HTMLDSL.ecma.js";
 
 /**
  * @class FormsComponent
@@ -45,18 +47,23 @@ export const FormsComponent = (function(){
         };
 
         /**
-         * @param {string} name
          * @param {!(Object.<string, any|null>|Array.<any|null>)} inputs 
          * @return {Array.<any|null>}
          * @access public
          */
-        this.build = (name, inputs) => {
+        this.build = inputs => {
 
             /** @type {form_submit_callback|null} */
-            const submit = Common.get_value("submit", inputs, null);
+            const submit = Common.get_value("submit", inputs, null), 
+                  /** @type {string} */
+                  name = Common.get_value("name", inputs), 
+                  /** @type {string|null} */
+                  view = Common.get_value("view", inputs, null);
 
             return Form({
+                class : "form-component", 
                 data_name : name,
+                ...(view ? {data_view : view} : {}), 
                 method : Common.get_value("method", inputs, "post"),
                 action : Common.get_value("action", inputs, "#"), 
                 ...(submit ? {on_submit : submit} : {})
@@ -64,10 +71,10 @@ export const FormsComponent = (function(){
                 Fieldset({class : "form"}, [
                     anp.components.i18n(name, "legend"), 
                     anp.components.i18n(name + "_description", "p"),
-                    Div({class : "form-fields"}, Common.get_value("structure", inputs, []).map(([type, name, ...inputs], i) => {
+                    Div({class : "form-fields"}, Common.get_value("structure", inputs, []).map(([name, type, ...inputs], i) => {
 
                         /** @type {string} */
-                        let id = anp.unique_keys.create(true), 
+                        let id = anp.unique_keys.get(true), 
                             /** @type {number} */
                             l = inputs.length - 1;
 
@@ -98,8 +105,8 @@ export const FormsComponent = (function(){
                     })), 
                     UL({class : "global-errors"}), 
                     Div({class : "buttons"}, Common.get_value(["actions", "buttons"], inputs, []).concat(
-                        anp.components.button(Common.get_value("submit_reset", inputs, "reset"), "reset"), 
-                        submit ? anp.components.button(Common.get_value("submit_name", inputs, "submit"), "submit") : null
+                        [anp.components.button(Common.get_value("submit_reset", inputs, "clean"), "reset")], 
+                        submit ? [anp.components.button(Common.get_value("submit_name", inputs, "submit"), "submit")] : []
                     ))
                 ])
             ]);

Public/ecma/Managers/ViewsManager.ecma.js

@@ -137,7 +137,7 @@ export const ViewsManager = (function(){
          */
         this.get = (key, inputs = null) => {
             if(views[key] && views[key].type && anp.components[views[key].type])
-                return anp.components[views[key].type]([views[key], inputs]);
+                return anp.components[views[key].type]([views[key], {view : key}, inputs]);
             return anp.components.http_error(502);
         };
 

Public/ecma/Utils/Checks.ecma.js

@@ -20,6 +20,14 @@ export const Check = (function(){
      */
     const Check = function(){};
 
+    /**
+     * @param {?any} item 
+     * @returns {boolean}
+     * @access public
+     * @static
+     */
+    Check.is_null_or_undefined = item => item === undefined || item === null;
+
     /**
      * @param {?any} item 
      * @returns {boolean}
@@ -68,6 +76,22 @@ export const Check = (function(){
      */
     Check.is_function = item => typeof item == "function";
 
+    /**
+     * @param {?any} item 
+     * @returns {boolean}
+     * @access public
+     * @static
+     */
+    Check.is_number = item => typeof item == "number";
+
+    /**
+     * @param {?any} item 
+     * @returns {boolean}
+     * @access public
+     * @static
+     */
+    Check.is_integer = item => Check.is_number(item) && item >> 0 == item;
+
     /**
      * @param {?any} item 
      * @returns {boolean}

Public/ecma/Utils/ErrorsManager.ecma.js

@@ -0,0 +1,639 @@
+"use strict";
+
+import {Check} from "./Checks.ecma.js";
+import {Common} from "./Common.ecma.js";
+
+/**
+ * @class ErrorsManager
+ * @constructor
+ * @param {?(Object.<string, any|null>|Array.<any|null>|string)} [inputs = null] 
+ * @returns {void}
+ * @access public
+ * @static
+ */
+export const ErrorsManager = (function(){
+
+    /**
+     * @constructs ErrorsManager
+     * @param {?(Object.<string, any|null>|Array.<any|null>|string)} [inputs = null] 
+     * @returns {void}
+     * @access private
+     * @static
+     */
+    const ErrorsManager = function(inputs = null){
+
+        /** @type {ErrorsManager} */
+        const self = this, 
+              /** @type {Array.<string>} */
+              alphabet = [], 
+              /** @type {Object.<string, number>} */
+              dictionary = {};
+        /** @type {number} */
+        let error = 0, 
+            /** @type {number} */
+            base, 
+            /** @type {number} */
+            power;
+
+        /**
+         * @returns {void}
+         * @access private
+         */
+        const constructor = () => {
+
+            self.set_alphabet(
+                Common.get_value("alphabet", inputs, ErrorsManager.ALPHABET), 
+                Common.get_value("base", inputs, 64)
+            );
+
+        };
+
+        /**
+         * @param {?(string|Array.<string>)} [new_alphabet = null] 
+         * @param {!number} [new_base = 64] 
+         * @returns {number}
+         * @access public
+         */
+        this.set_alphabet = (new_alphabet = null, new_base = 64) => {
+
+            /** @type {number} */
+            let original_length;
+
+            error = 0;
+            // alphabet.splice(0, alphabet.length);
+            alphabet.length = 0;
+
+            if(Check.is_null_or_undefined(new_alphabet))
+                alphabet.push(...ErrorsManager.ALPHABET);
+            else if(Check.is_string(new_alphabet))
+                alphabet.push(...new_alphabet.split(""));
+            else if(Check.is_array(new_alphabet))
+                alphabet.push(...new_alphabet);
+            else{
+                error |= 1 << 2;
+                alphabet.push(...ErrorsManager.ALPHABET);
+            };
+
+            original_length = alphabet.length;
+
+            for(let i = alphabet.length - 1; i >= 0; i--)
+                alphabet.indexOf(alphabet[i]) != i && alphabet.splice(i, 1);
+
+            if(alphabet.length < 2){
+                error |= 1 << 3;
+                alphabet.splice(0, alphabet.length);
+                alphabet.push(...ErrorsManager.ALPHABET);
+            };
+            if(alphabet.length != original_length)
+                error |= 1 << 4;
+            if(alphabet.length > 128)
+                error |= 1 << 5;
+
+            error |= (
+                new_base < 2 ? 1 << 0 : 
+                new_base > 128 ? 1 << 1 :
+                new_base >= alphabet.length ? 1 << 2 : 
+            0) << 6;
+
+            if(!(error >> 6))
+                alphabet.splice(new_base, alphabet.length - new_base);
+
+            alphabet.splice(base = 2 ** (power = Math.log2(alphabet.slice(0, 128).length) >> 0));
+
+            for(const key in dictionary)
+                delete dictionary[key];
+
+            for(let i = alphabet.length - 1; i >= 0; i--)
+                dictionary[alphabet[i]] = i;
+
+            return error;
+        };
+
+        /**
+         * @returns {string}
+         * @access public
+         */
+        this.get_alphabet = () => alphabet.join("");
+
+        /**
+         * @param {!(string|Array.<number>|number)} code
+         * @return {Array.<number>}
+         * @access public
+         */
+        this.to_array = code => {
+            if(Check.is_string(code))
+                return code.split("").map(character => dictionary[character]);
+            if(Check.is_array(code))
+                return code;
+            if(Check.is_integer(code)){
+            
+                /** @type {Array.<number>} */
+                const hexas = [];
+
+                while(code){
+                    hexas.push(code % base);
+                    code = code / base >> 0;
+                };
+
+                return hexas;
+            };
+            return [];
+        };
+
+        /**
+         * @param {!(string|Array.<number>|number)} code
+         * @return {string}
+         * @access public
+         */
+        this.to_string = code => {
+            if(Check.is_string(code))
+                return code;
+            if(Check.is_array(code))
+                return code.map(number => alphabet[number]).join("");
+            if(Check.is_integer(code)){
+            
+                /** @type {string} */
+                let string = "";
+
+                while(code){
+                    string += alphabet[code % base];
+                    code = code / base >> 0;
+                };
+
+                return string;
+            };
+            return "";
+        };
+
+        /**
+         * @param {!(string|Array.<number>|number)} code
+         * @return {number}
+         * @access public
+         */
+        this.to_integer = code => {
+            if(Check.is_string(code))
+                return code.split("").reduce((integer, character) => integer * base + dictionary[character], 0);
+            if(Check.is_array(code))
+                return code.reduce((integer, number) => integer * base + number, 0);
+            if(Check.is_integer(code))
+                return code;
+            return 0;
+        };
+
+        /**
+         * @param {!(string|Array.<number>|number)} code
+         * @return {string}
+         * @access public
+         */
+        this.to_string_binary = code => {
+            if(Check.is_string(code))
+                return code.split("").map(character => dictionary[character].toString(2).padStart(power, "0")).join("");
+            if(Check.is_array(code))
+                return code.map(number => number.toString(2).padStart(power, "0")).join("");
+            if(Check.is_integer(code)){
+            
+                /** @type {string} */
+                let string = "";
+
+                while(code){
+                    string = (code % base).toString(2).padStart(power, "0") + string;
+                    code = code / base >> 0;
+                };
+
+                return string;
+            };
+            return "";
+        };
+
+        /**
+         * @param {!(string|Array.<number>|number)} code
+         * @return {number}
+         * @access public
+         */
+        this.get_bits = code => {
+            if(Check.is_string(code))
+                return (code.length - 1) * power + Math.ceil(Math.log2(dictionary[code[code.length - 1]] + 1));
+            if(Check.is_array(code))
+                return (code.length - 1) * power + Math.ceil(Math.log2(code[code.length - 1] + 1));
+            if(Check.is_integer(code))
+                return Math.ceil(Math.log2(code + 1));
+            return 0;
+        };
+
+        /**
+         * @param {!Array.<number>} code 
+         * @param {!number} from 
+         * @param {!number} bits 
+         * @returns {![number, number]}
+         * @access private
+         */
+        const get_from_bits_array = (code, from, bits) => {
+
+            if(from < 0){
+                from = self.get_bits(code) + from;
+                if(from < 0)
+                    from = 0;
+            };
+            if(bits < 0){
+                from += bits;
+                bits *= -1;
+                if(from < 0){
+                    bits += from;
+                    from = 0;
+                };
+            };
+
+            return [from, bits];
+        };
+
+        /**
+         * @param {!(string|Array.<number>|number)} code 
+         * @param {!number} from 
+         * @param {!number} bits 
+         * @returns {![number, number]}
+         * @access public
+         */
+        this.get_from_bits = (code, from, bits) => (
+            Check.is_string(code) ? get_from_bits_array(code.split("").map(character => dictionary[character]), from, bits) : 
+            Check.is_array(code) ? get_from_bits_array(code, from, bits) : 
+            Check.is_integer(code) ? get_from_bits_array(self.to_array(code), from, bits) : 
+        [from, bits]);
+
+        /**
+         * @param {!(string|Array.<number>|number)} code 
+         * @returns {string|Array.<number>|number|null}
+         * @access public
+         */
+        this.clean = code => {
+            if(Check.is_string(code)){
+
+                /** @type {number} */
+                let l = code.length;
+
+                for(; l > 0 && code[l - 1] == alphabet[0]; l --);
+
+                return (
+                    l == code.length ? code : 
+                    !l ? alphabet[0] : 
+                code.slice(0, l));
+            };
+            if(Check.is_array(code)){
+
+                /** @type {number} */
+                let l = code.length;
+
+                for(; l > 0 && code[l - 1] == 0; l --);
+
+                return (
+                    l == code.length ? code : 
+                    !l ? [0] : 
+                code.slice(0, l));
+            };
+            if(Check.is_integer(code))
+                return code;
+            return null;
+        };
+
+        /**
+         * @param {!(string|Array.<number>|number)} code 
+         * @param {!number} from 
+         * @param {!number} bits 
+         * @returns {!(string|Array.<number>|number|null)}
+         * @access public
+         */
+        this.get_range = (code, from, bits) => {
+            if(Check.is_array(code)){
+
+                /** @type {Array.<number>} */
+                const hexas = [];
+
+                [from, bits] = self.get_from_bits(code, from, bits);
+
+                if(bits == 0)
+                    bits = self.get_bits(code) - from;
+                if(bits <= 0)
+                    return [0];
+
+                hexas.push(...code);
+
+                if(from > 0){
+
+                    /** @type {number} */
+                    const shift = from % power,
+                          /** @type {number} */
+                          mask = ~-base;
+
+                    hexas = hexas.slice(from / power >> 0);
+                    if(shift != 0 && hexas.length){
+
+                        /** @type {number} */
+                        const l = hexas.length - 1;
+
+                        for(let i = 0; i < l; i ++)
+                            hexas[i] = ((hexas[i] >> shift) | (hexas[i + 1] << power - shift)) & mask;
+                        hexas[l] >>= shift;
+
+                    };
+
+                }
+                if(bits > 0){
+
+                    /** @type {number} */
+                    const shift = bits % power, 
+                          /** @type {number} */
+                          l = Math.ceil(bits / power);
+
+                    hexas = hexas.slice(l, hexas.length - l);
+                    if(shift && hexas.length)
+                        hexas[hexas.length - 1] &= ~(-1 << shift);
+
+                };
+
+                return self.clean(hexas);
+            };
+            if(Check.is_string(code))
+                return self.to_string(self.get_range(self.to_array(code), from, bits));
+            if(Check.is_integer(code)){
+
+                [from, bits] = self.get_from_bits(code, from, bits);
+
+                from > 0 && (code = (code >> from) & ~-(1 << 31 - from));
+
+                if(bits <= 0 || bits >= 31)
+                    return code;
+
+                from + bits > 31 && (bits = 31 - from);
+
+                return code & ~-(1 << bits);
+            };
+            return null;
+        };
+
+        /**
+         * @param {!(string|Array.<string>|number)} code 
+         * @param {!Array.<string>} messages 
+         * @param {?Object.<number, number>} [blocks = null] 
+         * @returns {Array.<[number, string]>}
+         * @access public
+         */
+        this.process = (code, messages, blocks = null) => {
+
+            /** @type {Array.<[number, string]>} */
+            const response = [], 
+                  /** @type {number} */
+                  l = (code = self.to_array(code)).length;
+            /** @type {number} */
+            let k = 0;
+
+            blocks || (blocks = {});
+
+            for(let i = 0; i < l;)
+                if(blocks[i] !== undefined){
+
+                    /** @type {number} */
+                    const logarithm = Math.log2(blocks[i]) >> 0;
+                    /** @type {number} */
+                    let _k = self.to_integer(self.get_range(code, i, logarithm ? logarithm : logarithm = 1));
+
+                    if(_k > 0){
+                        _k = k + _k;
+                        response.push([k, messages[k] || "error_message_" + k]);
+                    };
+
+                    k += blocks[i];
+                    i += logarithm;
+
+                }else{
+                    code[i / power >> 0] & (1 << i % power) && response.push([k, messages[k] || "error_message_" + k]);
+                    k ++;
+                    i ++;
+                };
+
+            return response;
+        };
+
+        /**
+         * @param {!(string|Array.<number>|number)} code 
+         * @param {!number} bits 
+         * @return {string|Array.<number>|number|null}
+         * @access public
+         */
+        this.bitwise = (code, bits) => {
+            if(Check.is_array(code)){
+                if(!code.length || !bits)
+                    return code;
+
+                /** @type {number} */
+                const shift = Math.abs(bits) % power,
+                      /** @type {number} */
+                      mask = ~-base, 
+                      /** @type {Array.<number>} */
+                      hexas = [...code];
+
+                if(bits < 0){
+
+                    hexas.splice(0, -bits / power >> 0);
+
+                    if(shift != 0 && hexas.length){
+
+                        /** @type {number} */
+                        const l = hexas.length - 1;
+
+                        for(let i = 0; i < l; i ++)
+                            hexas[i] = (hexas[i] >> shift | (hexas[i + 1] << power - shift)) & mask;
+                        hexas[l] >>= shift;
+
+                    };
+
+                }else{
+
+                    if(shift != 0){
+
+                        /** @type {number} */
+                        const last_hexa = hexas[hexas.length - 1] << shift;
+
+                        for(let i = hexas.length - 1; i > 0; i --)
+                            hexas[i] = ((hexas[i] << shift) | (hexas[i - 1] >> power - shift)) & mask;
+                        hexas[0] = (hexas[0] << shift) & mask;
+                        
+                        if(last_hexa)
+                            hexas.push(last_hexa);
+
+                    };
+
+                    for(let i = bits / power >> 0; i > 0; i --)
+                        hexas.unshift(0);
+
+                };
+
+                return self.clean(hexas);
+            };
+            if(Check.is_string(code))
+                return self.to_string(self.bitwise(self.to_array(code), bits));
+            if(Check.is_integer(code)){};
+            return null;
+        };
+
+        /**
+         * @param {!(string|Array.<number>|number)} code 
+         * @param {!number} from 
+         * @param {!number} bits 
+         * @param {!boolean} reversed 
+         * @returns {!(string|Array.<number>|number|null)} 
+         * @access public
+         */
+        this.reset = (code, from, bits = 0, reversed = false) => {
+            if(Check.is_array(code)){
+
+                /** @type {Array.<number>} */
+                const hexas = [...code];
+                /** @type {[number, number, number]} */
+                let l, from_mask, to_mask;
+
+                [from, bits] = self.get_from_bits(hexas, from, bits);
+
+                /** @type {number} */
+                const hexa_from = from / power >> 0, 
+                      /** @type {number} */
+                      hexas_to = Math.ceil((from + bits) / power);
+
+                if(reversed){
+
+                    l = from % power;
+                    from_mask = ~-(1 << power) << l;
+                    to_mask = ~-(1 << (from + bits) % power);
+
+                    for(let i = 0, l = hexas.length; i < l; i ++)
+                        if(i < hexa_from || i > hexas_to)
+                            hexas[i] = 0;
+
+                    if(hexa_from == hexa_to)
+                        hexas[hexa_to] &= from_mask | to_mask;
+                    else{
+                        hexas[hexa_from] &= from_mask;
+                        if(hexa_to < hexas.length)
+                            hexas[hexa_to] &= to_mask;
+                    };
+
+                }else{
+
+                    l = (from + bits) % power;
+                    from_mask = ~-(1 << from % power);
+                    to_mask = ~-(1 << l) << l;
+
+                    if(hexa_from == hexa_to)
+                        hexas[hexa_to] &= from_mask | to_mask;
+                    else{
+                        hexas[hexa_from] &= from_mask;
+                        for(let i = hexa_from + 1; i < hexas_to && i < hexas.length; i ++)
+                            hexas[i] = 0;
+                        if(hexa_to < hexas.length)
+                            hexas[hexa_to] &= to_mask;
+                    };
+
+                };
+
+                return self.clean(hexas);
+            };
+            if(Check.is_string(code))
+                return self.to_string(self.reset(self.to_array(code), from, bits, reversed));
+            if(Check.is_integer(code)){
+
+                [from, bits] = self.get_from_bits(code, from, bits);
+                from + bits > 31 && (bits = 31 - from);
+
+                return code & (
+                    reversed ? ~-(1 << bits) << from : 
+                (~-(1 << self.get_bits(code)) << from + bits) | ~-(1 << from));
+            };
+            return null;
+        };
+
+        /**
+         * @param {!(string|Array.<number>|number)} code 
+         * @param {!number} from 
+         * @param {!number} bits 
+         * @return {boolean|null}
+         * @access public
+         */
+        this.has = (code, from = 0, bits = 0) => (
+            Check.is_string(code) ? self.get_range(code, from, bits).split("").some(character => character != alphabet[0]) : 
+            Check.is_array(code) ? self.get_range(code, from, bits).some(number => number != 0) : 
+            Check.is_integer(code) ? !!self.get_range(code, from, bits) : 
+        null);
+
+        /**
+         * @param {!(string|Array.<number>|number)} error 
+         * @param {!(string|Array.<number>|number)} code 
+         * @param {!number} from 
+         * @param {!number} bits 
+         * @return {string|Array.<number>|number|null}
+         * @access public
+         */
+        this.set = (error, code, from = 0, bits = 0) => {
+            if(Check.is_array(code)){
+
+                let l, 
+                    m = error.length, 
+                    n = code.length;
+                const results = [];
+
+                bits && (m = (error = self.reset(error, from, bits)).length);
+                from && (n = (code = self.bitwise(code, from)).length);
+                l = m > n ? m : n;
+
+                for(let i = 0; i < l; i ++)
+                    results.push(
+                        (i < m ? error[i] : 0) | 
+                        (i < n ? code[i] : 0)
+                    );
+
+                return self.clean(results);
+            };
+            if(Check.is_string(code))
+                return self.to_string(self.set(self.to_array(error), self.to_array(code), from, bits));
+            if(Check.is_integer(code)){
+
+                bits && (error = self.reset(error, from, bits));
+                from && (code = self.bitwise(code, from));
+
+                return error | code;
+            };
+            return null;
+        };
+
+        constructor();
+
+    };
+
+    /** @type {Array.<string>} */
+    ErrorsManager.ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".split("");
+
+    /** @type {Array.<string>} */
+    ErrorsManager.ERRORS_MESSAGES = [
+        "invalid_alphabet",
+        "invalid_base",
+        "invalid_alphabet_type",
+        "too_short_alphabet",
+        "repeated_characters_in_alphabet",
+        "too_long_alphabet",
+        "base_lower_than_2",
+        "base_greater_than_128",
+        "base_greater_than_alphabet"
+    ];
+
+    /** @type {RegExp} */
+    ErrorsManager.RE_KEY = /^[a-z_][a-z0-9_]*$/i;
+
+    /**
+     * @param {!(string|Array.<any|null>)} items 
+     * @returns {string|Array.<any|null>}
+     * @access public
+     * @static
+     */
+    ErrorsManager.unique = items => (
+        ErrorsManager.is_array(items) ? items.filter((item, i) => items.indexOf(item) == i) : 
+    items.split("").filter((item, i) => items.indexOf(item) == i).join(""));
+
+    return ErrorsManager;
+})();

Public/json/AnP.routes.json

@@ -1,3 +1,5 @@
 [
-    "/ai ai"
+    "/ai ai", 
+    "/register sessions_register",
+    "/login sessions_login"
 ]

Public/json/i18n/AnP.i18n.espanol.json

@@ -4,9 +4,6 @@
         "git" : "Git", 
         "user" : "Usuario", 
         "ip" : "IP", 
-        "login" : "Acceder", 
-        "logout" : "Salir",
-        "register" : "Registrarse",
         "copyright" : "© Copyright {years} {authors}", 
         "cc_by_nc_sa_4" : "CC-BY-NC-SA-4.0: Creative Commons de Atribución, No Comercial y Permitido el Compartir, versión 4.0.", 
         "zoom" : "Zoom", 
@@ -33,6 +30,26 @@
         "minimum" : "Mínimo", 
         "maximum" : "Máximo", 
         "ai" : "IA", 
-        "anpbot" : "AnPBot"
+        "anpbot" : "AnPBot", 
+        "clean" : "Limpiar", 
+        "submit" : "Enviar", 
+
+        "AnP_Sessions_start" : null, 
+        "login" : "Acceder", 
+        "login_description" : "Para acceder con tu perfil, por favor, rellene el siguiente formulario.", 
+        "username" : "Nick", 
+        "username_description" : "Nombre de usuario con el que te identificas en la plataforma.",
+        "password" : "Contraseña",
+        "password_description" : "Contraseña de acceso a la plataforma.",
+        "confirm_password" : "Confirmar contraseña",
+        "confirm_password_description" : "Vuelva a escribir la contraseña para confirmar que es correcta.",
+        "email" : "Correo electrónico",
+        "email_description" : "Dirección de correo electrónico para poder ponernos en contacto con usted.",
+        "register" : "Registrarse",
+        "register_description" : "Para registrarse en la plataforma, por favor, rellene el siguiente formulario.",
+        "logout" : "Salir",
+        "logout_description" : "Para confirmar que realmente quiere salir de la sesión actual, por favor, Clicke en el botón 'Enviar'.",
+        "AnP_Sessions_end" : null
+
     }
 }

Public/json/views/AnP.views.sessions.json

@@ -1,25 +1,28 @@
 {
-    "login" : {
+    "sessions_login" : {
         "type" : "form", 
+        "name" : "login", 
         "submit" : "login@sessions", 
         "structure" : [
-            ["username", "text"], 
-            ["password", "password"]
+            ["username", "text", {"required" : true, "minimum_length" : 1, "maximum_length" : 32, "pattern" : "^[a-zA-Z_][a-zA-Z0-9_]{0,31}$"}], 
+            ["password", "password", {"required" : true, "minimum_length" : 1, "maximum_length" : 32}]
         ]
     }, 
-    "unloggin" : {
+    "sessions_logout" : {
         "type" : "form", 
+        "name" : "logout", 
         "submit" : "logout@sessions", 
         "structure" : []
     }, 
-    "register" : {
+    "sessions_register" : {
         "type" : "form", 
+        "name" : "register", 
         "submit" : "register@sessions", 
         "structure" : [
-            ["username", "text"], 
-            ["password", "password"], 
-            ["confirm_password", "password"], 
-            ["email", "email"]
+            ["username", "text", {"required" : true, "minimum_length" : 1, "maximum_length" : 32, "pattern" : "^[a-zA-Z_][a-zA-Z0-9_]{0,31}$"}], 
+            ["password", "password", {"required" : true, "minimum_length" : 1, "maximum_length" : 32}], 
+            ["confirm_password", "password", {"required" : true, "minimum_length" : 1, "maximum_length" : 32}], 
+            ["email", "email", {"required" : true}]
         ]
     }
 }

Public/scss/AnP.css

@@ -1022,17 +1022,33 @@
   position: relative;
   width: 100%;
   min-width: 0%;
+  box-sizing: border-box;
 }
 .anp .input > textarea {
-  width: 100%;
   height: 5em;
-  min-width: 0%;
   min-height: 0%;
   resize: none;
 }
+.anp .input > textarea, .anp .input > [type=text], .anp .input > [type=password], .anp .input > [type=email], .anp .input > [type=number] {
+  width: 100%;
+  min-width: 0%;
+  border: 0.1em solid #2272D4;
+  border-radius: 0.3em;
+  background-color: #EFEFEF;
+  box-sizing: border-box;
+  transition-duration: 1s;
+  transition-property: border-color, box-shadow;
+  box-shadow: 0em 0em 0.2em inset #2272D4;
+}
+.anp .input > textarea:focus, .anp .input > [type=text]:focus, .anp .input > [type=password]:focus, .anp .input > [type=email]:focus, .anp .input > [type=number]:focus {
+  outline: none;
+  border-color: #D47222;
+  transition-duration: 0.35s;
+  box-shadow: 0em 0em 0.2em inset #D47222;
+}
 .anp .input .information {
   position: absolute;
-  bottom: 0em;
+  bottom: -0.2em;
   right: 0em;
   font-size: 0.8em;
   color: rgb(136.5, 136.5, 136.5);
@@ -1221,6 +1237,48 @@
   height: 1em;
   margin-right: 0.3em;
 }
+.anp .form-component fieldset {
+  margin: 0em;
+  padding: 0em;
+  border: none;
+}
+.anp .form-component legend {
+  font-size: 1.2em;
+  font-weight: 900;
+}
+.anp .form-component .form-fields {
+  display: table;
+  margin: 1em 2em;
+}
+.anp .form-component .form-fields > div {
+  display: table-row;
+}
+.anp .form-component .form-fields > div > * {
+  display: table-cell;
+  padding: 1em 0.5em;
+}
+.anp .form-component .form-fields > div > :first-child {
+  min-width: 30%;
+}
+.anp .form-component .form-fields > div > :nth-child(2) {
+  width: 70%;
+}
+.anp .form-component .form-fields > div > label {
+  text-align: right;
+}
+.anp .form-component .form-fields > div > label span {
+  display: block;
+}
+.anp .form-component .form-fields > div > label > :first-child {
+  font-weight: 900;
+  white-space: nowrap;
+}
+.anp .form-component .form-fields > div > label > :first-child::after {
+  content: ":";
+}
+.anp .form-component .form-fields > div > label > :last-child {
+  font-size: 0.85em;
+}
 
 .anp [data-icon]::before {
   margin-right: 0.3em;

Public/scss/_base.scss

@@ -100,16 +100,32 @@
         position : relative;
         width : 100%;
         min-width : 0%;
+        box-sizing : border-box;
         &>textarea{
-            width : 100%;
             height : 5em;
-            min-width : 0%;
             min-height : 0%;
             resize : none;
         }
+        &>textarea,&>[type=text],&>[type=password],&>[type=email],&>[type=number]{
+            width : 100%;
+            min-width : 0%;
+            border : .1em solid $color-primary;
+            border-radius : $border-radius;
+            background-color : $color-back;
+            box-sizing : border-box;
+            transition-duration : $transition-out;
+            transition-property : border-color, box-shadow;
+            box-shadow : 0em 0em .2em inset $color-primary;
+            &:focus{
+                outline : none;
+                border-color : $color-secondary;
+                transition-duration : $transition-in;
+                box-shadow : 0em 0em .2em inset $color-secondary;
+            }
+        }
         .information{
             position : absolute;
-            bottom : 0em;
+            bottom : -.2em;
             right : 0em;
             font-size : .8em;
             color : $color-grey;
@@ -284,4 +300,39 @@
         }
     }
 
+    .form-component{
+        fieldset{
+            margin : 0em;
+            padding : 0em;
+            border : none;
+        }
+        legend{
+            font-size : 1.2em;
+            font-weight : 900;
+        }
+        .form-fields{
+            display : table;
+            margin : 1em 2em;
+            &>div{
+                display : table-row;
+                &>*{
+                    display : table-cell;
+                    padding : 1em .5em;
+                }
+                &>:first-child{min-width : 30%;}
+                &>:nth-child(2){width : 70%;}
+                &>label{
+                    text-align : right;
+                    span{display : block;}
+                    &>:first-child{
+                        font-weight : 900;
+                        white-space : nowrap;
+                        &::after{content : ":";}
+                    }
+                    &>:last-child{font-size : .85em;}
+                }
+            }
+        }
+    }
+
 }

Python/AnP/Abstracts/ModelAbstract.py

@@ -1,6 +1,4 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-from abc import ABC
-
-class ModelAbstract(ABC):pass
+class ModelAbstract:pass

Python/AnP/Application/AnP.py

@@ -27,6 +27,7 @@ from AnP.Managers.PseudoLoRAsManager import PseudoLoRAsManager
 from AnP.Managers.AIInterpretersManager import AIInterpretersManager
 from AnP.Managers.BrowsersManager import BrowsersManager
 from AnP.Managers.DirectoriesClonesManager import DirectoriesClonesManager
+from AnP.ORM.ORM import ORM
 from AnP.Utils.Common import Common
 from AnP.Utils.Patterns import RE
 
@@ -68,6 +69,7 @@ class AnP:
         self.ai_interpreters:AIInterpretersManager = AIInterpretersManager(self)
         self.browsers:BrowsersManager = BrowsersManager(self)
         self.directories_clones:DirectoriesClonesManager = DirectoriesClonesManager(self)
+        self.rm = ORM(self)
 
     def update(self:Self) -> None:
         self.settings.update()

Python/AnP/Interfaces/Managers/DispatchesManagerInterface.py

@@ -1,12 +1,9 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-from typing import Any, Self, TypeVar
-from AnP.Abstracts.DispatchAbstract import DispatchAbstract
+from typing import Any, Self
 from abc import ABC, abstractmethod
 
-DispatchType = TypeVar("DispatchType", bound = DispatchAbstract)
-
 class DispatchesManagerInterface(ABC):
 
     @abstractmethod
@@ -20,6 +17,3 @@ class DispatchesManagerInterface(ABC):
 
     @abstractmethod
     def execute(self:Self, via:str, key:str, method:str, *arguments:list[Any|None]) -> bool:pass
-
-    @abstractmethod
-    def get(self:Self, via:str, key:str, Type:type[DispatchType]) -> DispatchType|None:pass

Python/AnP/Managers/DispatchesManager.py

@@ -1,13 +1,12 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-from typing import Any, Self, TypeVar
+from typing import Any, Self
 from AnP.Interfaces.Application.AnPInterface import AnPInterface
 from AnP.Abstracts.DispatchAbstract import DispatchAbstract
+from AnP.Models.DatabaseResponseModel import DatabaseResponseModel
 from AnP.Utils.Checks import Check
 
-DispatchType = TypeVar("DispatchType", bound = DispatchAbstract)
-
 class DispatchesManager:
 
     def __init__(self:Self, anp:AnPInterface) -> None:
@@ -38,7 +37,6 @@ class DispatchesManager:
 
             key:str
             subinputs:dict[str, Any|None]
-            # dispatch:Any|None
             
             for key, subinputs in subinputs.items():
                 if Check.is_mark_key(key) and dispatch is None:
@@ -70,13 +68,7 @@ class DispatchesManager:
                             self.anp, dispatch if Check.is_dictionary(dispatch) else 
                         None)
 
-    def execute(self:Self, via:str, key:str, method:str, *arguments:list[Any|None]) -> bool:
+    def execute(self:Self, via:str, key:str, method:str, *arguments:list[Any|None]) -> DatabaseResponseModel|None:
         if via in self.__dispatches and key in self.__dispatches[via] and hasattr(self.__dispatches[via][key], method):
-            getattr(self.__dispatches[via][key], method)(*arguments)
-            return True
-        return False
-    
-    def get(self:Self, via:str, key:str, Type:type[DispatchType]) -> DispatchType|None:
-        if via in self.__dispatches and key in self.__dispatches[via] and isinstance(self.__dispatches[via][key], Type):
-            return self.__dispatches[via][key]
+            return getattr(self.__dispatches[via][key], method)(*arguments)
         return None

Python/AnP/Managers/UniqueKeysManager.py

@@ -1,29 +1,33 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-from typing import Self
+from typing import Self, Any, Optional, Sequence
 from AnP.Interfaces.Application.AnPInterface import AnPInterface
 from AnP.Utils.Common import Common
 
 class UniqueKeysManager:
 
-    def __init__(self:Self, anp:AnPInterface) -> None:
+    def __init__(self:Self, anp:AnPInterface, inputs:Optional[dict[str, Any|None]|Sequence[Any|None]] = None) -> None:
         self.anp:AnPInterface = anp
         self.__keys:list[str] = []
+        self.__inputs:dict[str, Any|None] = Common.get_dictionary(inputs)
         self.__alphabet:list[str] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
         self.__length:int = 13
+        self.__autosave:bool = True
 
         self.update()
 
     def update(self:Self) -> None:
-        self.__alphabet = Common.unique(self.anp.settings.get(("unique_keys_alphabet", "alphabet"), None, self.__alphabet))
-        self.__length = self.anp.settings.get(("unique_keys_length", "length"), None, self.__length)
+        self.__alphabet = Common.unique(self.anp.settings.get(("unique_keys_alphabet", "alphabet"), self.__inputs, self.__alphabet))
+        self.__length = self.anp.settings.get(("unique_keys_length", "length"), self.__inputs, self.__length)
+        self.__autosave = self.anp.settings.get(("unique_keys_autosave", "autosave"), self.__inputs, self.__autosave)
 
     def reset(self:Self) -> None:
 
         self.__keys = []
         self.__alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
         self.__length = 13
+        self.__autosave = True
 
         self.update()
 
@@ -36,7 +40,7 @@ class UniqueKeysManager:
             while len(key) < self.__length:
                 key += Common.random(self.__alphabet)
             if key[0] not in "0123456789" and key not in self.__keys:
-                self.__keys.append(key)
+                self.__autosave and self.__keys.append(key)
                 return key
 
     def remove(self:Self, key:str) -> None:

Python/AnP/Models/ORMModel.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from typing import Self, Any, Optional
+from re import Match as REMatch
+import datetime
+from AnP.Utils.Patterns import RE
+
+class ORMAttributeModel:
+    def __init__(self:Self) -> None:
+        self.name:str = ""
+        self.type:str = ""
+        self.default:Any|None = None
+        self.nullable:bool = True
+        self.unique:bool = False
+        self.multiline:bool = False
+        self.hidden:bool = False
+        self.disabled:bool = False
+        self.range:tuple[int|float, int|float]|None = None
+        self.pattern:str|None = None
+        self.foreign:str|None = None
+        self.path:str|None = None
+
+class ORMKeysModel:
+
+    def __init__(self:Self, keys:Optional[str] = None) -> None:
+
+        self.pascal:str = ""
+        self.snake:str = ""
+        self.camel:str = ""
+        self.kebab:str = ""
+
+        if keys is not None:
+            self.pascal, self.snake, self.camel, self.kebab = [key.strip() for key in RE.ORM_SEPARATOR.split(keys)]
+
+class ORMEntityModel:
+
+    def __init__(self:Self) -> None:
+        
+        self.attributes:dict[str, ORMAttributeModel] = {}
+        self.attributes_order:list[str] = []
+        self.structure:list[str] = []
+        self.permissions:list[str] = []
+        self.list:list[str] = []
+        self.select:list[str] = []
+        self.uniques:list[str] = []
+        self.belongs:list[str] = []
+
+class ORMModel:
+
+    def __init__(self:Self, code:Optional[str] = None) -> None:
+
+        default_version:str = self.get_default_version()
+
+        self.name:str = ""
+        self.key:ORMKeysModel = ORMKeysModel()
+        self.authors:list[str] = []
+        self.url:str = ""
+        self.since:str = default_version
+        self.version:str = default_version
+        self.description:str = ""
+        self.keywords:list[str] = []
+        self.platforms:list[str] = ["python", "ecma", "sqlserver", "sqlite", "mariadb", "wmarkdown"]
+        self.languages:list[str] = ["espanol", "english", "galego", "nihongo", "russkye"]
+        self.licenses:list[str] = ["copyright", "cc_by_nc_sa_4"]
+        self.git:str = ""
+        self.libraries:list[str] = []
+        self.logs:bool = True
+        self.doc_folder:bool = True
+        self.breadcrump:bool = True
+        self.aichat_doc:bool = True
+        self.cells:int = 40
+        self.zoom:int = 100
+        self.font_size:int = 12
+        self.anp_db:str = "AnP"
+        self.database:str = ""
+        self.main_route:str = "/"
+        self.guest_route:str = "/sessions/login"
+        self.entities:dict[str, ORMEntityModel] = {}
+        self.entities_order:list[str] = []
+
+        code is None or self.process(code)
+
+    @staticmethod
+    def get_string(value:str) -> str:
+
+        matches:REMatch = RE.ORM_STRING.match(value)
+
+        return matches.group(1) or matches.group(2) or matches.group(3) or ""
+    
+    @staticmethod
+    def get_default_version() -> str:
+
+        date:datetime.datetime = datetime.datetime.now()
+
+        return (
+            ("0000" + str(date.year))[-4:] + 
+            ("00" + str(date.month))[-2:] + 
+            ("00" + str(date.day))[-2:]
+        )
+
+    def process(self:Self, code:str) -> None:
+
+        headers:str
+        entities:str
+
+        headers, entities = [value.strip() for value in RE.ORM_MAIN_BLOCKS.match(code).groups()]
+
+        for header in RE.NEW_LINES.split(headers):
+
+            name:str
+            value:str
+
+            name, value = [value.strip() for value in RE.ORM_HEADER.match(header).groups()]
+
+            if hasattr(self, name):
+
+                attribute:Any = getattr(self, name)
+
+                setattr(self, name, (
+                    self.get_string(value) if isinstance(attribute, str) else 
+                    ORMKeysModel(value) if isinstance(attribute, ORMKeysModel) else 
+                    [item.strip() for item in RE.ORM_SEPARATOR.split(value)] if isinstance(attribute, list) else 
+                    value.strip().lower() == "true" if isinstance(attribute, bool) else 
+                    int(value.strip()) if isinstance(attribute, int) else 
+                None))

Python/AnP/ORM/ORM.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from typing import Self
+from AnP.Interfaces.Application.AnPInterface import AnPInterface
+
+class ORM:
+
+    def __init__(self:Self, anp:AnPInterface) -> None:
+        self.anp:AnPInterface = anp

Python/AnP/Utils/AnyankaKeys.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from typing import Any, Self, Callable, Optional, TypeVar, Iterable
+from time import time
+from AnP.Utils.Common import Common
+
+T = TypeVar("T", int, float, str, bytes)
+
+class AnyankaKeys:
+
+    __slots__:tuple[str] = (
+        '__alphabet', '__dictionary', '__private_key', '__private_key_l',
+        '__multiplier', '__primes', '__primes_l', '__multiplier_jumps',
+        '__multiplier_jump', '__base', '__encrypt_i', '__password', '__password_l'
+    )
+
+    ALPHABET:tuple[str] = tuple("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
+    PRIVATE_KEY:tuple[int] = tuple(range(0, 0x100))
+    MULTIPLIER:int = 1
+    MULTIPLIER_JUMPS:int = 3
+    MULTIPLIER_JUMP:int = 7
+    PRIMES:tuple[int] = (
+        0x3FFFFFFB, 0x3FFFFF29, 0x3FFFFF0B, 
+        0x2FFFFFFF, 0x2FFFFF5B, 0x1FFFFFFF, 
+        0x279DB13D, 0x279DB113, 
+        0x2AAAAAAB, 0x1555556B, 0x27D4EB2F, 0x165667B1, 
+        0x1000007F, 0x3B9ACA07, 0x01000193, 0x1EADBEEF, 0x0AFEBABE, 0x0BADC0DE, 0x3B9AC9C1, 0x1D295C4D, 0x990BF9F, 0x1CFAA2DB, 
+        0xDEADBEEF, 0xCAFEBABF, 0xBAADF00D
+    )
+
+    def __init__(self:Self, inputs:Optional[dict[str, Any|None]] = None) -> None:
+        
+        self.__alphabet:tuple[str] = tuple(self.unique(Common.get_value("alphabet", inputs, self.ALPHABET)))
+        self.__dictionary:dict[str, int] = {value : index for index, value in enumerate(self.__alphabet)}
+        self.__private_key:tuple[int] = tuple(Common.get_value("private_key", inputs, self.PRIVATE_KEY))
+        self.__private_key_l:int = len(self.__private_key)
+        self.__multiplier:int = Common.get_value("multiplier", inputs, self.MULTIPLIER)
+        self.__primes:tuple[int] = tuple(Common.get_value("primes", inputs, self.PRIMES))
+        self.__primes_l:int = len(self.__primes)
+        self.__multiplier_jumps:int = Common.get_value("multiplier_jumps", inputs, self.MULTIPLIER_JUMPS)
+        self.__multiplier_jump:int = Common.get_value("multiplier_jump", inputs, self.MULTIPLIER_JUMP)
+        l:int = len(self.__alphabet)
+        self.__base:int = Common.get_value("base", inputs, l)
+        self.__encrypt_i:int = 0
+        self.__password:tuple[int] = (0,)
+        self.__password_l:int = 1
+
+        self.set_password(Common.get_value("password", inputs, ""))
+
+        if self.__base > l:
+            self.__base = l
+
+    def set_password(self:Self, password:str) -> None:
+
+        if password:
+
+            password_changed:list[int] = []
+
+            self.change_base(password, self.__base, input_handler = ord, output_handler = password_changed.append)
+            self.__password = tuple(password_changed)
+
+        else:
+            self.__password = (0,)
+            
+        self.__password_l = len(self.__password)
+
+    def __get_multiplier(self:Self, i:int) -> int:
+        
+        value:int = (i + self.__multiplier + self.__primes[
+            i := (i + self.__multiplier_jump) % self.__primes_l
+        ]) & 0x3FFFFFFF
+
+        for _ in range(self.__multiplier_jumps):
+
+            shift:int = 13 + i % 8
+
+            value = ((value ^ (
+                value >> shift if i & 1 else value << shift
+            )) + self.__primes[
+                i := (i + self.__multiplier_jump) % self.__primes_l
+            ]) & 0x3FFFFFFF
+
+        return value
+
+    def encrypt(self:Self, data:str) -> str:
+
+        i:int = self.__get_multiplier(self.__encrypt_i + len(data) + int(time() % 1 * 1000)) % self.__base
+        summatory:str = self.__alphabet[i]
+        encrypted:list[str] = []
+        
+        self.__encrypt_i = (self.__encrypt_i + i) % self.__base
+        i -= 1
+
+        def output_handler(value:int) -> None:
+            nonlocal encrypted, i
+
+            multiplier:int = self.__get_multiplier(i := i + 1)
+
+            encrypted.append(self.__alphabet[(multiplier + value + self.__private_key[
+                multiplier // self.__base % self.__private_key_l
+            ] + self.__password[multiplier % self.__password_l]) % self.__base])
+
+        self.change_base(data, self.__base, 0x100, 
+            input_handler = ord, 
+            output_handler = output_handler
+        )
+
+        return summatory + "".join(reversed(encrypted))
+
+    def decrypt(self:Self, data:str) -> str:
+
+        i:int = len(data[1:]) + self.__dictionary[data[0]]
+        decrypted:list[str] = []
+
+        def output_handler(value:int) -> None:
+            nonlocal decrypted
+            decrypted.append(chr(value))
+        
+        def input_handler(value:str) -> int:
+            nonlocal i
+
+            multiplier:int = self.__get_multiplier(i := i - 1)
+
+            return (self.__dictionary[value] - self.__private_key[
+                multiplier // self.__base % self.__private_key_l
+            ] - multiplier - self.__password[multiplier % self.__password_l]) % self.__base
+        
+        self.change_base(data[1:], 0x100, self.__base, 
+            input_handler = input_handler, 
+            output_handler = output_handler
+        )
+
+        return "".join(reversed(decrypted))
+    
+    @staticmethod
+    def unique(items:Iterable[Any|None]) -> list[Any|None]:
+        return list(dict.fromkeys(items))
+
+    @staticmethod
+    def change_base(
+        data:Iterable[T], 
+        to_base:int, 
+        from_base:int = 0x100, 
+        input_handler:Optional[Callable[[T], int]] = None, 
+        output_handler:Optional[Callable[[int], None]] = None
+    ) -> None:
+
+        stack:int = 0
+        value:int
+        has:bool = False
+
+        if input_handler is None:input_handler = lambda value:value
+        if output_handler is None:output_handler = lambda value:value
+
+        for value in data:
+            stack = stack * from_base + input_handler(value)
+            while stack >= to_base:
+                has = True
+                stack, value = divmod(stack, to_base)
+                output_handler(value)
+
+        (not has or stack) and output_handler(stack)

Python/AnP/Utils/ErrorsManager.py

@@ -0,0 +1,442 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from math import log2, ceil
+from typing import Any, Optional, Sequence, Self
+from AnP.Utils.Checks import Check
+from AnP.Utils.Common import Common
+
+class ErrorsManager:
+
+    ALPHABET:tuple[str] = tuple("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=")
+
+    ERRORS_MESSAGES:tuple[str] = (
+        "invalid_alphabet",
+        "invalid_base",
+        "invalid_alphabet_type",
+        "too_short_alphabet",
+        "repeated_characters_in_alphabet",
+        "too_long_alphabet",
+        "base_lower_than_2",
+        "base_greater_than_128",
+        "base_greater_than_alphabet"
+    )
+
+    def __init__(self:Self, inputs:Optional[dict[str, Any|None]|Sequence[Any|None]] = None) -> None:
+        
+        self.__error:int = 0
+        self.__alphabet:tuple[str] = tuple()
+        self.__dictionary:dict[str, int] = {}
+        self.__base:int = 0
+        self.__power:int = 0
+
+        self.set_alphabet(
+            Common.get_value("alphabet", inputs, self.ALPHABET), 
+            Common.get_value("base", inputs, 64)
+        )
+
+    def set_alphabet(self:Self, alphabet:Optional[str|Sequence[str]] = None, base:int = 64) -> int:
+
+        original_length:int
+        i:int
+        character:str
+
+        self.__error = 0
+
+        if alphabet is None:
+            self.__alphabet = self.ALPHABET
+        elif Check.is_string(alphabet) or Check.is_array(alphabet):
+            self.__alphabet = tuple(alphabet)
+        else:
+            self.__error |= 1 << 2
+            self.__alphabet = self.ALPHABET
+
+        original_length = len(self.__alphabet)
+
+        self.__alphabet = tuple(self.unique(self.__alphabet))
+
+        if len(self.__alphabet) < 2:
+            self.__error |= 1 << 3
+            self.__alphabet = self.ALPHABET
+        if len(self.__alphabet) != original_length:
+            self.__error |= 1 << 4
+        if len(self.__alphabet) > 128:
+            self.__error |= 1 << 5
+
+        self.__error |= (
+            1 << 0 if base < 2 else
+            1 << 1 if base > 128 else
+            1 << 2 if base >= len(self.__alphabet) else
+        0) << 6
+
+        if not self.__error >> 6:
+            self.__alphabet = self.__alphabet[0:base]
+
+        self.__power = int(log2(len(self.__alphabet[0:128])))
+        self.__base = 2 ** self.__power
+        self.__alphabet = self.__alphabet[0:self.__base]
+
+        for i, character in enumerate(self.__alphabet):
+            self.__dictionary[character] = i
+
+        return self.__error
+    
+    def get_alphabet(self:Self) -> str:
+        return "".join(self.__alphabet)
+    
+    def to_array(self:Self, code:str|Sequence[int]|int) -> list[int]:
+        if Check.is_string(code):
+            return [self.__dictionary[character] for character in code]
+        if Check.is_array(code):
+            return list(code)
+        if Check.is_integer(code):
+
+            hexas:list[int] = []
+
+            while code:
+                hexas.append(code % self.__base)
+                code //= self.__base
+
+            return hexas or [0]
+        return []
+    
+    def to_string(self:Self, code:list[int]|str|Sequence[int]|int) -> str:
+        if Check.is_string(code):
+            return code
+        if Check.is_array(code):
+            return "".join(self.__alphabet[i] for i in code)
+        if Check.is_integer(code):
+
+            hexas:str = ""
+
+            while code:
+                hexas += self.__alphabet[code % self.__base]
+                code //= self.__base
+
+            return hexas or self.__alphabet[0]
+        return ""
+    
+    def to_integer(self:Self, code:str|Sequence[int]|int) -> int:
+        if Check.is_string(code):
+            return sum(self.__dictionary[character] * (self.__base ** i) for i, character in enumerate(code))
+        if Check.is_array(code):
+            return sum(i * (self.__base ** j) for j, i in enumerate(code))
+        if Check.is_integer(code):
+            return code
+        return 0
+    
+    def to_string_binary(self:Self, code:str|Sequence[int]|int) -> str:
+        if Check.is_string(code):
+            return "".join(("0000000" + "{0:b}".format(self.__dictionary[character]))[-self.__power:] for character in code[::-1])
+        if Check.is_array(code):
+            return "".join(("0000000" + "{0:b}".format(hexa))[-self.__power:] for hexa in code[::-1])
+        if Check.is_integer(code):
+
+            binary:str = "{0:b}".format(code)
+            module:int = len(binary) % self.__power
+            
+            return ("0000000"[:self.__power - module] if module else "") + binary
+        return ""
+    
+    def get_bits(self:Self, code:str|Sequence[int]|int) -> int:
+        if Check.is_string(code):
+            return (len(code) - 1) * self.__power + ceil(log2(self.__dictionary[code[-1]] + 1))
+        if Check.is_array(code):
+            return (len(code) - 1) * self.__power + ceil(log2(code[-1] + 1))
+        if Check.is_integer(code):
+            return code.bit_length()
+        return 0
+    
+    def get_from_bits(self:Self, code:str|Sequence[int]|int, _from:int, bits:int) -> tuple[int, int]:
+
+        if _from < 0:
+            _from = self.get_bits(code) + _from
+            if _from < 0:
+                _from = 0
+        if bits < 0:
+            _from += bits
+            bits = -bits
+            if _from < 0:
+                bits += _from
+                _from = 0
+
+        return _from, bits
+    
+    def clean(self:Self, code:str|Sequence[int]|int) -> str|Sequence[int]|int|None:
+        if Check.is_string(code):
+
+            l:int = len(code)
+            
+            while l > 0 and code[l - 1] != self.__alphabet[0]:
+                l -= 1
+
+            return code[:l] or self.__alphabet[0]
+        if Check.is_array(code):
+            
+            l:int = len(code)
+            
+            while l > 0 and code[l - 1] == 0:
+                l -= 1
+
+            return code[:l] or [0]
+        if Check.is_integer(code):
+            return code
+        return None
+    
+    def get_range(self:Self, code:str|Sequence[int]|int, _from:int, bits:int) -> str|Sequence[int]|int|None:
+        if Check.is_string(code):
+            return self.to_string(self.get_range(self.to_array(code), _from, bits))
+        if Check.is_array(code):
+            
+            hexas:list[int]
+
+            _from, bits = self.get_from_bits(code, _from, bits)
+
+            if not bits:
+                bits = self.get_bits(code) - _from
+            if bits <= 0:
+                return [0]
+            
+            hexas = list(code)
+
+            if _from > 0:
+
+                shift:int = _from % self.__power
+                mask:int = (self.__base) - 1
+
+                hexas = hexas[_from // self.__power:]
+                if shift and len(hexas):
+
+                    hexa:int
+                    i:int
+
+                    for i, hexa in enumerate(hexas[:-1]):
+                        hexas[i] = ((hexa >> shift) | (hexas[i + 1] << self.__power - shift)) & mask
+                    hexas[-1] >>= shift
+
+            if bits > 0:
+
+                shift:int = bits % self.__power
+
+                hexas = hexas[0:int(ceil(bits / self.__power))]
+                if shift and len(hexas):
+                    hexas[len(hexas) - 1] &= (1 << shift) - 1
+
+            return self.clean(hexas)
+        if Check.is_integer(code):
+            
+            _from, bits = self.get_from_bits(code, _from, bits)
+
+            if not bits:
+                bits = self.get_bits(code) - _from
+            if bits <= 0 or _from >= 31:
+                return 0
+            
+            if _from + bits > 31:
+                bits = 31 - _from
+            
+            return (code >> _from) & ((1 << bits) - 1)
+        return None
+    
+    def process(self:Self, code:str|Sequence[int]|int, messages:Sequence[str], blocks:dict[int, int]) -> list[tuple[int, str]]:
+        if Check.is_string(code) or Check.is_integer(code):
+            return self.process(self.to_array(code), messages, blocks)
+        if Check.is_array(code):
+            
+            response:list[tuple[int, str]] = []
+            k:int = 0
+            i:int
+            l:int = len(messages)
+            i:int = 0
+            m:int = len(code) * self.__power
+
+            if blocks is None:
+                blocks = {}
+
+            while i < m:
+                if i in blocks and blocks[i]:
+
+                    logarithm:int = int(ceil(log2(blocks[i])))
+                    _k:int = self.to_integer(self.get_range(code, i, logarithm if logarithm else (logarithm := 0)))
+
+                    if _k:
+                        _k += k
+                        response.append((_k, messages[k] if k < l else "error_message_" + str(_k)))
+
+                    k += blocks[i]
+                    i += logarithm
+
+                else:
+                    if code[i // self.__power] & (1 << (i % self.__power)):
+                        response.append((k, messages[k] if k < l else "error_message_" + str(k)))
+                    k += 1
+                    i += 1
+
+            return response
+        return []
+    
+    def bitwise(self:Self, code:str|Sequence[int]|int, bits:int) -> str|Sequence[int]|int|None:
+        if Check.is_string(code):
+            return self.to_string(self.bitwise(self.to_array(code), bits))
+        if Check.is_array(code):
+            if not len(code) or not bits:
+                return self.clean(code)
+            
+            shift:int = abs(bits) % self.__power
+            mask:int = self.__base - 1
+            hexas:list[int] = list(code)
+
+            if bits < 0:
+
+                hexas = hexas[-bits // self.__power:]
+
+                if shift and len(hexas):
+
+                    hexa:int
+                    i:int
+
+                    for i, hexa in enumerate(hexas[:-1]):
+                        hexas[i] = ((hexa >> shift) | (hexas[i + 1] << self.__power - shift)) & mask
+                    hexas[-1] >>= shift
+
+            else:
+
+                if shift:
+
+                    last_hexa:int = hexas[-1] << shift
+
+                    for i, hexa in reversed(list(enumerate(hexas))[1:]):
+                        hexas[i] = ((hexas[i] << shift) | (hexas[i - 1] >> self.__power - shift)) & mask
+                    hexas[0] = (hexas[0] << shift) & mask
+
+                    if last_hexa >= self.__base:
+                        hexas.append(last_hexa >> self.__power)
+
+                hexas = [0] * (bits // self.__power) + hexas
+
+            return self.clean(hexas)
+        if Check.is_integer(code):
+            return (
+                code << bits if bits > 0 else
+                code >> -bits if bits < 0 else
+            code)
+        return None
+    
+    def reset(self:Self, code:str|Sequence[int]|int, _from:int, bits:int = 0, reversed:bool = False) -> str|Sequence[int]|int|None:
+        if Check.is_string(code):
+            return self.to_string(self.reset(self.to_array(code), _from, bits, reversed))
+        if Check.is_array(code):
+            
+            hexas:list[int] = list(code)
+            hexa_from:int
+            hexa_to:int
+            l:int
+            from_mask:int
+            to_mask:int
+
+            _from, bits = self.get_from_bits(code, _from, bits)
+            hexa_from = _from // self.__power
+            hexa_to = (_from + bits) // self.__power
+
+            if reversed:
+
+                i:int
+
+                l = _from % self.__power
+                from_mask = ~((1 << l) - 1)
+                to_mask = (1 << ((_from + bits) % self.__power)) - 1
+
+                for i in range(len(hexas)):
+                    if i < hexa_from or i > hexa_to:
+                        hexas[i] = 0
+
+                if hexa_from == hexa_to:
+                    hexas[hexa_from] &= from_mask & to_mask
+                else:
+                    hexas[hexa_from] &= from_mask
+                    if hexa_to < len(hexas):
+                        hexas[hexa_to] &= to_mask
+
+            elif hexa_from < len(hexas):
+                
+                l = (_from + bits) % self.__power
+                from_mask = ((1 << (_from % self.__power)) - 1)
+                to_mask = ((1 << (self.__power - l)) - 1) << l
+
+                if hexa_from == hexa_to:
+                    hexas[hexa_from] &= from_mask | to_mask
+                else:
+
+                    i:int
+                    m:int = len(hexas)
+
+                    hexas[hexa_from] &= from_mask
+                    for i in range(hexa_from + 1, hexa_to):
+                        if i >= m:
+                            break
+                        hexas[i] = 0
+                    if hexa_to < m:
+                        hexas[hexa_to] &= to_mask
+
+            return self.clean(hexas)
+        if Check.is_integer(code):
+            
+            _from, bits = self.get_from_bits(code, _from, bits)
+            if _from + bits > 31:
+                bits = 31 - _from
+
+            return code & (
+                ((1 << bits) - 1) << _from if reversed else
+            ((1 << self.get_bits(code)) - 1 << _from + bits) | ((1 << _from) - 1))
+        return None
+    
+    def has(self:Self, code:str|Sequence[int]|int, _from:int = 0, bits:int = 0) -> bool:
+        if Check.is_string(code):
+            for hexa in self.get_range(code, _from, bits):
+                if self.__dictionary[hexa]:
+                    return True
+        if Check.is_array(code):
+            for hexa in self.get_range(code, _from, bits):
+                if hexa:
+                    return True
+        if Check.is_integer(code) and self.get_range(code, _from, bits):
+            return True
+        return False
+    
+    def set(self:Self, code:str|Sequence[int]|int, error:str|Sequence[int]|int, _from:int, bits:int = 0) -> str|Sequence[int]|int|None:
+        if Check.is_string(code):
+            return self.to_string(self.set(self.to_array(code), error, _from, bits))
+        if Check.is_array(code):
+            
+            l:int
+            n:int = len(error := self.to_array(error))
+            m:int = len(code)
+            results:list[int] = []
+
+            if bits:
+                m = len(code := self.reset(code, _from, bits))
+            if _from:
+                n = len(error := self.bitwise(error, _from))
+            l = m if m > n else n
+
+            for i in range(l):
+                results.append(
+                    (error[i] if i < n else 0) | 
+                    (code[i] if i < m else 0)
+                )
+
+            return self.clean(results)
+        if Check.is_integer(code):
+            
+            error = self.to_integer(error)
+            if bits:
+                code = self.reset(code, _from, bits)
+            if _from:
+                error = self.bitwise(error, _from)
+
+            return error | code
+        return None
+    
+    @staticmethod
+    def unique(items:str|bytes|Sequence[Any|None]) -> list[Any|None]:
+        return [item for i, item in enumerate(items) if list(items).index(item) == i]

Python/AnP/Utils/Patterns.py

@@ -21,3 +21,13 @@ class RE:
     HTTP_REQUEST:REPattern = re_compile(r'^([^\s]+)\s([^\s\?\#]+)(?:\?([^#]+))?(?:\#([^\s]+))?\s([^\/]+)\/([0-9\.]+)$')
     PYTHON_MODULES_PATH:REPattern = re_compile(r'[\/\\]python[0-9\.]+[\/\\]site-packages[\/\\]?$', RE_IGNORECASE)
     ODBC_STRING_VARIABLE:REPattern = re_compile(r'\{([a-z_][a-z0-9_]*)\}|@([a-z0-9_]+)', RE_IGNORECASE)
+
+    # ORM
+    ORM_MAIN_BLOCKS:REPattern = re_compile(r'((?:(?!(?:(?:\r\n){2}|[\r\n]{2}))(?:.|[\r\n]))+)(?:(?:\r\n){2}|[\r\n]{2})((?:.+|[\r\n]+)+)')
+    ORM_HEADER:REPattern = re_compile(r'^([a-z_][a-z0-9_]*)\s+(.+)$', RE_IGNORECASE)
+    ORM_SEPARATOR:REPattern = re_compile(r'\s+|,')
+    ORM_STRING:REPattern = re_compile(r'"((?:[^\r\n"\\]|\\.)*)"|\'((?:[^\r\n\'\\]|\\.)*)\'|(.+)')
+    ORM_BLOCK_COMMENTS:REPattern = re_compile(r'\/\*(?:[^\*]|\*+[^\/\*]|[\r\n]+)*\*+\/')
+    ORM_LINE_COMMENTS:REPattern = re_compile(r'(?:#|\-{2}|\/{2})[^\r\n]+')
+    ORM_LINE_BLOCKS:REPattern = re_compile(r'"(?:[^\r\n"\\]|\\.)*"|\'(?:[^\r\n\'\\]|\\.)*\'')
+    # ORM

SQLServer/AnP.01.base.server.sql

@@ -86,7 +86,6 @@ create procedure dbo.procedure_get_id (
 end
 go
 
-execute dbo.common_tables_drop
 execute dbo.common_tables_create
 
 if object_id(N'dbo.bw', N'FN') is not null drop function dbo.bw

SQLServer/AnP.02.users.server.sql

@@ -32,7 +32,7 @@ create procedure dbo.users_tables_create as begin set nocount on
 
     if object_id(N'dbo._Users', N'U') is null create table dbo._Users(
         id integer not null identity(1, 1), 
-        mode integer not null, 
+        history_mode integer not null, 
         entity integer not null, 
         [procedure] integer not null, 
         [session] integer not null, 
@@ -41,9 +41,9 @@ create procedure dbo.users_tables_create as begin set nocount on
         accessible bit not null, 
         date_in datetime2 not null, 
         date_out datetime2, 
-        history_date datetime2 not null constraint df__users_history_in default sysutcdatetime(), 
+        history_date datetime2 not null constraint df__users_history_date default sysutcdatetime(), 
         constraint pk__users primary key clustered(id), 
-        constraint fk__users_mode foreign key(mode) references dbo.HistoryModes(id) 
+        constraint fk__users_history_mode foreign key(history_mode) references dbo.HistoryModes(id) 
             on update no action 
             on delete no action,
         constraint fk__users_procedure foreign key([procedure]) references dbo.Procedures(id) 
@@ -89,7 +89,7 @@ create trigger dbo.users_trigger on dbo.Users for insert, update, delete as begi
     execute dbo.history_mode_get @insert output, @update output, @delete output, @unknown output
 
     -- update.
-    insert into dbo._Users(mode, entity, [procedure], [session], nick, [password], accessible, date_in, date_out) 
+    insert into dbo._Users(history_mode, entity, [procedure], [session], nick, [password], accessible, date_in, date_out) 
     select @update, inserted.id, inserted.[procedure], inserted.[session], inserted.nick, inserted.[password], inserted.accessible, inserted.date_in, inserted.date_out 
     from inserted inserted 
     join deleted deleted on inserted.id = deleted.id 
@@ -103,14 +103,14 @@ create trigger dbo.users_trigger on dbo.Users for insert, update, delete as begi
         isnull(inserted.date_out, '0001-01-01') != isnull(deleted.date_out, '0001-01-01')
 
     -- Insert.
-    insert into dbo._Users(mode, entity, [procedure], [session], nick, [password], accessible, date_in, date_out) 
+    insert into dbo._Users(history_mode, entity, [procedure], [session], nick, [password], accessible, date_in, date_out) 
     select @insert, inserted.id, inserted.[procedure], inserted.[session], inserted.nick, inserted.[password], inserted.accessible, inserted.date_in, inserted.date_out 
     from inserted inserted 
     left join deleted deleted on inserted.id = deleted.id 
     where deleted.id is null
 
     -- deleted.
-    insert into dbo._Users(mode, entity, [procedure], [session], nick, [password], accessible, date_in, date_out) 
+    insert into dbo._Users(history_mode, entity, [procedure], [session], nick, [password], accessible, date_in, date_out) 
     select @delete, deleted.id, deleted.[procedure], deleted.[session], deleted.nick, deleted.[password], deleted.accessible, deleted.date_in, deleted.date_out 
     from deleted deleted 
     left join inserted inserted on deleted.id = inserted.id 

SQLServer/AnP.03.ips.server.sql

@@ -24,26 +24,27 @@ create procedure dbo.ips_tables_create as begin set nocount on
         constraint fk_ips_procedure foreign key([procedure]) references dbo.Procedures(id) 
             on update no action 
             on delete no action,
-        constraint uq_ips_ip unique(ip) with(fillfactor = 90), 
-        constraint ck_ips_ip check((
-            [ip] like '%._%._%._%' and 
-            [ip] not like '%[^0-9.]%' and 
-            len([ip]) - len(replace([ip], '.', '')) = 3 and 
-            parsename([ip], 1) between 0 and 255 and 
-            parsename([ip], 2) between 0 and 255 and 
-            parsename([ip], 3) between 0 and 255 and 
-            parsename([ip], 4) between 0 and 255 
+        constraint uq_ips_address unique(address) with(fillfactor = 90), 
+        constraint ck_ips_address check((
+            [address] like '%._%._%._%' and 
+            [address] not like '%[^0-9.]%' and 
+            len([address]) - len(replace([address], '.', '')) = 3 and 
+            parsename([address], 1) between 0 and 255 and 
+            parsename([address], 2) between 0 and 255 and 
+            parsename([address], 3) between 0 and 255 and 
+            parsename([address], 4) between 0 and 255 
         ) or (
-            [ip] not like '%[^0-9a-fA-F:]%' and 
-            [ip] like '%:%' and 
-            [ip] not like '%:::%' and 
-            [ip] not like '%[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]%' and 
-            len([ip]) - len(replace([ip], ':', '')) between 2 and 7 
+            [address] not like '%[^0-9a-fA-F:]%' and 
+            [address] like '%:%' and 
+            [address] not like '%:::%' and 
+            [address] not like '%[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]%' and 
+            len([address]) - len(replace([address], ':', '')) between 2 and 7 
         ))
     )
 
     if object_id(N'dbo._Ips', N'U') is null create table dbo._Ips(
         id integer not null identity(1, 1), 
+        history_mode integer not null, 
         entity integer not null, 
         [procedure] integer not null, 
         [session] integer, 
@@ -51,9 +52,12 @@ create procedure dbo.ips_tables_create as begin set nocount on
         accessible bit not null, 
         date_in datetime not null, 
         date_out datetime, 
-        history_date datetime2 not null constraint df__ips_history_in default sysutcdatetime(), 
+        history_date datetime2 not null constraint df__ips_history_date default sysutcdatetime(), 
         constraint pk__ips primary key clustered(id), 
-        constraint fk_ips_procedure foreign key([procedure]) references dbo.Procedures(id) 
+        constraint fk__ips_history_mode foreign key(history_mode) references dbo.HistoryModes(id) 
+            on update no action 
+            on delete no action,
+        constraint fk__ips_procedure foreign key([procedure]) references dbo.Procedures(id) 
             on update no action 
             on delete no action
     )
@@ -95,7 +99,7 @@ create trigger dbo.ips_trigger on dbo.Ips for insert, update, delete as begin se
     execute dbo.history_mode_get @insert output, @update output, @delete output, @unknown output
 
     -- update.
-    insert into dbo._Ips(mode, entity, [procedure], [session], [address], accessible, date_in, date_out) 
+    insert into dbo._Ips(history_mode, entity, [procedure], [session], [address], accessible, date_in, date_out) 
     select @update, inserted.id, inserted.[procedure], inserted.[session], inserted.[address], inserted.accessible, inserted.date_in, inserted.date_out 
     from inserted inserted 
     join deleted deleted on inserted.id = deleted.id 
@@ -108,14 +112,14 @@ create trigger dbo.ips_trigger on dbo.Ips for insert, update, delete as begin se
         isnull(inserted.date_out, '0001-01-01') != isnull(deleted.date_out, '0001-01-01')
 
     -- Insert.
-    insert into dbo._Ips(mode, entity, [procedure], [session], [address], accessible, date_in, date_out) 
+    insert into dbo._Ips(history_mode, entity, [procedure], [session], [address], accessible, date_in, date_out) 
     select @insert, inserted.id, inserted.[procedure], inserted.[session], inserted.[address], inserted.accessible, inserted.date_in, inserted.date_out 
     from inserted inserted 
     left join deleted deleted on inserted.id = deleted.id 
     where deleted.id is null
 
     -- deleted.
-    insert into dbo._Ips(mode, entity, [procedure], [session], [address], accessible, date_in, date_out) 
+    insert into dbo._Ips(history_mode, entity, [procedure], [session], [address], accessible, date_in, date_out) 
     select @delete, deleted.id, deleted.[procedure], deleted.[session], deleted.[address], deleted.accessible, deleted.date_in, deleted.date_out 
     from deleted deleted 
     left join inserted inserted on deleted.id = inserted.id 

SQLServer/AnP.04.sessions.server.sql

@@ -18,7 +18,7 @@ create procedure dbo.users_tables_create as begin set nocount on
         [procedure] integer not null, 
         [user] integer not null, 
         [ip] integer not null, 
-        date_last integer not null constraint df_sessions_date_last default getdate(),
+        date_last datetime not null constraint df_sessions_date_last default getdate(),
         date_in datetime not null constraint df_sessions_date_in default getdate(), 
         date_out datetime, 
         constraint pk_sessions primary key clustered(id), 
@@ -38,32 +38,36 @@ create procedure dbo.users_tables_create as begin set nocount on
         [procedure] integer not null, 
         [user] integer not null, 
         [ip] integer not null, 
-        date_last integer not null constraint df_sessions_date_last default getdate(),
-        date_in datetime not null constraint df_sessions_date_in default getdate(), 
-        [timeout] integer not null constraint df_sessions_timeout default 300,
-        constraint pk_sessions primary key clustered(id), 
-        constraint fk_sessions_procedure foreign key([procedure]) references dbo.Procedures(id) 
+        date_last datetime not null constraint df_sessions_actived_date_last default getdate(),
+        date_in datetime not null constraint df_sessions_actived_date_in default getdate(), 
+        [timeout] integer not null constraint df_sessions_actived_timeout default 300,
+        constraint pk_sessions_actived primary key clustered(id), 
+        constraint fk_sessions_actived_procedure foreign key([procedure]) references dbo.Procedures(id) 
             on update no action 
             on delete no action, 
-        constraint fk_sessions_user foreign key([user]) references dbo.Users(id) 
+        constraint fk_sessions_actived_user foreign key([user]) references dbo.Users(id) 
             on update no action 
             on delete no action, 
-        constraint fk_sessions_ip foreign key([ip]) references dbo.Ips(id) 
+        constraint fk_sessions_actived_ip foreign key([ip]) references dbo.Ips(id) 
             on update no action 
             on delete no action
     )
     
     if object_id(N'dbo._Sessions', N'U') is null create table dbo._Sessions(
         id integer not null identity(1, 1), 
+        history_mode integer not null,
         entity integer not null, 
         [procedure] integer not null,
         [user] integer not null, 
         [ip] integer not null, 
-        date_last integer not null,
+        date_last datetime not null,
         date_in datetime not null, 
         date_out datetime, 
-        history_date datetime2 not null constraint df__sessions_history_in default sysutcdatetime(), 
+        history_date datetime2 not null constraint df__sessions_history_date default sysutcdatetime(), 
         constraint pk__sessions primary key clustered(id), 
+        constraint fk__sessions_history_mode foreign key(history_mode) references dbo.HistoryModes(id) 
+            on update no action 
+            on delete no action,
         constraint fk__sessions_procedure foreign key([procedure]) references dbo.Procedures(id) 
             on update no action 
             on delete no action, 
@@ -88,11 +92,11 @@ go
 
 execute dbo.users_tables_create
 
-if object_id(N'dbo.sessions_actived_trigger', N'TR') is not null drop trigger dbo.sessions_actived_trigger on dbo.SessionsActived
+if object_id(N'dbo.sessions_actived_trigger', N'TR') is not null drop trigger dbo.sessions_actived_trigger
 go
 create trigger dbo.sessions_actived_trigger on dbo.SessionsActived after insert, update, delete as begin set nocount on 
 
-    -- Updates.
+    -- Update.
     update sessions set 
         sessions.[procedure] = inserted.[procedure],
         sessions.[user] = inserted.[user],
@@ -103,7 +107,7 @@ create trigger dbo.sessions_actived_trigger on dbo.SessionsActived after insert,
     join dbo.Sessions sessions on inserted.id = sessions.id 
     join deleted deleted on inserted.id = deleted.id 
 
-    -- Inserts.
+    -- Insert.
     insert into dbo.Sessions(id, [procedure], [user], [ip], date_last, date_in) 
     select inserted.id, inserted.[procedure], inserted.[user], inserted.[ip], inserted.date_last, inserted.date_in 
     from inserted inserted 
@@ -111,7 +115,7 @@ create trigger dbo.sessions_actived_trigger on dbo.SessionsActived after insert,
     left join deleted deleted on inserted.id = deleted.id 
     where sessions.id is null and deleted.id is null
 
-    -- Deletes.
+    -- Delete.
     update sessions set 
         sessions.[procedure] = deleted.[procedure],
         sessions.[user] = deleted.[user],
@@ -124,7 +128,7 @@ create trigger dbo.sessions_actived_trigger on dbo.SessionsActived after insert,
     left join inserted inserted on deleted.id = inserted.id 
     where inserted.id is null
 
-    -- Deletes unexistent.
+    -- Delete unexistent.
     insert into dbo.Sessions(id, [procedure], [user], [ip], date_last, date_in, date_out) 
     select deleted.id, deleted.[procedure], deleted.[user], deleted.[ip], deleted.date_last, deleted.date_in, getdate() 
     from deleted deleted 
@@ -135,13 +139,17 @@ create trigger dbo.sessions_actived_trigger on dbo.SessionsActived after insert,
 end
 go
 
-if object_id(N'dbo.sessions_trigger', N'TR') is not null drop trigger dbo.sessions_trigger on dbo.Sessions
+if object_id(N'dbo.sessions_trigger', N'TR') is not null drop trigger dbo.sessions_trigger
 go
 create trigger dbo.sessions_trigger on dbo.Sessions after insert, update, delete as begin set nocount on 
 
+    declare @insert integer, @update integer, @delete integer, @unknown integer
+
+    execute dbo.history_mode_get @insert output, @update output, @delete output, @unknown output
+
     -- Update.
-    insert into dbo._Sessions(id, [procedure], [user], [ip], date_last, date_in, date_out) 
-    select inserted.id, inserted.[procedure], inserted.[user], inserted.[ip], inserted.date_last, inserted.date_in, null 
+    insert into dbo._Sessions(history_mode, id, [procedure], [user], [ip], date_last, date_in, date_out) 
+    select @update, inserted.id, inserted.[procedure], inserted.[user], inserted.[ip], inserted.date_last, inserted.date_in, null 
     from inserted inserted 
     join deleted deleted on inserted.id = deleted.id 
     where (
@@ -161,15 +169,15 @@ create trigger dbo.sessions_trigger on dbo.Sessions after insert, update, delete
     )
 
     -- Insert.
-    insert into dbo._Sessions(id, [procedure], [user], [ip], date_last, date_in, date_out) 
-    select inserted.id, inserted.[procedure], inserted.[user], inserted.[ip], inserted.date_last, inserted.date_in, null 
+    insert into dbo._Sessions(history_mode, id, [procedure], [user], [ip], date_last, date_in, date_out) 
+    select @insert, inserted.id, inserted.[procedure], inserted.[user], inserted.[ip], inserted.date_last, inserted.date_in, null 
     from inserted inserted 
     left join deleted deleted on inserted.id = deleted.id 
     where deleted.id is null
 
     -- Delete.
-    insert into dbo._Sessions(id, [procedure], [user], [ip], date_last, date_in, date_out, history_out) 
-    select deleted.id, deleted.[procedure], deleted.[user], deleted.[ip], deleted.date_last, deleted.date_in, getdate(), sysutcdatetime() 
+    insert into dbo._Sessions(history_mode, id, [procedure], [user], [ip], date_last, date_in, date_out) 
+    select @delete, deleted.id, deleted.[procedure], deleted.[user], deleted.[ip], deleted.date_last, deleted.date_in, getdate()
     from deleted deleted 
     left join inserted inserted on deleted.id = inserted.id 
     where inserted.id is null
@@ -184,7 +192,10 @@ create function machine_session_get() returns integer begin
         select top 1 sessions.id 
         from dbo.Sessions sessions 
         join dbo.Users users on users.id = sessions.[user] 
-        where date_out is null and users.nick = 'machine'
+        where 
+            sessions.date_out is null and 
+            users.date_out is null and 
+            users.nick = 'machine'
     )
 end
 go

SQLServer/AnP.05.groups.server.sql

@@ -24,6 +24,7 @@ create procedure dbo.groups_tables_create as begin set nocount on
         [procedure] integer not null, 
         [session] integer not null, 
         [name] varchar(64) not null, 
+        [owner] bit not null constraint df_groups_owner default 0,
         [description] varchar(512) not null, 
         date_in datetime not null constraint df_groups_date_in default getdate(), 
         date_out datetime, 
@@ -90,15 +91,20 @@ create procedure dbo.groups_tables_create as begin set nocount on
 
     if object_id(N'dbo._Groups', N'U') is null create table dbo._Groups(
         id integer not null identity(1, 1), 
+        history_mode integer not null, 
         entity integer not null, 
         [procedure] integer not null, 
         [session] integer not null, 
         [name] varchar(64) not null, 
+        [owner] bit not null constraint df__groups_owner default 0,
         [description] varchar(512) not null, 
         date_in datetime not null, 
         date_out datetime, 
-        history_date datetime2 not null constraint df__groups_history_in default sysutcdatetime(), 
+        history_date datetime2 not null constraint df__groups_history_date default sysutcdatetime(), 
         constraint pk__groups primary key clustered(id), 
+        constraint fk__groups_history_mode foreign key(history_mode) references dbo.HistoryModes(id) 
+            on update no action 
+            on delete no action,
         constraint fk__groups_procedure foreign key([procedure]) references dbo.Procedures(id) 
             on update no action 
             on delete no action,
@@ -109,6 +115,7 @@ create procedure dbo.groups_tables_create as begin set nocount on
 
     if object_id(N'dbo._GroupsUsers', N'U') is null create table dbo._GroupsUsers(
         id integer not null identity(1, 1), 
+        history_mode integer not null,
         entity integer not null, 
         [procedure] integer not null, 
         [session] integer not null, 
@@ -117,8 +124,11 @@ create procedure dbo.groups_tables_create as begin set nocount on
         belongs bit not null,
         date_in datetime not null, 
         date_out datetime, 
-        history_date datetime2 not null constraint df__groups_users_history_in default sysutcdatetime(),
+        history_date datetime2 not null constraint df__groups_users_history_date default sysutcdatetime(),
         constraint pk__groups_users primary key clustered(id), 
+        constraint fk__groups_users_history_mode foreign key(history_mode) references dbo.HistoryModes(id) 
+            on update no action 
+            on delete no action,
         constraint fk__groups_users_procedure foreign key([procedure]) references dbo.Procedures(id) 
             on update no action 
             on delete no action,
@@ -135,6 +145,7 @@ create procedure dbo.groups_tables_create as begin set nocount on
 
     if object_id(N'dbo._GroupsIps', N'U') is null create table dbo._GroupsIps(
         id integer not null identity(1, 1), 
+        history_mode integer not null, 
         entity integer not null, 
         [procedure] integer not null, 
         [session] integer not null, 
@@ -143,8 +154,11 @@ create procedure dbo.groups_tables_create as begin set nocount on
         belongs bit not null,
         date_in datetime not null, 
         date_out datetime, 
-        history_date datetime2 not null constraint df__groups_ips_history_in default sysutcdatetime(),
+        history_date datetime2 not null constraint df__groups_ips_history_date default sysutcdatetime(),
         constraint pk__groups_ips primary key clustered(id), 
+        constraint fk__groups_ips_history_mode foreign key(history_mode) references dbo.HistoryModes(id) 
+            on update no action 
+            on delete no action,
         constraint fk__groups_ips_procedure foreign key([procedure]) references dbo.Procedures(id) 
             on update no action 
             on delete no action,
@@ -173,28 +187,29 @@ create trigger dbo.groups_trigger on dbo.Groups for insert, update, delete as be
     execute dbo.history_mode_get @insert output, @update output, @delete output, @unknown output
 
     -- update.
-    insert into dbo._Groups(mode, entity, [procedure], [session], [name], [description], date_in, date_out) 
-    select @update, inserted.id, inserted.[procedure], inserted.[session], inserted.[name], inserted.[description], inserted.date_in, inserted.date_out 
+    insert into dbo._Groups(history_mode, entity, [procedure], [session], [name], [owner], [description], date_in, date_out) 
+    select @update, inserted.id, inserted.[procedure], inserted.[session], inserted.[name], inserted.[owner], inserted.[description], inserted.date_in, inserted.date_out 
     from inserted inserted 
     join deleted deleted on inserted.id = deleted.id 
     where 
         inserted.[procedure] != deleted.[procedure] or 
         inserted.[session] != deleted.[session] or 
         inserted.[name] != deleted.[name] or 
+        inserted.[owner] != deleted.[owner] or 
         inserted.[description] != deleted.[description] or 
         inserted.date_in != deleted.date_in or 
         isnull(inserted.date_out, '0001-01-01') != isnull(deleted.date_out, '0001-01-01')
 
     -- Insert.
-    insert into dbo._Groups(mode, entity, [procedure], [session], [name], [description], date_in, date_out) 
-    select @insert, inserted.id, inserted.[procedure], inserted.[session], inserted.[name], inserted.[description], inserted.date_in, inserted.date_out 
+    insert into dbo._Groups(history_mode, entity, [procedure], [session], [name], [owner], [description], date_in, date_out) 
+    select @insert, inserted.id, inserted.[procedure], inserted.[session], inserted.[name], inserted.[owner], inserted.[description], inserted.date_in, inserted.date_out 
     from inserted inserted 
     left join deleted deleted on inserted.id = deleted.id 
     where deleted.id is null
 
     -- deleted.
-    insert into dbo._Groups(mode, entity, [procedure], [session], [name], [description], date_in, date_out) 
-    select @delete, deleted.id, deleted.[procedure], deleted.[session], deleted.[name], deleted.[description], deleted.date_in, deleted.date_out 
+    insert into dbo._Groups(history_mode, entity, [procedure], [session], [name], [owner], [description], date_in, date_out) 
+    select @delete, deleted.id, deleted.[procedure], deleted.[session], deleted.[name], deleted.[owner], deleted.[description], deleted.date_in, deleted.date_out 
     from deleted deleted 
     left join inserted inserted on deleted.id = inserted.id 
     where inserted.id is null
@@ -211,7 +226,7 @@ create trigger dbo.groups_users_trigger on dbo.GroupsUsers for insert, update, d
     execute dbo.history_mode_get @insert output, @update output, @delete output, @unknown output
 
     -- update.
-    insert into dbo._GroupsUsers(mode, entity, [procedure], [session], [group], [user], belongs, date_in, date_out) 
+    insert into dbo._GroupsUsers(history_mode, entity, [procedure], [session], [group], [user], belongs, date_in, date_out) 
     select @update, inserted.id, inserted.[procedure], inserted.[session], inserted.[group], inserted.[user], inserted.belongs, inserted.date_in, inserted.date_out 
     from inserted inserted 
     join deleted deleted on inserted.id = deleted.id 
@@ -225,14 +240,14 @@ create trigger dbo.groups_users_trigger on dbo.GroupsUsers for insert, update, d
         isnull(inserted.date_out, '0001-01-01') != isnull(deleted.date_out, '0001-01-01')
 
     -- Insert.
-    insert into dbo._GroupsUsers(mode, entity, [procedure], [session], [group], [user], belongs, date_in, date_out) 
+    insert into dbo._GroupsUsers(history_mode, entity, [procedure], [session], [group], [user], belongs, date_in, date_out) 
     select @insert, inserted.id, inserted.[procedure], inserted.[session], inserted.[group], inserted.[user], inserted.belongs, inserted.date_in, inserted.date_out 
     from inserted inserted 
     left join deleted deleted on inserted.id = deleted.id 
     where deleted.id is null
 
     -- deleted.
-    insert into dbo._GroupsUsers(mode, entity, [procedure], [session], [group], [user], belongs, date_in, date_out) 
+    insert into dbo._GroupsUsers(history_mode, entity, [procedure], [session], [group], [user], belongs, date_in, date_out) 
     select @delete, deleted.id, deleted.[procedure], deleted.[session], deleted.[group], deleted.[user], deleted.belongs, deleted.date_in, deleted.date_out 
     from deleted deleted 
     left join inserted inserted on deleted.id = inserted.id 
@@ -250,7 +265,7 @@ create trigger dbo.groups_ips_trigger on dbo.GroupsIps for insert, update, delet
     execute dbo.history_mode_get @insert output, @update output, @delete output, @unknown output
 
     -- update.
-    insert into dbo._GroupsIps(mode, entity, [procedure], [session], [group], [ip], belongs, date_in, date_out) 
+    insert into dbo._GroupsIps(history_mode, entity, [procedure], [session], [group], [ip], belongs, date_in, date_out) 
     select @update, inserted.id, inserted.[procedure], inserted.[session], inserted.[group], inserted.[ip], inserted.belongs, inserted.date_in, inserted.date_out 
     from inserted inserted 
     join deleted deleted on inserted.id = deleted.id 
@@ -264,14 +279,14 @@ create trigger dbo.groups_ips_trigger on dbo.GroupsIps for insert, update, delet
         isnull(inserted.date_out, '0001-01-01') != isnull(deleted.date_out, '0001-01-01')
 
     -- Insert.
-    insert into dbo._GroupsIps(mode, entity, [procedure], [session], [group], [ip], belongs, date_in, date_out) 
+    insert into dbo._GroupsIps(history_mode, entity, [procedure], [session], [group], [ip], belongs, date_in, date_out) 
     select @insert, inserted.id, inserted.[procedure], inserted.[session], inserted.[group], inserted.[ip], inserted.belongs, inserted.date_in, inserted.date_out 
     from inserted inserted 
     left join deleted deleted on inserted.id = deleted.id 
     where deleted.id is null
 
     -- deleted.
-    insert into dbo._GroupsIps(mode, entity, [procedure], [session], [group], [ip], belongs, date_in, date_out) 
+    insert into dbo._GroupsIps(history_mode, entity, [procedure], [session], [group], [ip], belongs, date_in, date_out) 
     select @delete, deleted.id, deleted.[procedure], deleted.[session], deleted.[group], deleted.[ip], deleted.belongs, deleted.date_in, deleted.date_out 
     from deleted deleted 
     left join inserted inserted on deleted.id = inserted.id 

SQLServer/AnP.06.settings.server.sql

@@ -27,8 +27,6 @@ create procedure dbo.settings_tables_create as begin set nocount on
         [description] varchar(512) not null, 
         date_in datetime not null constraint df_settings_types_date_in default getdate(), 
         date_out datetime, 
-        history_in datetime2 generated always as row start hidden not null constraint df_settings_types_history_in default sysutcdatetime(), 
-        history_out datetime2 generated always as row end hidden not null constraint df_settings_types_history_out default convert(datetime2, '9999-12-31 23:59:59.9999999'),
         constraint pk_settings_types primary key clustered(id), 
         constraint fk_settings_types_procedure foreign key([procedure]) references dbo.Procedures(id) 
             on update no action 
@@ -51,8 +49,6 @@ create procedure dbo.settings_tables_create as begin set nocount on
         [description] varchar(512) not null, 
         date_in datetime not null constraint df_settings_date_in default getdate(), 
         date_out datetime, 
-        history_in datetime2 generated always as row start hidden not null constraint df_settings_history_in default sysutcdatetime(), 
-        history_out datetime2 generated always as row end hidden not null constraint df_settings_history_out default convert(datetime2, '9999-12-31 23:59:59.9999999'),
         constraint pk_settings primary key clustered(id), 
         constraint fk_settings_procedure foreign key([procedure]) references dbo.Procedures(id) 
             on update no action 
@@ -73,11 +69,9 @@ create procedure dbo.settings_tables_create as begin set nocount on
         [session] integer not null, 
         [settings] integer not null, 
         [group] integer not null,
-        belongs bit not null constraint df_settings_groups_belongs default 1,
+        [value] varchar(max),
         date_in datetime not null constraint df_settings_groups_date_in default getdate(), 
         date_out datetime, 
-        history_in datetime2 generated always as row start hidden not null constraint df_settings_groups_history_in default sysutcdatetime(), 
-        history_out datetime2 generated always as row end hidden not null constraint df_settings_groups_history_out default convert(datetime2, '9999-12-31 23:59:59.9999999'),
         constraint pk_settings_groups primary key clustered(id), 
         constraint fk_settings_groups_procedure foreign key([procedure]) references dbo.Procedures(id) 
             on update no action 
@@ -96,14 +90,19 @@ create procedure dbo.settings_tables_create as begin set nocount on
 
     if object_id(N'dbo._SettingsTypes', N'U') is null create table dbo._SettingsTypes(
         id integer not null identity(1, 1), 
+        history_mode integer not null,
+        entity integer not null, 
         [procedure] integer not null, 
         [session] integer not null, 
         [name] varchar(32) not null, 
         [description] varchar(512) not null, 
-        date_in datetime not null constraint df__settings_types_date_in default getdate(), 
+        date_in datetime not null constraint df__settings_types_date_date default getdate(), 
         date_out datetime, 
         history_date datetime2 not null constraint df__settings_types_history_date default sysutcdatetime(), 
         constraint pk__settings_types primary key clustered(id), 
+        constraint fk__settings_types_history_mode foreign key(history_mode) references dbo.HistoryModes(id) 
+            on update no action 
+            on delete no action,
         constraint fk__settings_types_procedure foreign key([procedure]) references dbo.Procedures(id) 
             on update no action 
             on delete no action,
@@ -114,6 +113,8 @@ create procedure dbo.settings_tables_create as begin set nocount on
 
     if object_id(N'dbo._Settings', N'U') is null create table dbo._Settings(
         id integer not null identity(1, 1), 
+        history_mode integer not null,
+        entity integer not null, 
         [procedure] integer not null, 
         [session] integer not null, 
         [type] integer not null, 
@@ -121,10 +122,13 @@ create procedure dbo.settings_tables_create as begin set nocount on
         [value] varchar(max), 
         [default] varchar(max), 
         [description] varchar(512) not null, 
-        date_in datetime not null constraint df_settings_date_in default getdate(), 
+        date_in datetime not null constraint df_settings_date_date default getdate(), 
         date_out datetime, 
-        history_date datetime2 generated always as row start hidden not null constraint df__settings_history_date default sysutcdatetime(), 
+        history_date datetime2 not null constraint df__settings_history_date default sysutcdatetime(), 
         constraint pk__settings primary key clustered(id), 
+        constraint fk__settings_history_mode foreign key(history_mode) references dbo.HistoryModes(id) 
+            on update no action 
+            on delete no action,
         constraint fk__settings_procedure foreign key([procedure]) references dbo.Procedures(id) 
             on update no action 
             on delete no action,
@@ -138,17 +142,22 @@ create procedure dbo.settings_tables_create as begin set nocount on
         constraint ck__settings_name check([name] != '' and [name] not like '%[^a-zA-Z0-9_]%' and [name] not like '[^a-zA-Z_]%')
     )
 
-    if object_id(N'dbo.SettingsGroups', N'U') is null create table dbo._SettingsGroups(
+    if object_id(N'dbo._SettingsGroups', N'U') is null create table dbo._SettingsGroups(
         id integer not null identity(1, 1), 
+        history_mode integer not null,
+        entity integer not null, 
         [procedure] integer not null, 
         [session] integer not null, 
         [settings] integer not null, 
         [group] integer not null,
-        belongs bit not null,
+        [value] varchar(max),
         date_in datetime not null, 
         date_out datetime, 
         history_date datetime2 not null constraint df__settings_groups_history_date default sysutcdatetime(), 
         constraint pk__settings_groups primary key clustered(id), 
+        constraint fk__settings_groups_history_mode foreign key(history_mode) references dbo.HistoryModes(id) 
+            on update no action 
+            on delete no action,
         constraint fk__settings_groups_procedure foreign key([procedure]) references dbo.Procedures(id) 
             on update no action 
             on delete no action,
@@ -178,7 +187,7 @@ create trigger dbo.settings_types_trigger on dbo.SettingsTypes for insert, updat
     execute dbo.history_mode_get @insert output, @update output, @delete output, @unknown output
 
     -- update.
-    insert into dbo._SettingsTypes(mode, entity, [procedure], [session], [name], [description], date_in, date_out) 
+    insert into dbo._SettingsTypes(history_mode, entity, [procedure], [session], [name], [description], date_in, date_out) 
     select @update, inserted.id, inserted.[procedure], inserted.[session], inserted.[name], inserted.[description], inserted.date_in, inserted.date_out 
     from inserted inserted 
     join deleted deleted on inserted.id = deleted.id 
@@ -191,14 +200,14 @@ create trigger dbo.settings_types_trigger on dbo.SettingsTypes for insert, updat
         isnull(inserted.date_out, '0001-01-01') != isnull(deleted.date_out, '0001-01-01')
 
     -- Insert.
-    insert into dbo._SettingsTypes(mode, entity, [procedure], [session], [name], [description], date_in, date_out) 
+    insert into dbo._SettingsTypes(history_mode, entity, [procedure], [session], [name], [description], date_in, date_out) 
     select @insert, inserted.id, inserted.[procedure], inserted.[session], inserted.[name], inserted.[description], inserted.date_in, inserted.date_out 
     from inserted inserted 
     left join deleted deleted on inserted.id = deleted.id 
     where deleted.id is null
 
     -- deleted.
-    insert into dbo._SettingsTypes(mode, entity, [procedure], [session], [name], [description], date_in, date_out) 
+    insert into dbo._SettingsTypes(history_mode, entity, [procedure], [session], [name], [description], date_in, date_out) 
     select @delete, deleted.id, deleted.[procedure], deleted.[session], deleted.[name], deleted.[description], deleted.date_in, deleted.date_out 
     from deleted deleted 
     left join inserted inserted on deleted.id = inserted.id 
@@ -216,7 +225,7 @@ create trigger dbo.settings_trigger on dbo.Settings for insert, update, delete a
     execute dbo.history_mode_get @insert output, @update output, @delete output, @unknown output
 
     -- update.
-    insert into dbo._Settings(mode, entity, [procedure], [session], [type], [name], [value], [default], [description], date_in, date_out) 
+    insert into dbo._Settings(history_mode, entity, [procedure], [session], [type], [name], [value], [default], [description], date_in, date_out) 
     select @update, inserted.id, inserted.[procedure], inserted.[session], inserted.[type], inserted.[name], inserted.[value], inserted.[default], inserted.[description], inserted.date_in, inserted.date_out 
     from inserted inserted 
     join deleted deleted on inserted.id = deleted.id 
@@ -232,14 +241,14 @@ create trigger dbo.settings_trigger on dbo.Settings for insert, update, delete a
         isnull(inserted.date_out, '0001-01-01') != isnull(deleted.date_out, '0001-01-01')
 
     -- Insert.
-    insert into dbo._Settings(mode, entity, [procedure], [session], [type], [name], [value], [default], [description], date_in, date_out) 
+    insert into dbo._Settings(history_mode, entity, [procedure], [session], [type], [name], [value], [default], [description], date_in, date_out) 
     select @insert, inserted.id, inserted.[procedure], inserted.[session], inserted.[type], inserted.[name], inserted.[value], inserted.[default], inserted.[description], inserted.date_in, inserted.date_out 
     from inserted inserted 
     left join deleted deleted on inserted.id = deleted.id 
     where deleted.id is null
 
     -- deleted.
-    insert into dbo._Settings(mode, entity, [procedure], [session], [type], [name], [value], [default], [description], date_in, date_out) 
+    insert into dbo._Settings(history_mode, entity, [procedure], [session], [type], [name], [value], [default], [description], date_in, date_out) 
     select @delete, deleted.id, deleted.[procedure], deleted.[session], deleted.[type], deleted.[name], deleted.[value], deleted.[default], deleted.[description], deleted.date_in, deleted.date_out 
     from deleted deleted 
     left join inserted inserted on deleted.id = inserted.id 
@@ -257,7 +266,7 @@ create trigger dbo.settings_groups_trigger on dbo.SettingsGroups for insert, upd
     execute dbo.history_mode_get @insert output, @update output, @delete output, @unknown output
 
     -- update.
-    insert into dbo._SettingsGroups(mode, entity, [procedure], [session], [settings], [group], [value], date_in, date_out) 
+    insert into dbo._SettingsGroups(history_mode, entity, [procedure], [session], [settings], [group], [value], date_in, date_out) 
     select @update, inserted.id, inserted.[procedure], inserted.[session], inserted.[settings], inserted.[group], inserted.[value], inserted.date_in, inserted.date_out 
     from inserted inserted 
     join deleted deleted on inserted.id = deleted.id 
@@ -271,14 +280,14 @@ create trigger dbo.settings_groups_trigger on dbo.SettingsGroups for insert, upd
         isnull(inserted.date_out, '0001-01-01') != isnull(deleted.date_out, '0001-01-01')
 
     -- Insert.
-    insert into dbo._SettingsGroups(mode, entity, [procedure], [session], [session], [settings], [group], [value], date_in, date_out) 
+    insert into dbo._SettingsGroups(history_mode, entity, [procedure], [session], [settings], [group], [value], date_in, date_out) 
     select @insert, inserted.id, inserted.[procedure], inserted.[session], inserted.[settings], inserted.[group], inserted.[value], inserted.date_in, inserted.date_out 
     from inserted inserted 
     left join deleted deleted on inserted.id = deleted.id 
     where deleted.id is null
 
     -- deleted.
-    insert into dbo._SettingsGroups(mode, entity, [procedure], [session], [session], [settings], [group], [value], date_in, date_out) 
+    insert into dbo._SettingsGroups(history_mode, entity, [procedure], [session], [settings], [group], [value], date_in, date_out) 
     select @delete, deleted.id, deleted.[procedure], deleted.[session], deleted.[settings], deleted.[group], deleted.[value], deleted.date_in, deleted.date_out 
     from deleted deleted 
     left join inserted inserted on deleted.id = inserted.id 

SQLServer/AnP.07.logs.server.sql

@@ -168,7 +168,7 @@ create procedure dbo.logs_set(
     @level integer = 1
 ) as begin set nocount on 
 
-    declare @levels integer = dbo.settings_get_int('logs_levels', 15)
+    declare @levels integer = dbo.settings_get_int('logs_levels', null, 15)
 
     if @levels & @level != 0 begin 
         

SQLServer/AnP.08.permissions.server.sql

@@ -4,9 +4,6 @@ if object_id(N'dbo.permissions_tables_remove', N'P') is not null drop procedure
 go
 create procedure dbo.permissions_tables_remove as begin set nocount on 
 
-    if object_id(N'dbo.PermissionsGroups', N'U') is not null execute sp_executesql N'alter table dbo.PermissionsGroups set (system_versioning = off)'
-    if object_id(N'dbo.Permissions', N'U') is not null execute sp_executesql N'alter table dbo.Permissions set (system_versioning = off)'
-
     if object_id(N'dbo._PermissionsGroups', N'U') is not null drop table dbo._PermissionsGroups
     if object_id(N'dbo._Permissions', N'U') is not null drop table dbo._Permissions
 
@@ -20,8 +17,53 @@ if object_id(N'dbo.permissions_tables_create', N'P') is not null drop procedure
 go
 create procedure dbo.permissions_tables_create as begin set nocount on 
 
+    if object_id(N'dbo.Permissions', N'U') is null create table dbo.Permissions(
+        id integer not null identity(1, 1), 
+        [procedure] integer not null, 
+        [session] integer not null, 
+        [name] varchar(64) not null, 
+        [description] varchar(512) not null, 
+        date_in datetime not null constraint df_permissions_date_in default getdate(), 
+        date_out datetime, 
+        constraint pk_permissions primary key clustered(id), 
+        constraint fk_permissions_procedure foreign key([procedure]) references dbo.Procedures(id) 
+            on update no action 
+            on delete no action,
+        constraint fk_permissions_session foreign key([session]) references dbo.Sessions(id) 
+            on update no action 
+            on delete no action,
+        constraint uq_permissions_name unique([name]) with(fillfactor = 90), 
+        constraint ck_permissions_name check([name] != '' and [name] not like '%[^a-zA-Z0-9_]%' and [name] not like '[^a-zA-Z_]%')
+    )
+
+    if object_id(N'dbo.PermissionsGroups', N'U') is null create table dbo.PermissionsGroups(
+        id integer not null identity(1, 1), 
+        [procedure] integer not null, 
+        [session] integer not null, 
+        permission integer not null, 
+        [group] integer not null,
+        belongs bit not null constraint df_permissions_groups_belongs default 1,
+        date_in datetime not null constraint df_permissions_groups_date_in default getdate(), 
+        date_out datetime, 
+        constraint pk_permissions_groups primary key clustered(id), 
+        constraint fk_permissions_groups_procedure foreign key([procedure]) references dbo.Procedures(id) 
+            on update no action 
+            on delete no action,
+        constraint fk_permissions_groups_session foreign key([session]) references dbo.Sessions(id) 
+            on update no action 
+            on delete no action, 
+        constraint fk_permissions_groups_permission foreign key(permission) references dbo.Permissions(id) 
+            on update no action 
+            on delete no action,
+        constraint fk_permissions_groups_group foreign key([group]) references dbo.Users(id) 
+            on update no action
+            on delete no action, 
+        constraint uq_permissions_groups unique(permission, [group]) with(fillfactor = 90)
+    )
+
     if object_id(N'dbo._Permissions', N'U') is null create table dbo._Permissions(
         id integer not null identity(1, 1), 
+        history_mode integer not null, 
         entity integer not null, 
         [procedure] integer not null, 
         [session] integer not null, 
@@ -29,14 +71,21 @@ create procedure dbo.permissions_tables_create as begin set nocount on
         [description] varchar(512) not null, 
         date_in datetime not null, 
         date_out datetime, 
-        history_in datetime2 not null, 
-        history_out datetime2 not null, 
         constraint pk__permissions primary key clustered(id), 
-        index ix__permissions_history nonclustered(entity, history_out, history_in)
+        constraint fk__permissions_history_mode foreign key(history_mode) references dbo.HistoryModes(id) 
+            on update no action 
+            on delete no action,
+        constraint fk__permissions_procedure foreign key([procedure]) references dbo.Procedures(id) 
+            on update no action 
+            on delete no action,
+        constraint fk__permissions_session foreign key([session]) references dbo.Sessions(id) 
+            on update no action 
+            on delete no action
     )
 
     if object_id(N'dbo._PermissionsGroups', N'U') is null create table dbo._PermissionsGroups(
         id integer not null identity(1, 1), 
+        history_mode integer not null,
         entity integer not null, 
         [procedure] integer not null, 
         [session] integer not null, 
@@ -45,69 +94,102 @@ create procedure dbo.permissions_tables_create as begin set nocount on
         belongs bit not null,
         date_in datetime not null, 
         date_out datetime, 
-        history_in datetime2 not null, 
-        history_out datetime2 not null,
-        constraint pk_permissions_groups primary key clustered(id), 
-        index ix__permissions_groups_history nonclustered(entity, history_out, history_in)
+        constraint pk__permissions_groups primary key clustered(id), 
+        constraint fk__permissions_groups_history_mode foreign key(history_mode) references dbo.HistoryModes(id) 
+            on update no action 
+            on delete no action,
+        constraint fk__permissions_groups_procedure foreign key([procedure]) references dbo.Procedures(id) 
+            on update no action 
+            on delete no action,
+        constraint fk__permissions_groups_session foreign key([session]) references dbo.Sessions(id) 
+            on update no action 
+            on delete no action, 
+        constraint fk__permissions_groups_permission foreign key(permission) references dbo.Permissions(id) 
+            on update no action 
+            on delete no action,
+        constraint fk__permissions_groups_group foreign key([group]) references dbo.Users(id) 
+            on update no action
+            on delete no action
     )
 
-    if object_id(N'dbo.Permissions', N'U') is null begin 
-        create table dbo.Permissions(
-            id integer not null identity(1, 1), 
-            [procedure] integer not null, 
-            [session] integer not null, 
-            [name] varchar(64) not null, 
-            [description] varchar(512) not null, 
-            date_in datetime not null constraint df_permissions_date_in default getdate(), 
-            date_out datetime, 
-            history_in datetime2 generated always as row start hidden not null constraint df_permissions_history_in default sysutcdatetime(), 
-            history_out datetime2 generated always as row end hidden not null constraint df_permissions_history_out default convert(datetime2, '9999-12-31 23:59:59.9999999'),
-            constraint pk_permissions primary key clustered(id), 
-            constraint fk_permissions_procedure foreign key([procedure]) references dbo.Procedures(id) 
-                on update no action 
-                on delete no action,
-            constraint fk_permissions_session foreign key([session]) references dbo.Sessions(id) 
-                on update no action 
-                on delete no action,
-            constraint uq_permissions_name unique([name]) with(fillfactor = 90), 
-            constraint ck_permissions_name check([name] != '' and [name] not like '%[^a-zA-Z0-9_]%' and [name] not like '[^a-zA-Z_]%'), 
-            period for system_time(history_in, history_out)
-        )
-        execute sp_executesql N'alter table dbo.Permissions set (system_versioning = on (history_table = dbo._Permissions, data_consistency_check = on))'
-    end
-
-    if object_id(N'dbo.PermissionsGroups', N'U') is null begin 
-        create table dbo._PermissionsGroups(
-            id integer not null identity(1, 1), 
-            [procedure] integer not null, 
-            [session] integer not null, 
-            permission integer not null, 
-            [group] integer not null,
-            belongs bit not null constraint df_permissions_groups_belongs default 1,
-            date_in datetime not null constraint df_permissions_groups_date_in default getdate(), 
-            date_out datetime, 
-            history_in datetime2 generated always as row start hidden not null constraint df_permissions_groups_history_in default sysutcdatetime(), 
-            history_out datetime2 generated always as row end hidden not null constraint df_permissions_groups_history_out default convert(datetime2, '9999-12-31 23:59:59.9999999'),
-            constraint pk_permissions_groups primary key clustered(id), 
-            constraint fk_permissions_groups_procedure foreign key([procedure]) references dbo.Procedures(id) 
-                on update no action 
-                on delete no action,
-            constraint fk_permissions_groups_session foreign key([session]) references dbo.Sessions(id) 
-                on update no action 
-                on delete no action, 
-            constraint fk_permissions_groups_permission foreign key(permission) references dbo.Permissions(id) 
-                on update no action 
-                on delete no action,
-            constraint fk_permissions_groups_group foreign key([group]) references dbo.Users(id) 
-                on update no action
-                on delete no action, 
-            constraint uq_permissions_groups unique(permission, [group]) with(fillfactor = 90), 
-            period for system_time(history_in, history_out)
-        )
-        execute sp_executesql N'alter table dbo.PermissionsGroups set (system_versioning = on (history_table = dbo._PermissionsGroups, data_consistency_check = on))'
-    end
-
 end
 go
 
 execute dbo.permissions_tables_create
+
+if object_id(N'dbo.permissions_trigger', N'TR') is not null drop trigger dbo.permissions_trigger
+go
+create trigger dbo.permissions_trigger on dbo.Permissions for insert, update, delete as begin set nocount on 
+
+    declare @insert integer, @update integer, @delete integer, @unknown integer
+
+    execute dbo.history_mode_get @insert output, @update output, @delete output, @unknown output
+
+    -- update.
+    insert into dbo._Permissions(history_mode, entity, [procedure], [session], [name], [description], date_in, date_out) 
+    select @update, inserted.id, inserted.[procedure], inserted.[session], inserted.[name], inserted.[description], inserted.date_in, inserted.date_out 
+    from inserted inserted 
+    join deleted deleted on inserted.id = deleted.id 
+    where 
+        inserted.[procedure] != deleted.[procedure] or 
+        inserted.[session] != deleted.[session] or 
+        inserted.[name] != deleted.[name] or 
+        inserted.[description] != deleted.[description] or 
+        inserted.date_in != deleted.date_in or 
+        isnull(inserted.date_out, '0001-01-01') != isnull(deleted.date_out, '0001-01-01')
+
+    -- Insert.
+    insert into dbo._Permissions(history_mode, entity, [procedure], [session], [name], [description], date_in, date_out) 
+    select @insert, inserted.id, inserted.[procedure], inserted.[session], inserted.[name], inserted.[description], inserted.date_in, inserted.date_out 
+    from inserted inserted 
+    left join deleted deleted on inserted.id = deleted.id 
+    where deleted.id is null
+
+    -- deleted.
+    insert into dbo._Permissions(history_mode, entity, [procedure], [session], [name], [description], date_in, date_out) 
+    select @delete, deleted.id, deleted.[procedure], deleted.[session], deleted.[name], deleted.[description], deleted.date_in, deleted.date_out 
+    from deleted deleted 
+    left join inserted inserted on deleted.id = inserted.id 
+    where inserted.id is null
+
+end
+go
+
+if object_id(N'dbo.permissions_groups_trigger', N'TR') is not null drop trigger dbo.permissions_groups_trigger
+go
+create trigger dbo.permissions_groups_trigger on dbo.PermissionsGroups for insert, update, delete as begin set nocount on 
+
+    declare @insert integer, @update integer, @delete integer, @unknown integer
+
+    execute dbo.history_mode_get @insert output, @update output, @delete output, @unknown output
+
+    -- update.
+    insert into dbo._PermissionsGroups(history_mode, entity, [procedure], [session], [permission], [group], belongs, date_in, date_out) 
+    select @update, inserted.id, inserted.[procedure], inserted.[session], inserted.[permission], inserted.[group], inserted.belongs, inserted.date_in, inserted.date_out 
+    from inserted inserted 
+    join deleted deleted on inserted.id = deleted.id 
+    where 
+        inserted.[procedure] != deleted.[procedure] or 
+        inserted.[session] != deleted.[session] or 
+        inserted.[permission] != deleted.[permission] or 
+        inserted.[group] != deleted.[group] or 
+        inserted.belongs != deleted.belongs or 
+        inserted.date_in != deleted.date_in or 
+        isnull(inserted.date_out, '0001-01-01') != isnull(deleted.date_out, '0001-01-01')
+
+    -- Insert.
+    insert into dbo._PermissionsGroups(history_mode, entity, [procedure], [session], [permission], [group], belongs, date_in, date_out) 
+    select @insert, inserted.id, inserted.[procedure], inserted.[session], inserted.[permission], inserted.[group], inserted.belongs, inserted.date_in, inserted.date_out 
+    from inserted inserted 
+    left join deleted deleted on inserted.id = deleted.id 
+    where deleted.id is null
+
+    -- deleted.
+    insert into dbo._PermissionsGroups(history_mode, entity, [procedure], [session], [permission], [group], belongs, date_in, date_out) 
+    select @delete, deleted.id, deleted.[procedure], deleted.[session], deleted.[permission], deleted.[group], deleted.belongs, deleted.date_in, deleted.date_out 
+    from deleted deleted 
+    left join inserted inserted on deleted.id = inserted.id 
+    where inserted.id is null
+
+end
+go

SQLServer/AnP.09.fill.server.sql

@@ -4,11 +4,13 @@ if object_id(N'dbo.common_tables_fill', N'P') is not null drop procedure dbo.com
 go
 create procedure dbo.common_tables_fill as begin set nocount on 
 
-    declare @database varchar(64) = dbname()
+    declare @database varchar(64) = db_name()
     declare @machine integer = dbo.machine_session_get()
     declare @procedure integer
+    declare @machine_user varchar(32) = 'machine'
+    declare @machine_ip varchar(39) = '::1'
     declare @machine_user_id integer = (select top 1 id from dbo.Users where nick = @machine_user)
-    declare @machine_ip_id integer = (select top 1 id from dbo.Ips where ip = @machine_ip)
+    declare @machine_ip_id integer = (select top 1 id from dbo.Ips where [address] = @machine_ip)
     declare @guest_user_id integer = (select top 1 id from dbo.Users where nick = 'guest')
     declare @guest_group_id integer = (select top 1 id from dbo.Groups where [name] = 'guest' and date_out is null)
     declare @root_group_id integer = (select top 1 id from dbo.Groups where [name] = 'root' and date_out is null)
@@ -20,15 +22,12 @@ create procedure dbo.common_tables_fill as begin set nocount on
 
     if @machine is null begin 
 
-        declare @machine_user varchar(32) = 'machine'
-        declare @machine_ip varchar(39) = '::1'
+        declare @group integer
 
         set @machine = 1
 
         if @machine_user_id is null begin 
 
-            declare @group integer
-
             insert into dbo.Users([procedure], [session], nick, [password], accessible) values 
                 (@procedure, @machine, @machine_user, hashbytes('SHA2_512', ''), 0)
             set @machine_user_id = scope_identity()
@@ -43,9 +42,7 @@ create procedure dbo.common_tables_fill as begin set nocount on
 
         if @machine_ip_id is null begin 
 
-            declare @group integer
-
-            insert into dbo.Ips ([procedure], [session], ip) values 
+            insert into dbo.Ips([procedure], [session], [address]) values 
                 (@procedure, @machine, @machine_ip)
             set @machine_ip_id = scope_identity()
 
@@ -65,11 +62,11 @@ create procedure dbo.common_tables_fill as begin set nocount on
             set @machine = scope_identity()
         end
 
-        if (select top 1 0 from dbo.Users where id = @user_id and [session] = @session) is null begin 
+        if (select top 1 0 from dbo.Users where id = @machine_user_id and [session] = @machine) is null begin 
             update dbo.Users set [session] = @machine where id = @machine_user_id
             delete from dbo._Users where [session] != @machine
         end
-        if (select top 1 0 from dbo.Ips where id = @ip_id and [session] = @session) is null begin 
+        if (select top 1 0 from dbo.Ips where id = @machine_ip_id and [session] = @machine) is null begin 
             update dbo.Ips set [session] = @machine where id = @machine_ip_id
             delete from dbo._Ips where [session] != @machine
         end
@@ -141,3 +138,5 @@ create procedure dbo.common_tables_fill as begin set nocount on
 
 end
 go
+
+execute dbo.common_tables_fill

SQLServer/AnP.10.common.server.sql

@@ -22,14 +22,12 @@ create procedure tables_list(
 	@pages integer output,
 	@items integer output,
 	@results integer output
-) as begin 
+) as begin set nocount on 
 		
 	declare @item_from integer
 	declare @query nvarchar(max)
 	declare @where_string varchar(max)
 
-	set nocount on
-
 	if @has_errors = 1
 		set @where = dbo.where_set('0 = 1', @where)
 	set @where_string = (case when isnull(@where, '') = '' then '' else ' where ' + @where end)

Tools/dockers.execute.bat

@@ -0,0 +1,11 @@
+@echo off
+
+set "directory=%cd%"
+
+cd %~dp0\..
+
+call Tools\dockers.stop.bat
+docker images -q anp:sql-server | findstr "anp-sql-server">null || call Dockers\SQLServer\rebuild.bat
+docker compose up -d
+
+cd %directory%

Tools/dockers.execute.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+directory=`dirname $(readlink -f "$0")`
+
+cd $directory
+./dockers.stop.sh
+cd $directory/..
+[ -z "$(docker images -q anp:sql-server 2>/dev/null)" ] && ./Dockers/SQLServer/rebuild.sh
+docker compose up -d

Tools/dockers.stop.bat

@@ -0,0 +1,8 @@
+@echo off
+
+set "directory=%cd%"
+
+cd %~dp0\..
+docker compose down
+
+cd %directory%

Tools/dockers.stop.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+directory=`dirname $(readlink -f "$0")`
+
+cd $directory/..
+docker compose down

Tools/sqlserver.install.bat

@@ -1,22 +1,24 @@
 @echo off
 
-set "transact_sql_host=127.0.0.1"
-set "transact_sql_port=1433"
-set "transact_sql_user=sa"
-set "transact_sql_password="
+set "current_path=%cd%"
+set "sql_server_host=127.0.0.1"
+set "sql_server_port=1433"
+set "sql_server_user=sa"
+set "sql_server_password="
 
-if exist Secrets.cmd (
-    call Secrets.cmd
+cd %~dp0\..
+
+if exist Tools\sqlserver.secrets.cmd (
+    call Tools\sqlserver.secrets.cmd
 )
 
-where sqlcmd > NUL
-if %errorlevel% neq 0 (
-    echo "Please, install 'sqlcmd' for use the Scripts via CMD."
-) else (
-    for /D %%d in (%cd%\..\SQLServer\AnP.*) do (
-        for %%f in (%%d\*.sql) do (
-            echo %%f
-            sqlcmd -S %transact_sql_host%,%transact_sql_port% -U %transact_sql_user% -P %transact_sql_password% -i %%f
-        )
+docker compose ps | findstr "anp-sql-server" >nul || call Tools\dockers.execute.bat
+
+for /D %%d in (SQLServer\AnP.*) do (
+    for %%f in (%%d\*.sql) do (
+        echo %%f
+        docker exec -i anp-sql-server /opt/mssql-tools18/bin/sqlcmd -S %sql_server_host%,%sql_server_port% -U %sql_server_user% -P %sql_server_password% -i < %%f
     )
 )
+
+cd %current_path%

Tools/sqlserver.install.sh

@@ -1,21 +1,20 @@
 #!/bin/bash
 
 directory=`dirname $(readlink -f "$0")`
+sql_server_host="127.0.0.1"
+sql_server_port="1433"
+sql_server_user="sa"
+sql_server_password=""
 
-if command -v sqlcmd &> /dev/null; then
+[[ -f $directory/sqlserver.secrets.sh ]] && source $directory/sqlserver.secrets.sh
 
-	transact_sql_host="127.0.0.1"
-	transact_sql_port="1433"
-	transact_sql_user="sa"
-	transact_sql_password=""
-
-	[[ -f Secrets.sh ]] && source Secrets.sh
-
-	for i in $(find $directory/../SQLServer -type f|grep .sql|sort|cat); do
-		echo $i
-        sqlcmd -S $transact_sql_host,$transact_sql_port -U $transact_sql_user -P $transact_sql_password -i $i -C
-    done
-
-else
-	echo "Please, install 'sqlcmd'."
+if [ -z "$(docker compose ps | grep anp-sql-server)" ];then 
+	cd $directory/..
+	./Tools/dockers.execute.sh
+	sleep 3
 fi
+
+for i in $(find $directory/../SQLServer -type f|grep .sql|sort|cat); do 
+	echo $i
+	docker exec -i anp-sql-server /opt/mssql-tools18/bin/sqlcmd -S $sql_server_host,$sql_server_port -U $sql_server_user -P $sql_server_password -C < $i
+done

docker-compose.yml

@@ -0,0 +1,23 @@
+services:
+
+  anp-sql-server:
+    image: anp:sql-server
+    container_name: anp-sql-server
+    volumes:
+      - ./Dockers/SQLServer/data:/var/opt/mssql
+      - ./Dockers/SQLServer/temporary:/temporary
+      - ./Dockers/SQLServer/scripts:/scripts
+    environment:
+      - MSSQL_SA_PASSWORD=Abc123..
+    ports:
+      - 31433:1433/tcp
+    networks:
+      anp-network:
+        ipv4_address: 172.20.212.222
+
+networks:
+  anp-network:
+    driver: bridge
+    ipam:
+      config:
+        - subnet: 172.20.212.0/24