init

Framework/Entities/Associations/AssociationAttribute.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace Kreta.Framework.Entities.Associations
+{
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
+    public class AssociationAttribute : Attribute
+    {
+        public string AssociationName
+        {
+            get;
+            private set;
+        }
+
+        public AssociationAttribute(string associationName)
+        {
+            AssociationName = associationName;
+        }
+    }
+}

Framework/Entities/Associations/AssociationHandler.cs

@@ -0,0 +1,32 @@
+namespace Kreta.Framework.Entities.Associations
+{
+    public class AssociationHandler<LeftEntity, RightEntity>
+        where LeftEntity : Entity
+        where RightEntity : Entity
+    {
+        internal protected AssociationHandler()
+        {
+            //for internal constructs only
+        }
+
+        public virtual void BeforeInsert(LeftEntity leftEntity, RightEntity rightEntity)
+        {
+            //dummy handler
+        }
+
+        public virtual void AfterInsert(LeftEntity leftEntity, RightEntity rightEntity)
+        {
+            //dummy handler
+        }
+
+        public virtual void BeforeDelete(LeftEntity leftEntity, RightEntity rightEntity)
+        {
+            //dummy handler
+        }
+
+        public virtual void AfterDelete(LeftEntity leftEntity, RightEntity rightEntity)
+        {
+            //dummy handler
+        }
+    }
+}

Framework/Entities/Associations/AssociationHandlerManager.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Kreta.Framework.Entities.Associations
+{
+    public static class AssociationHandlerManager
+    {
+        private static Dictionary<string, Type> associationHandlers = null;
+
+        private static void Initialize()
+        {
+            if (associationHandlers == null)
+            {
+                associationHandlers = new Dictionary<string, Type>();
+                var handlers = from assembly in AppDomain.CurrentDomain.GetAssemblies()
+                               where SDAServer.Instance.IsAssemblyAllowed(assembly)
+                               from type in assembly.GetTypes()
+                               where type.IsDefined(typeof(AssociationAttribute), false)
+                               select new
+                               {
+                                   AssociationName = ((AssociationAttribute)type.GetCustomAttributes(typeof(AssociationAttribute), false)[0]).AssociationName.ToLower(),
+                                   HandlerType = type,
+                               };
+                foreach (var handler in handlers)
+                {
+                    associationHandlers.Add(handler.AssociationName, handler.HandlerType);
+                }
+            }
+        }
+
+        public static AssociationHandler<LeftEntity, RightEntity> Create<LeftEntity, RightEntity>(string associationName)
+            where LeftEntity : Entity
+            where RightEntity : Entity
+        {
+            Initialize();
+
+            return associationHandlers.TryGetValue(associationName.ToLower(), out Type type)
+                ? (AssociationHandler<LeftEntity, RightEntity>)Activator.CreateInstance(type, true)
+                : new AssociationHandler<LeftEntity, RightEntity>();
+        }
+    }
+}

Framework/Entities/ColumnFilterMode.cs

@@ -0,0 +1,19 @@
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Entitás betöltés oszlopszűrés módja
+    /// </summary>
+    public enum ColumnFilterMode
+    {
+        /// <summary>
+        /// Alapértelmezetten minden oszlop engedélyezett
+        /// </summary>
+        DEFAULT_ALLOWED,
+
+        /// <summary>
+        /// Alapértelmezetten minden ozslop tiltott,
+        /// kivéve: ID, SERIAL, LASTCHANGED, CREATED, MODIFIER, CREATOR, és a kapcsoló mezők
+        /// </summary>
+        DEFAULT_DENIED,
+    }
+}

Framework/Entities/DAUtil.cs

@@ -0,0 +1,468 @@
+using System;
+using SDA.DataProvider;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// A generált DataAccessor-ok által használt statikus segédosztály, 
+    /// a generált kód mennyiségének csökkentésére. Az osztály kézzel írt kód számára tabu.
+    /// </summary>
+    /// <remarks>
+    /// Az osztály metódusai teljesítménykritikusak, ezért paraméterellenőrzés nem történik bennük, 
+    /// megbízunk a hívóban.
+    /// </remarks>
+    public sealed class DAUtil
+    {
+        // <<Facade>>
+
+        /// <summary>
+        /// Az osztály alapértelmezett konstruktora.
+        /// </summary>
+        /// <remarks>Az osztály statikus, példányosítását nem szándékozzuk.</remarks>
+        private DAUtil()
+        {
+        }
+
+        /// <summary>
+        /// Létrehoz egy új SDA.DataProvider.SDACommand parancsobjektumot,
+        /// és inicializálja a Commandtext, Connection, Transaction tulajdonságait.
+        /// </summary>
+        /// <param name="commandText">A parancsobjektum sql szövege</param>
+        /// <returns>A létrehozott <see cref="SDA.DataProvider.SDACommand"/> parancsobjektum</returns>
+        public static SDACommand CreateCommand(string commandText)
+        {
+            SDACommand result = new SDACommand
+            {
+                CommandText = commandText,
+                Connection = UserContext.Instance.SDAConnection,
+                Transaction = UserContext.Instance.SDATransaction
+            };
+            return result;
+
+        }
+
+        /// <summary>
+        /// Az entitás felvétele után utólag lekérdezi az entitás ID-ját.
+        /// </summary>
+        /// <returns></returns>
+        public static int? GetEntityID(SDAConnection connection, SDATransaction transaction)
+        {
+            using (SDACommand command = new SDACommand())
+            {
+                command.Connection = connection;
+                command.Transaction = transaction;
+                command.CommandText = "SELECT @@IDENTITY as ID";
+
+                var id = command.ExecuteScalar();
+
+                return id != DBNull.Value ? Convert.ToInt32(id) : (int?)null;
+            }
+        }
+
+        #region BindParameter
+
+        /// <summary>
+        /// Hozzáad a parancsobjektumhoz egy új paramétert.
+        /// </summary>
+        /// <param name="command">A tulajdonos <see cref="SDA.DataProvider.SDACommand"/> objektum</param>
+        /// <param name="parameterName">A paraméter neve</param>
+        /// <param name="type">A paraméter típusa</param>
+        /// <param name="length">A paraméter hossza</param>
+        /// <param name="value">A paraméter értéke</param>
+        /// <param name="isNull">A paraméter null-e vagy sem</param>
+        public static void BindParameter(SDA.DataProvider.SDACommand command, string parameterName, SDA.DataProvider.SDADBType type, int length, object value, bool isNull)
+        {
+            if (isNull || value == null)
+            {
+                command.Parameters.Add(parameterName, type, length).Value = DBNull.Value;
+            }
+            else
+            {
+                command.Parameters.Add(parameterName, type, length).Value = value;
+            }
+        }
+
+        /// <summary>
+        /// Hozzáad a parancsobjektumhoz egy új paramétert.
+        /// </summary>
+        /// <param name="command">A tulajdonos <see cref="SDA.DataProvider.SDACommand"/> objektum</param>
+        /// <param name="parameterName">A paraméter neve</param>
+        /// <param name="type">A paraméter típusa</param>
+        /// <param name="value">A paraméter értéke</param>
+        /// <param name="isNull">A paraméter null-e vagy sem</param>
+        public static void BindParameter(SDA.DataProvider.SDACommand command, string parameterName, SDA.DataProvider.SDADBType type, object value, bool isNull)
+        {
+            if (isNull || value == null)
+            {
+                command.Parameters.Add(parameterName, type).Value = DBNull.Value;
+            }
+            else
+            {
+                command.Parameters.Add(parameterName, type).Value = value;
+            }
+        }
+
+        /// <summary>
+        /// Hozzáad a parancsobjektumhoz egy új paramétert.
+        /// </summary>
+        /// <param name="command">A tulajdonos <see cref="SDA.DataProvider.SDACommand"/> objektum</param>
+        /// <param name="parameterName">A paraméter neve</param>
+        /// <param name="value">A paraméter értéke</param>
+        public static void BindIdParameter(SDA.DataProvider.SDACommand command, string parameterName, int value)
+        {
+            if (value == -1)
+            {
+                command.Parameters.Add(parameterName, SDA.DataProvider.SDADBType.Int).Value = DBNull.Value;
+            }
+            else
+            {
+                command.Parameters.Add(parameterName, SDA.DataProvider.SDADBType.Int).Value = value;
+            }
+        }
+
+        #endregion
+
+        #region ReadAttribute
+
+        /// <summary>
+        /// Bináris típusú attribútum értékét olvassa be.
+        /// </summary>
+        /// <param name="reader">A forrás <see cref="SDA.DataProvider.SDADataReader"/> objektum</param>
+        /// <param name="index">Az attribútum indexe</param>
+        /// <param name="defaultValue">Alapértelmezett érték null olvasása esetén</param>
+        /// <returns>True, ha nem null lett olvasva; egyébként false</returns>
+        public static bool ReadBinaryAttribute(SDA.DataProvider.SDADataReader reader, int index, ref byte[] target, ref bool isNull, byte[] defaultValue)
+        {
+            if (reader.IsDBNull(index))
+            {
+                isNull = true;
+                target = defaultValue;
+                return false;
+            }
+
+            isNull = false;
+            target = (byte[])reader.GetValue(index);
+            return true;
+        }
+
+        public static byte[] ReadBinaryAttribute(SDA.DataProvider.SDADataReader reader, int index, byte[] defaultValue)
+        {
+            if (reader.IsDBNull(index))
+            {
+                return defaultValue;
+            }
+
+            return (byte[])reader.GetValue(index);
+        }
+
+        public static byte[] ReadBinaryAttribute(SDA.DataProvider.SDADataReader reader, int index)
+        {
+            if (reader.IsDBNull(index))
+            {
+                return null;
+            }
+
+            return (byte[])reader.GetValue(index);
+        }
+
+        /// <summary>
+        /// Logikai típusú attribútum értékét olvassa be.
+        /// </summary>
+        /// <param name="reader">A forrás <see cref="SDA.DataProvider.SDADataReader"/> objektum</param>
+        /// <param name="index">Az attribútum indexe</param>
+        /// <param name="defaultValue">Alapértelmezett érték null olvasása esetén</param>
+        /// <returns>True, ha nem null lett olvasva; egyébként false</returns>
+        public static bool ReadBooleanAttribute(SDA.DataProvider.SDADataReader reader, int index, ref bool target, ref bool isNull, bool defaultValue)
+        {
+            if (reader.IsDBNull(index))
+            {
+                isNull = true;
+                target = defaultValue;
+                return false;
+            }
+
+            isNull = false;
+            char tmp = reader.GetString(index)[0];
+            target = (tmp == 'T' || tmp == 'I');
+            return true;
+        }
+
+        public static bool ReadBooleanAttribute(SDA.DataProvider.SDADataReader reader, int index, bool defaultValue)
+        {
+            if (reader.IsDBNull(index))
+            {
+                return defaultValue;
+            }
+
+            char tmp = reader.GetString(index)[0];
+            return (tmp == 'T' || tmp == 'I');
+        }
+
+        public static bool? ReadBooleanAttribute(SDA.DataProvider.SDADataReader reader, int index)
+        {
+            if (reader.IsDBNull(index))
+            {
+                return null;
+            }
+
+            char tmp = reader.GetString(index)[0];
+            return (tmp == 'T' || tmp == 'I');
+        }
+
+        /// <summary>
+        /// Dátum típusú attribútum értékét olvassa be.
+        /// </summary>
+        /// <param name="reader">A forrás <see cref="SDA.DataProvider.SDADataReader"/> objektum</param>
+        /// <param name="index">Az attribútum indexe</param>
+        /// <param name="defaultValue">Alapértelmezett érték null olvasása esetén</param>
+        /// <returns>True, ha nem null lett olvasva; egyébként false</returns>
+        public static bool ReadDateTimeAttribute(SDA.DataProvider.SDADataReader reader, int index, ref DateTime target, ref bool isNull, DateTime defaultValue)
+        {
+            if (reader.IsDBNull(index))
+            {
+                isNull = true;
+                target = defaultValue;
+                return false;
+            }
+
+            isNull = false;
+            target = reader.GetDateTime(index);
+            return true;
+        }
+
+        public static DateTime ReadDateTimeAttribute(SDA.DataProvider.SDADataReader reader, int index, DateTime defaultValue)
+        {
+            if (reader.IsDBNull(index))
+            {
+                return defaultValue;
+            }
+
+            return reader.GetDateTime(index);
+        }
+
+        public static DateTime? ReadDateTimeAttribute(SDA.DataProvider.SDADataReader reader, int index)
+        {
+            if (reader.IsDBNull(index))
+            {
+                return null;
+            }
+
+            return reader.GetDateTime(index);
+        }
+
+        /// <summary>
+        /// Lebegőpontos típusú attribútum értékét olvassa be.
+        /// </summary>
+        /// <param name="reader">A forrás <see cref="SDA.DataProvider.SDADataReader"/> objektum</param>
+        /// <param name="index">Az attribútum indexe</param>
+        /// <param name="defaultValue">Alapértelmezett érték null olvasása esetén</param>
+        /// <returns>True, ha nem null lett olvasva; egyébként false</returns>
+        public static bool ReadDoubleAttribute(SDA.DataProvider.SDADataReader reader, int index, ref double target, ref bool isNull, double defaultValue)
+        {
+            if (reader.IsDBNull(index))
+            {
+                isNull = true;
+                target = defaultValue;
+                return false;
+            }
+
+            isNull = false;
+            target = Convert.ToDouble(reader.GetValue(index));
+            return true;
+        }
+
+        public static double ReadDoubleAttribute(SDA.DataProvider.SDADataReader reader, int index, double defaultValue)
+        {
+            if (reader.IsDBNull(index))
+            {
+                return defaultValue;
+            }
+
+            return Convert.ToDouble(reader.GetValue(index));
+        }
+
+        public static double? ReadDoubleAttribute(SDA.DataProvider.SDADataReader reader, int index)
+        {
+            if (reader.IsDBNull(index))
+            {
+                return null;
+            }
+
+            return Convert.ToDouble(reader.GetValue(index));
+        }
+
+        /// <summary>
+        /// ID típusú attribútum értékét olvassa be.
+        /// </summary>
+        /// <param name="reader">A forrás <see cref="SDA.DataProvider.SDADataReader"/> objektum</param>
+        /// <param name="index">Az attribútum indexe</param>
+        /// <param name="target">A cél</param>
+        /// <param name="defaultValue">Alapértelmezett érték null olvasása esetén</param>
+        /// <returns>True, ha nem null lett olvasva; egyébként false</returns>
+        public static bool ReadIDAttribute(SDA.DataProvider.SDADataReader reader, int index, ref int target, int defaultValue)
+        {
+            if (reader.IsDBNull(index))
+            {
+                target = defaultValue;
+                return false;
+            }
+
+            target = Convert.ToInt32(reader.GetValue(index));
+            return true;
+        }
+
+        /// <summary>
+        /// Egész típusú attribútum értékét olvassa be.
+        /// </summary>
+        /// <param name="reader">A forrás <see cref="SDA.DataProvider.SDADataReader"/> objektum</param>
+        /// <param name="index">Az attribútum indexe</param>
+        /// <param name="defaultValue">Alapértelmezett érték null olvasása esetén</param>
+        /// <returns>True, ha nem null lett olvasva; egyébként false</returns>
+        public static bool ReadIntegerAttribute(SDA.DataProvider.SDADataReader reader, int index, ref int target, ref bool isNull, int defaultValue)
+        {
+            if (reader.IsDBNull(index))
+            {
+                isNull = true;
+                target = defaultValue;
+                return false;
+            }
+
+            isNull = false;
+            target = Convert.ToInt32(reader.GetValue(index));
+            return true;
+        }
+
+        public static int ReadIntegerAttribute(SDA.DataProvider.SDADataReader reader, int index, int defaultValue)
+        {
+            if (reader.IsDBNull(index))
+            {
+                return defaultValue;
+            }
+
+            return Convert.ToInt32(reader.GetValue(index));
+        }
+
+        public static int? ReadIntegerAttribute(SDA.DataProvider.SDADataReader reader, int index)
+        {
+            if (reader.IsDBNull(index))
+            {
+                return null;
+            }
+
+            return Convert.ToInt32(reader.GetValue(index));
+        }
+
+        /// <summary>
+        /// Karakterlánc típusú attribútum értékét olvassa be.
+        /// </summary>
+        /// <param name="reader">A forrás <see cref="SDA.DataProvider.SDADataReader"/> objektum</param>
+        /// <param name="index">Az attribútum indexe</param>
+        /// <param name="target">A cél</param>
+        /// <param name="isNull">Null-t olvasott vagy nem null-t</param>
+        /// <param name="defaultValue">Alapértelmezett érték null olvasása esetén</param>
+        /// <returns>True, ha nem null lett olvasva; egyébként false</returns>
+        public static bool ReadStringAttribute(SDA.DataProvider.SDADataReader reader, int index, ref string target, ref bool isNull, string defaultValue)
+        {
+            if (reader.IsDBNull(index))
+            {
+                isNull = true;
+                target = defaultValue;
+                return false;
+            }
+
+            isNull = false;
+            target = reader.GetString(index);
+            return true;
+        }
+
+        public static string ReadStringAttribute(SDA.DataProvider.SDADataReader reader, int index, string defaultValue)
+        {
+            if (reader.IsDBNull(index))
+            {
+                return defaultValue;
+            }
+
+            return reader.GetString(index);
+        }
+
+        public static string ReadStringAttribute(SDA.DataProvider.SDADataReader reader, int index)
+        {
+            if (reader.IsDBNull(index))
+            {
+                return null;
+            }
+
+            return reader.GetString(index);
+        }
+
+        public static bool ReadGuidAttribute(SDA.DataProvider.SDADataReader reader, int index, ref Guid target, ref bool isNull, Guid defaultValue)
+        {
+            if (reader.IsDBNull(index))
+            {
+                isNull = true;
+                target = defaultValue;
+                return false;
+            }
+
+            isNull = false;
+            target = Guid.Parse(reader.GetString(index));
+            return true;
+        }
+
+        public static Guid ReadGuidAttribute(SDA.DataProvider.SDADataReader reader, int index, Guid defaultValue)
+        {
+            if (reader.IsDBNull(index))
+            {
+                return defaultValue;
+            }
+
+            return reader.GetGuid(index);
+        }
+
+        public static Guid? ReadGuidAttribute(SDA.DataProvider.SDADataReader reader, int index)
+        {
+            if (reader.IsDBNull(index))
+            {
+                return null;
+            }
+
+            return reader.GetGuid(index);
+        }
+
+        #endregion
+
+        #region Read methods for framework
+        /// <summary>
+        /// DateTime? típusú értékét olvas be
+        /// </summary>
+        /// <param name="reader">A forrás <see cref="SDA.DataProvider.SDADataReader"/> objektum</param>
+        /// <param name="index">Az attribútum indexe</param>
+        /// <returns>A beolvasott dátum, vagy null</returns>
+        internal static DateTime? ReadDateTime(SDA.DataProvider.SDADataReader reader, int index)
+        {
+            if (reader.IsDBNull(index))
+            {
+                return null;
+            }
+
+            return reader.GetDateTime(index);
+        }
+
+        /// <summary>
+        /// Karakterlánc típusú attribútum értékét olvas be
+        /// </summary>
+        /// <param name="reader">A forrás <see cref="SDA.DataProvider.SDADataReader"/> objektum</param>
+        /// <param name="index">Az attribútum indexe</param>
+        /// <returns>A beolvasott string vagy null</returns>
+        internal static string ReadString(SDA.DataProvider.SDADataReader reader, int index)
+        {
+            if (reader.IsDBNull(index))
+            {
+                return null;
+            }
+
+            return reader.GetString(index);
+        }
+        #endregion
+    }
+}

Framework/Entities/Entity.cs

@@ -0,0 +1,911 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Kreta.Framework.Util;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Az entitások absztrakt ősosztálya.
+    /// </summary>
+    public abstract class Entity
+    {
+        // <<Layer Supertype>>
+
+        //private static Hashtable m_EntityAttributeCache = Hashtable.Synchronized(new Hashtable());
+        protected int m_ID;
+        protected EntityState m_State;
+        protected int m_Serial;
+        protected DateTime? m_EntityLastChanged = null;
+        protected DateTime? m_EntityCreated = null;
+        protected bool m_Torolt = false;
+        protected int? m_EntityModifier = null;
+        protected int m_EntityCreator = -1;
+        private Hashtable m_OriginalValues = new Hashtable();
+        private Hashtable m_CurrentValues = new Hashtable();
+
+        /// <summary>
+        /// Az osztály alapértelmezett konstruktora.
+        /// </summary>
+        protected Entity()
+        {
+        }
+
+        #region Belső dolgok
+
+        /// <summary>
+        /// Ellenőrzi, hogy az entitás módosítható állapotban van.
+        /// </summary>
+        /// <exception cref="EntityStateException">Ha nem módosítható az entitás</exception>
+        protected void CheckModifyable()
+        {
+            if (!CanModifyFields)
+            {
+                throw new EntityStateException(m_State);
+            }
+        }
+
+        /// <summary>
+        /// Alapállapotba állítja az objektumot
+        /// </summary>
+        protected virtual void Reset()
+        {
+            m_State = EntityState.Uninitialized;
+            m_ID = -1;
+            m_Serial = -1;
+            m_EntityCreated = null;
+            m_EntityCreator = -1;
+            m_EntityLastChanged = null;
+            m_Torolt = false;
+            m_EntityModifier = null;
+            m_CurrentValues.Clear();
+            m_OriginalValues.Clear();
+        }
+
+        /// <summary>
+        /// Visszaadja az entitás adatbázisműveleteit végző <see cref="IEntityDataAccessor"/> objektumát.
+        /// </summary>
+        /// <returns>Az entitás adatbázisműveleteit végző <see cref="IEntityDataAccessor"/> objektum</returns>
+        protected abstract IEntityDataAccessor GetDataAccessor();
+
+        #endregion
+
+        #region Nyilvános felület
+
+        /// <summary>
+        /// Visszaadja az entitás nevét.
+        /// </summary>
+        /// <remarks>
+        /// Az entitás nevét a rajta lévő <see cref="EntityAttribute"/> attribútum definiálja.
+        /// A névnek rendszer szinten egyedinek kell lennie.
+        /// </remarks>
+        public string GetEntityName()
+        {
+            return EntityAttributeCache.GetEntityNameFromCache(GetType());
+        }
+
+        /// <summary>
+        /// Az entitás azonosítója
+        /// </summary>
+        /// <value>Az entitást azonosító nemnegatív egész szám</value>
+        public int ID
+        {
+            get
+            {
+                return m_ID;
+            }
+            set
+            {
+                m_ID = value;
+            }
+        }
+
+        /// <summary>
+        /// Az entitás utolsó módosításának ideje
+        /// </summary>
+        public virtual DateTime? EntityLastChanged
+        {
+            get
+            {
+                return m_EntityLastChanged;
+            }
+            internal protected set
+            {
+                m_EntityLastChanged = value;
+            }
+        }
+
+        /// <summary>
+        /// Az entitás létrehozásának ideje
+        /// </summary>
+        public virtual DateTime? EntityCreated
+        {
+            get
+            {
+                return m_EntityCreated;
+            }
+            internal protected set
+            {
+                m_EntityCreated = value;
+            }
+        }
+
+        /// <summary>
+        /// Az entitás létrehozójának adatai
+        /// </summary>
+        public virtual int EntityCreator
+        {
+            get
+            {
+                return m_EntityCreator;
+            }
+            internal protected set
+            {
+                m_EntityCreator = value;
+            }
+        }
+
+        /// <summary>
+        /// Az entitás logikailag törölve van.
+        /// </summary>
+        public virtual bool Torolt
+        {
+            get
+            {
+                return m_Torolt;
+            }
+            set
+            {
+                m_Torolt = value;
+            }
+        }
+
+        /// <summary>
+        /// Az entitás módosítójának adatai
+        /// </summary>
+        public virtual int? EntityModifier
+        {
+            get
+            {
+                return m_EntityModifier;
+            }
+            internal protected set
+            {
+                m_EntityModifier = value;
+            }
+        }
+
+        /// <summary>
+        /// Az entitás verziója
+        /// </summary>
+        /// <value>Az entitás verziója</value>
+        /// <remarks>Az entitás verziója kezdetben nulla, és minden mentésnél eggyel no.</remarks>
+        public int Serial
+        {
+            get
+            {
+                return m_Serial;
+            }
+            set
+            {
+                m_Serial = value;
+            }
+        }
+
+        /// <summary>
+        /// Az entitás jelenlegi állapota.
+        /// </summary>
+        public EntityState State
+        {
+            get
+            {
+                return m_State;
+            }
+            set
+            {
+                SetState(value);
+            }
+        }
+
+        /// <summary>
+        /// Új állapotba hozza az entitást.
+        /// </summary>
+        /// <param name="state">Új állapot</param>
+        public void SetState(EntityState state)
+        {
+            m_State = state;
+        }
+
+        /// <summary>
+        /// Betöltött állapotba helyezi az entitást.
+        /// </summary>
+        public void SetLoaded()
+        {
+            m_State = EntityState.Initialized;
+            StoreOriginalValues();
+        }
+
+        /// <summary>
+        /// Ellenőrzi, hogy az entitás attribútumai érvényes értékeket tartalmaznak-e.
+        /// </summary>
+        /// <exception cref="InvalidEntityAttributeException">
+        /// Ha valamelyik attribútum értéke érvénytelen.
+        /// </exception>
+        protected virtual void Validate(bool skipValidateAttributes = false)
+        {
+            // Az ősosztályban nem kell csinálnunk semmit.
+        }
+
+        #endregion
+
+        #region Állapottal kapcsolatos dolgok
+
+        /// <summary>
+        /// Visszaadja, hogy az entitás be van-e már töltve.
+        /// </summary>
+        public bool IsInitialized
+        {
+            get
+            {
+                return (m_State == EntityState.Initialized || m_State == EntityState.Modified);
+            }
+        }
+
+        /// <summary>
+        /// Visszaadja, hogy az entitás módosítva lett-e.
+        /// </summary>
+        public bool IsModified
+        {
+            get
+            {
+                return (m_State == EntityState.Modified);
+            }
+        }
+
+        /// <summary>
+        /// Visszaadja, hogy az entitás törölve lett-e.
+        /// </summary>
+        public bool IsDeleted
+        {
+            get
+            {
+                return (m_State == EntityState.Removed);
+            }
+        }
+
+        /// <summary>
+        /// Ellenőrzi, hogy az entitás állapota megfelelő-e a betöltés művelethez.
+        /// </summary>
+        /// <value>True, ha az entitás betölthető; egyébként false</value>
+        protected bool CanLoad
+        {
+            get
+            {
+                return (m_State == EntityState.Uninitialized);
+            }
+        }
+
+        /// <summary>
+        /// Ellenőrzi, hogy az entitás állapota megfelelő-e a beszúrás művelethez.
+        /// </summary>
+        /// <value>True, ha az entitás beszúrható az adatbázisba; egyébként false</value>
+        protected bool CanInsert
+        {
+            get
+            {
+                return (m_State == EntityState.New || m_State == EntityState.Uninitialized);
+            }
+        }
+
+        /// <summary>
+        /// Ellenőrzi, hogy az entitás állapota megfelelő-e a módosítás művelethez.
+        /// </summary>
+        /// <value>True, ha az entitás módosítható az adatbázisban; egyébként false</value>
+        protected bool CanUpdate
+        {
+            get
+            {
+                return (m_State == EntityState.Modified || m_State == EntityState.Initialized);
+            }
+        }
+
+        /// <summary>
+        /// Ellenőrzi, hogy az entitás állapota megfelelő-e a törléshez.
+        /// </summary>
+        /// <value>True, ha az entitás törölhető az adatbázisban; egyébként false</value>
+        protected bool CanRemove
+        {
+            get
+            {
+                return (m_State != EntityState.Uninitialized);
+            }
+        }
+
+        /// <summary>
+        /// Ellenőrzi, hogy az entitás állapota megfelelő-e az attribútumainak módosításához.
+        /// </summary>
+        /// <value>True, ha az entitás attribútumai módosíthatóak; egyébként false</value>
+        protected bool CanModifyFields
+        {
+            get
+            {
+                return (m_State != EntityState.Removed);
+            }
+        }
+
+        #endregion
+
+        #region CRUD logika
+
+        /// <summary>
+        /// Azonosító alapján feltölti az entitást az adatbázisból
+        /// </summary>
+        /// <param name="id">Az entitás azonosítója</param>
+        /// <returns>True, ha sikeres; egyébként False</returns>
+        public bool LoadEntityByID(int id)
+        {
+            if (m_State != EntityState.Uninitialized)
+            {
+                throw new EntityStateException(m_State);
+            }
+            m_ID = id;
+            if (!GetDataAccessor().LoadEntity(this, id))
+            {
+                m_ID = -1;
+                return false;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Azonosító alapján feltölti az entitást az adatbázisból, minden oszloppal
+        /// </summary>
+        /// <param name="id">Az entitás azonosítója</param>
+        /// <exception cref="EntityNotFoundException">Ha a megadott azonosítójú entitás nem található.</exception>
+        public void LoadByID(int id)
+        {
+            if (m_State != EntityState.Uninitialized)
+            {
+                throw new EntityStateException(m_State);
+            }
+            m_ID = id;
+            if (!GetDataAccessor().LoadEntity(this, id))
+            {
+                m_ID = -1;
+                throw new EntityNotFoundException(GetEntityName(), id);
+            }
+        }
+
+        /// <summary>
+        /// Azonosító alapján feltölti az entitást az adatbázisból, tiltó oszlopszűréssel
+        /// </summary>
+        /// <param name="id">Az entitás azonosítója</param>
+        /// <param name="filteredColumns">A betöltésre nem kerülő oszlopok</param>
+        public void LoadByID(int id, IEnumerable<string> filteredColumns)
+        {
+            this.LoadByID(id, ColumnFilterMode.DEFAULT_ALLOWED, filteredColumns);
+        }
+
+        /// <summary>
+        /// Azonosító alapján feltölti az entitást az adatbázisból, oszlopszűréssel
+        /// </summary>
+        /// <param name="id">Az entitás azonosítója</param>
+        /// <param name="columnFilterMode">A szűrés módja, megengedő vagy tiltó</param>
+        /// <param name="columns">A szűrendő oszlopok felsorolása</param>
+        public void LoadByID(int id, ColumnFilterMode columnFilterMode, IEnumerable<string> columns)
+        {
+            if (m_State != EntityState.Uninitialized)
+            {
+                throw new EntityStateException(m_State);
+            }
+            m_ID = id;
+            if (!GetDataAccessor().FilteredLoadEntity(this, id, columnFilterMode, columns))
+            {
+                m_ID = -1;
+                throw new EntityNotFoundException(GetEntityName(), id);
+            }
+        }
+
+        /// <summary>
+        /// Azonosító alapján feltölti az entitást adatbázisból.
+        /// </summary>
+        /// <param name="id">Az entitás azonosítója</param>
+        /// <param name="serial">Az entitás verziószáma</param>
+        /// <exception cref="EntityExpiredException">Ha az entitás verziószáma nem egyezik a megadottal.</exception>
+        /// <exception cref="EntityNotFoundException">Ha a megadott azonosítójú entitás nem található.</exception>
+        public void LoadByID(int id, int serial)
+        {
+            LoadByID(id);
+
+            if (m_Serial != serial)
+            {
+                throw new EntityExpiredException(GetEntityName(), ID, m_Serial, serial);
+            }
+        }
+
+        /// <summary>
+        /// Azonosító alapján feltölti az entitást adatbázisból, oszlopszűréssel
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="serial"></param>
+        /// <param name="columnFilterMode"></param>
+        /// <param name="columns"></param>
+        public void LoadByID(int id, int serial, ColumnFilterMode columnFilterMode, IEnumerable<string> columns)
+        {
+            LoadByID(id, columnFilterMode, columns);
+
+            if (m_Serial != serial)
+            {
+                throw new EntityExpiredException(GetEntityName(), ID, m_Serial, serial);
+            }
+        }
+
+        /// <summary>
+        /// Adatbázisba menti a még nem létező entitást.
+        /// </summary>
+        public void Insert()
+        {
+            Insert(true);
+        }
+
+        /// <summary>
+        /// Adatbázisba menti a még nem létező entitást.
+        /// </summary>
+        /// <param name="runHandler">Futtassa-e a hozzá tartozó <see cref="EntityHandler"/> objektumot, vagy sem</param>
+        public void Insert(bool runHandler)
+        {
+            try
+            {
+                // <<Template Method>>
+                IEntityHandler handler = null;
+                if (runHandler)
+                {
+                    handler = EntityHandler.Create(GetType());
+                    handler.BeforeInsert(this);
+                }
+
+                DoInsert();
+
+                if (runHandler)
+                {
+                    handler.AfterInsert(this);
+                }
+            }
+            catch
+            {
+                EntityState es = this.State;
+                this.State = EntityState.New;  // biztos ami biztos
+                this.StoreOriginalValues(); // hogy legyen mit logolni
+                //EntityHistoryLogger.LogErrorHistory(this);
+                this.State = es;
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Adatbázisba menti a már létező entitás tulajdonságait.
+        /// </summary>
+        public void Update()
+        {
+            Update(true);
+        }
+
+        /// <summary>
+        /// Adatbázisba menti a már létező entitás tulajdonságait.
+        /// </summary>
+        /// <param name="runHandler">Futtassa-e a hozzá tartozó <see cref="EntityHandler"/> objektumot, vagy sem</param>
+        public void Update(bool runHandler)
+        {
+            try
+            {
+                // <<Template Method>>
+                IEntityHandler handler = null;
+                if (runHandler)
+                {
+                    handler = EntityHandler.Create(GetType());
+                    handler.BeforeUpdate(this);
+                }
+
+                DoUpdate(true, false);
+
+                if (runHandler)
+                {
+                    handler.AfterUpdate(this);
+                }
+            }
+            catch
+            {
+                EntityState es = this.State;
+                this.State = EntityState.Modified;  // különben nem logol
+                //EntityHistoryLogger.LogErrorHistory(this);
+                this.State = es;
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Adatbázisba menti az entitás asszociációit.
+        /// </summary>
+        /// <remarks>Valójában csak azokat, amelyeknél a kapcsolómező ennek az entitásnak a táblájában van!</remarks>
+        public void UpdateAssociations()
+        {
+            UpdateAssociations(true);
+        }
+
+        /// <summary>
+        /// Adatbázisba menti az entitás asszociációit.
+        /// </summary>
+        /// <param name="runHandler">Futtassa-e a hozzá tartozó <see cref="EntityHandler"/> objektumot, vagy sem</param>
+        /// <remarks>Valójában csak azokat, amelyeknél a kapcsolómező ennek az entitásnak a táblájában van!</remarks>
+        public void UpdateAssociations(bool runHandler)
+        {
+            try
+            {
+                // <<Template Method>>
+                IEntityHandler handler = null;
+                if (runHandler)
+                {
+                    handler = EntityHandler.Create(GetType());
+                    handler.BeforeUpdate(this);
+                }
+
+                DoUpdate(false, true);
+
+                if (runHandler)
+                {
+                    handler.AfterUpdate(this);
+                }
+            }
+            catch
+            {
+                EntityState es = this.State;
+                this.State = EntityState.Modified;  // különben nem logol
+                //EntityHistoryLogger.LogErrorHistory(this);
+                this.State = es;
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Adatbázisba menti a már létező entitás tulajdonságait és asszociációit.
+        /// </summary>
+        public void FullUpdate()
+        {
+            FullUpdate(true);
+        }
+
+        /// <summary>
+        /// Adatbázisba menti a már létező entitás tulajdonságait és asszociációit.
+        /// </summary>
+        /// <param name="runHandler">Futtassa-e a hozzá tartozó <see cref="EntityHandler"/> objektumot, vagy sem</param>
+        public void FullUpdate(bool runHandler)
+        {
+            try
+            {
+                // <<Template Method>>
+                IEntityHandler handler = null;
+                if (runHandler)
+                {
+                    handler = EntityHandler.Create(GetType());
+                    handler.BeforeUpdate(this);
+                }
+
+                DoUpdate(true, true);
+
+                if (runHandler)
+                {
+                    handler.AfterUpdate(this);
+                }
+            }
+            catch
+            {
+                EntityState es = this.State;
+                this.State = EntityState.Modified;  // különben nem logol
+                //EntityHistoryLogger.LogErrorHistory(this);
+                this.State = es;
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Törli az entitást az adatbázisból.
+        /// </summary>
+        /// <remarks>Sikeres törlés esetén az entitás 'EntityState.REMOVED' állapotba kerül.</remarks>
+        public void Delete(bool logikai = true)
+        {
+            Delete(true, logikai);
+        }
+
+        /// <summary>
+        /// Leellenőrzi az aktív kapcsolatait törléshez.
+        /// </summary>
+        void CheckActiveConnections()
+        {
+            var entityNames = new List<string>() { GetEntityName() };
+
+            var entityType = this.GetType();
+            if (entityType.BaseType != typeof(Entity))
+            {
+                entityNames.Add(EntityAttributeCache.GetEntityNameFromCache(entityType.BaseType));
+            }
+
+            var EntitasKapcsolatok = EntityUtils.GetEntitiesConnections(new List<int>() { this.ID }, entityNames);
+
+            // ha van az entitásnak kapcsolata, akkor elszáll
+            if (EntitasKapcsolatok.Count > 0 && EntitasKapcsolatok[ID].Count > 0)
+            {
+                throw new EntityDeleteFailedException(StringResourcesUtil.GetString(3478), EntitasKapcsolatok[ID]);
+            }
+        }
+
+        /// <summary>
+        /// Törli az entitást az adatbázisból.
+        /// </summary>
+        /// <param name="runHandler">Futtassa-e a hozzá tartozó <see cref="EntityHandler"/> objektumot, vagy sem</param>
+        public void Delete(bool runHandler, bool logikai = true)
+        {
+            try
+            {
+                // <<Template Method>>
+                IEntityHandler handler = null;
+                if (runHandler)
+                {
+                    handler = EntityHandler.Create(GetType());
+                    handler.BeforeDelete(this);
+                }
+
+                // ellenőrzi az aktív kapcsolatait
+                CheckActiveConnections();
+                DoDelete(false, runHandler, logikai);
+
+                if (runHandler)
+                {
+                    handler.AfterDelete(this);
+                }
+            }
+            catch /*(Exception ex)*/
+            {
+                EntityState es = this.State;
+                this.State = EntityState.Removed;  // biztos ami biztos
+                //EntityHistoryLogger.LogErrorHistory(this);
+                this.State = es;
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Törli az entitást az adatbázisból a kapcsolódásaival együtt.
+        /// </summary>
+        /// <remarks>Sikeres törlés esetén az entitás 'EntityState.REMOVED' állapotba kerül.</remarks>
+        public void CascadeDelete(bool logikai = true)
+        {
+            CascadeDelete(false, logikai);
+        }
+
+        /// <summary>
+        /// Törli az entitást az adatbázisból a kapcsolódásaival együtt.
+        /// </summary>
+        /// <param name="runHandler">Futtassa-e a hozzá tartozó <see cref="EntityHandler"/> objektumot, vagy sem</param>
+        public void CascadeDelete(bool runHandler, bool logikai = true)
+        {
+            try
+            {
+                // <<Template Method>>
+                IEntityHandler handler = null;
+                if (runHandler)
+                {
+                    handler = EntityHandler.Create(GetType());
+                    handler.BeforeDelete(this);
+                }
+
+                DoDelete(true, runHandler);
+
+                if (runHandler)
+                {
+                    handler.AfterDelete(this);
+                }
+            }
+            catch
+            {
+                EntityState es = this.State;
+                this.State = EntityState.Removed;  // biztos ami biztos
+                //EntityHistoryLogger.LogErrorHistory(this);
+                this.State = es;
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Elvégzi az entitás törlése előtti szétkapcsolásokat és kaszkád törléseket.
+        /// </summary>
+        protected virtual void DeAssociateBeforeDelete(bool runHandler = false)
+        {
+            // Az ősosztályban nem kell csinálnunk semmit.
+        }
+
+        /// <summary>
+        /// Elvégzi az entitás törlését.
+        /// </summary>
+        /// <param name="performCascadeDelete">Kaszkádosított törlés legyen-e, vagy sem</param>
+        protected virtual void DoDelete(bool performCascadeDelete, bool runHandler = false, bool logikai = true)
+        {
+            if (!CanRemove)
+            {
+                throw new EntityStateException(m_State);
+            }
+
+            if (performCascadeDelete)
+            {
+                DeAssociateBeforeDelete(runHandler);
+            }
+
+            GetDataAccessor().DeleteEntity(this, logikai);
+            SetState(EntityState.Removed);
+            //EntityHistoryLogger.LogHistory(this);
+        }
+
+        /// <summary>
+        /// elvegzi az entitás update-jet
+        /// </summary>
+        protected virtual void DoUpdate(bool withattributes, bool withassociations)
+        {
+            if (!CanUpdate)
+            {
+                throw new EntityStateException(m_State);
+            }
+
+            Validate(!withattributes);
+
+            if (withattributes)
+            {
+                if (!GetDataAccessor().UpdateEntity(this))
+                {
+                    throw new EntityExpiredException(GetEntityName(), ID, m_Serial);
+                }
+            }
+
+            if (withassociations)
+            {
+                if (!GetDataAccessor().UpdateAssociations(this))
+                {
+                    throw new EntityExpiredException(GetEntityName(), ID, m_Serial);
+                }
+            }
+            //EntityHistoryLogger.LogHistory(this);
+            SetState(EntityState.Initialized);
+        }
+
+        /// <summary>
+        /// elvegzi az entitas insertjet
+        /// </summary>
+        protected virtual void DoInsert()
+        {
+            if (!CanInsert)
+            {
+                throw new EntityStateException(m_State);
+            }
+
+            Validate();
+
+            GetDataAccessor().InsertEntity(this);
+
+            StoreOriginalValues();
+
+            //EntityHistoryLogger.LogHistory(this);
+            SetState(EntityState.Initialized);
+        }
+
+        #endregion
+
+        #region Oszlopszintű naplózás támogatása
+
+        /// <summary>
+        /// Eltárolja az entitás összes attribútumának adatbázisban tárolt értékét.
+        /// </summary>
+        protected virtual void StoreOriginalValues()
+        {
+            m_OriginalValues.Clear();
+        }
+
+        /// <summary>
+        /// A függvény eltárolja egy attribútum értékének megváltozását.
+        /// </summary>
+        /// <param name="attributeName">A módosult attribútum neve</param>
+        /// <param name="value">A módosult attribútum új értéke</param>
+        /// <remarks>Ezt a metódust meg kell hívni minden olyan esetben, amikor olyan attribútum módosult,
+        /// amelyet oszlop szinten naplózni kell.</remarks>
+        protected void FieldModified(string attributeName, object value)
+        {
+            if (string.IsNullOrWhiteSpace(attributeName))
+            {
+                throw new ArgumentNullException(nameof(attributeName));
+            }
+
+            if (m_State == EntityState.Initialized)
+            {
+                SetState(EntityState.Modified);
+            }
+            else if (m_State == EntityState.Uninitialized)
+            {
+                SetState(EntityState.New);
+            }
+
+            m_CurrentValues[attributeName] = (value ?? DBNull.Value);
+        }
+
+        /// <summary>
+        /// Az entitás eredeti naplózandó attribútumai.
+        /// </summary>
+        protected internal Hashtable OriginalValues
+        {
+            get
+            {
+                return m_OriginalValues;
+            }
+        }
+
+        /// <summary>
+        /// Az entitás módosult naplózandó attribútumai a jelenlegi értékükkel.
+        /// </summary>
+        protected internal Hashtable CurrentValues
+        {
+            get
+            {
+                return m_CurrentValues;
+            }
+        }
+
+        /// <summary>
+        /// Visszaadja egy attribútum eredeti értékét.
+        /// </summary>
+        /// <param name="attributeName">Az attribútum neve</param>
+        /// <returns>Az attribútum eredeti értéke</returns>
+        /// <exception cref="ArgumentException">Ha az entitás nem rendelkezik a magadott attribútummal, vagy az nem naplózandó.</exception>
+        public object GetOriginalValue(string attributeName)
+        {
+            if (!m_OriginalValues.ContainsKey(attributeName))
+            {
+                throw new ArgumentException("The entity does not contain the original value for the specified attribute.", nameof(attributeName));
+            }
+
+            object result = m_OriginalValues[attributeName];
+
+            if (result == DBNull.Value)
+            {
+                return null;
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Megvizsgálja, hogy egy attribútum eredeti értéke null-e, vagy sem.
+        /// </summary>
+        /// <param name="attributeName">Az attribútum neve</param>
+        /// <returns>True, ha az attribútum eredeti értéke null; egyébként false</returns>
+        /// <exception cref="ArgumentException">Ha az entitás nem rendelkezik a magadott attribútummal, vagy az nem naplózandó.</exception>
+        public bool IsOriginalValueNull(string attributeName)
+        {
+            return (GetOriginalValue(attributeName) == null);
+        }
+
+        /// <summary>
+        /// Megvizsgálja, hogy egy attribútum értéke változott-e, vagy sem.
+        /// </summary>
+        /// <param name="attributeName">Az attribútum neve</param>
+        /// <returns>True, ha változott; egyébként false</returns>
+        public bool HasChanged(string attributeName)
+        {
+            return m_CurrentValues.ContainsKey(attributeName);
+        }
+
+        public IEnumerable<string> ChangedAttributes()
+        {
+            string[] result = new string[m_CurrentValues.Count];
+            m_CurrentValues.Keys.CopyTo(result, 0);
+            return result;
+        }
+
+        #endregion
+    }
+}

Framework/Entities/EntityAttribute.cs

@@ -0,0 +1,33 @@
+using System;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Entitást jelző attribútum.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
+    public sealed class EntityAttribute : Attribute
+    {
+        private string m_Name;
+
+        /// <summary>
+        /// Az attribútum konstruktora.
+        /// </summary>
+        /// <param name="name">Az entitás neve</param>
+        public EntityAttribute(string name)
+        {
+            m_Name = name;
+        }
+
+        /// <summary>
+        /// Az entitás neve.
+        /// </summary>
+        public string Name
+        {
+            get
+            {
+                return m_Name;
+            }
+        }
+    }
+}

Framework/Entities/EntityAttributeCache.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections;
+
+namespace Kreta.Framework.Entities
+{
+    internal static class EntityAttributeCache
+    {
+        private static Hashtable m_EntityAttributeCache = new Hashtable();
+
+        /// <summary>
+        /// Visszaadja az entitás nevét a rajta lévő <see cref="EntityAttribute"/> attribútum alapján.
+        /// </summary>
+        /// <param name="entityType">Az entitás típusa</param>
+        /// <returns>Az entitás neve, ha van <see cref="EntityAttribute"/> attribútuma; egyébként 'Ismeretlen'</returns>
+        private static string GetEntityName(Type entityType)
+        {
+            EntityAttribute[] attributes = (EntityAttribute[])entityType.GetCustomAttributes(typeof(EntityAttribute), true);
+            if (attributes.Length > 0)
+            {
+                return attributes[0].Name;
+            }
+
+            if (entityType.BaseType != null)
+            {
+                return GetEntityName(entityType.BaseType);
+            }
+
+            return "Ismeretlen";
+        }
+
+        /// <summary>
+        /// Visszaadja az entitás nevét, cache-elve
+        /// </summary>
+        /// <remarks>
+        /// Az entitás nevét a rajta lévő <see cref="EntityAttribute"/> attribútum definiálja.
+        /// A névnek rendszer szinten egyedinek kell lennie.
+        /// </remarks>
+        internal static string GetEntityNameFromCache(Type entityType)
+        {
+            string result = m_EntityAttributeCache[entityType] as string;
+            if (result == null)
+            {
+                result = GetEntityName(entityType);
+                m_EntityAttributeCache[entityType] = result;
+            }
+            return result;
+        }
+    }
+}

Framework/Entities/EntityAttributeError.cs

@@ -0,0 +1,54 @@
+using System;
+using Kreta.Framework.Localization;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Érvénytelen entitás attribútum hibakódjai, az <see cref="InvalidEntityAttributeException"/> kivétel használja.
+    /// </summary>
+    [Serializable]
+    public enum EntityAttributeError
+    {
+        /// <summary>
+        /// Érvénytelen
+        /// </summary>
+        [FriendlyName(1000032, "érvénytelen")]
+        Unknown = 0,
+
+        /// <summary>
+        /// Értéke túl hosszú
+        /// </summary>
+        [FriendlyName(1000033, "értéke túl hosszú")]
+        TooLong,
+
+        /// <summary>
+        /// Nincs kitöltve
+        /// </summary>
+        [FriendlyName(1000034, "nincs kitöltve")]
+        Empty,
+
+        /// <summary>
+        /// Nem megfelelő formátumú
+        /// </summary>
+        [FriendlyName(1000035, "nem megfelelő formátumú")]
+        WrongFormat,
+
+        /// <summary>
+        /// Értéke túl nagy vagy túl kicsi
+        /// </summary>
+        [FriendlyName(1000036, "értéke túl nagy vagy túl kicsi")]
+        OutOfRange,
+
+        /// <summary>
+        /// Értéke nem megengedett
+        /// </summary>
+        [FriendlyName(1000037, "értéke nem megengedett")]
+        NotAllowed,
+
+        /// <summary>
+        /// Értéke inkonzinsztens
+        /// </summary>
+        [FriendlyName(1000038, "értéke inkonzinsztens")]
+        Inconsistent,
+    }
+}

Framework/Entities/EntityConnectionModel.cs

@@ -0,0 +1,11 @@
+namespace Kreta.Framework.Entities
+{
+    public class EntityConnectionModel
+    {
+        public string TargetTableName { get; set; }
+
+        public string TargetColumnName { get; set; }
+
+        public int RowsCount { get; set; }
+    }
+}

Framework/Entities/EntityCopyMethod.cs

@@ -0,0 +1,18 @@
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Entitás másolásának fajtái. Lásd még <see cref="EntityPropertyAttribute"/>.
+    /// </summary>
+    public enum EntityCopyMethod
+    {
+        /// <summary>
+        /// Mély másolás
+        /// </summary>
+        DeepCopy,
+
+        /// <summary>
+        /// Sekély másolás
+        /// </summary>
+        ShallowCopy,
+    }
+}

Framework/Entities/EntityDeleteFailedException.cs

@@ -0,0 +1,569 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+using Kreta.Framework.Localization;
+using Kreta.Framework.Logging;
+using Kreta.Resources;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Az entitás nem törölhető, mert egy vagy több kapcsolódása még van.
+    /// </summary>
+    [FriendlyName(3478, "Az entitás nem törölhető, mert egy vagy több kapcsolódása még van: {Description} ({EntityName}.{AssociationName}).")]
+    [ErrorCode(Events.ENTITY_DELETEFAILED)]
+    [Serializable]
+    public sealed class EntityDeleteFailedException : EntityException
+    {
+        private const string ErrorMessage = "The entity could not be deleted due to one or more of its associations.";
+
+        private static readonly Dictionary<string, string> s_connectionErrorTableList = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+        {
+
+                {"T_ADATSZOLGALTATASENAPLO", ConnectionErrorTableResource.T_ADATSZOLGALTATASENAPLO},
+                {"T_ADATSZOLGALTATASENAPLO_OSSZES", ConnectionErrorTableResource.T_ADATSZOLGALTATASENAPLO_OSSZES},
+                {"T_AGAZATTIPUS", ConnectionErrorTableResource.T_AGAZATTIPUS},
+                {"T_AGAZATTIPUS_OSSZES", ConnectionErrorTableResource.T_AGAZATTIPUS_OSSZES},
+                {"T_ALKALMAZOTT", ConnectionErrorTableResource.T_ALKALMAZOTT},
+                {"T_ALKALMAZOTT_OSSZES", ConnectionErrorTableResource.T_ALKALMAZOTT_OSSZES},
+                {"T_ALLAMPOLGARSAG", ConnectionErrorTableResource.T_ALLAMPOLGARSAG},
+                {"T_ALLAMPOLGARSAG_OSSZES", ConnectionErrorTableResource.T_ALLAMPOLGARSAG_OSSZES},
+                {"T_ANYANYELV", ConnectionErrorTableResource.T_ANYANYELV},
+                {"T_ANYANYELV_OSSZES", ConnectionErrorTableResource.T_ANYANYELV_OSSZES},
+                {"T_BESOROLASIFOKOZATTIPUS", ConnectionErrorTableResource.T_BESOROLASIFOKOZATTIPUS},
+                {"T_BESOROLASIFOKOZATTIPUS_OSSZES", ConnectionErrorTableResource.T_BESOROLASIFOKOZATTIPUS_OSSZES},
+                {"T_CIM", ConnectionErrorTableResource.T_CIM},
+                {"T_CIM_OSSZES", ConnectionErrorTableResource.T_CIM_OSSZES},
+                {"T_CIMTIPUS", ConnectionErrorTableResource.T_CIMTIPUS},
+                {"T_CIMTIPUS_OSSZES", ConnectionErrorTableResource.T_CIMTIPUS_OSSZES},
+                {"T_CSENGETESIREND", ConnectionErrorTableResource.T_CSENGETESIREND},
+                {"T_CSENGETESIREND_OSSZES", ConnectionErrorTableResource.T_CSENGETESIREND_OSSZES},
+                {"T_CSENGETESIRENDORA", ConnectionErrorTableResource.T_CSENGETESIRENDORA},
+                {"T_CSENGETESIRENDORA_OSSZES", ConnectionErrorTableResource.T_CSENGETESIRENDORA_OSSZES},
+                {"T_CSOPORT", ConnectionErrorTableResource.T_CSOPORT},
+                {"T_CSOPORT_OSSZES", ConnectionErrorTableResource.T_CSOPORT_OSSZES},
+                {"T_CSOPORTTIPUS", ConnectionErrorTableResource.T_CSOPORTTIPUS},
+                {"T_CSOPORTTIPUS_OSSZES", ConnectionErrorTableResource.T_CSOPORTTIPUS_OSSZES},
+                {"T_CSOPORTTIPUS_FOGLALKOZASTIPU", ConnectionErrorTableResource.T_CSOPORTTIPUS_FOGLALKOZASTIPU},
+                {"T_CSOPORTTIPUS_FOGLALKOZASTIPU_OSSZES", ConnectionErrorTableResource.T_CSOPORTTIPUS_FOGLALKOZASTIPU_OSSZES},
+                {"T_DASHBOARDUZENETFELHASZNALO_OSSZES", ConnectionErrorTableResource.T_DASHBOARDUZENETFELHASZNALO_OSSZES},
+                {"T_DBVERSION", ConnectionErrorTableResource.T_DBVERSION},
+                {"T_DBVERSION_OSSZES", ConnectionErrorTableResource.T_DBVERSION_OSSZES},
+                {"T_DIAKIGAZOLVANYIGENYSTATUSZ", ConnectionErrorTableResource.T_DIAKIGAZOLVANYIGENYSTATUSZ},
+                {"T_DIAKIGAZOLVANYIGENYSTATUSZ_OSSZES", ConnectionErrorTableResource.T_DIAKIGAZOLVANYIGENYSTATUSZ_OSSZES},
+                {"T_DIAKIGAZOLVANYIGENYTIPUS", ConnectionErrorTableResource.T_DIAKIGAZOLVANYIGENYTIPUS},
+                {"T_DIAKIGAZOLVANYIGENYTIPUS_OSSZES", ConnectionErrorTableResource.T_DIAKIGAZOLVANYIGENYTIPUS_OSSZES},
+                {"T_DIAKOLIMPIA_OSSZES", ConnectionErrorTableResource.T_DIAKOLIMPIA_OSSZES},
+                {"T_DICTIONARYITEMBASE", ConnectionErrorTableResource.T_DICTIONARYITEMBASE},
+                {"T_DICTIONARYITEMBASE_OSSZES", ConnectionErrorTableResource.T_DICTIONARYITEMBASE_OSSZES},
+                {"T_DICTIONARYTYPE", ConnectionErrorTableResource.T_DICTIONARYTYPE},
+                {"T_DICTIONARYTYPE_OSSZES", ConnectionErrorTableResource.T_DICTIONARYTYPE_OSSZES},
+                {"T_DKT_FELADAT", ConnectionErrorTableResource.T_DKT_FELADAT},
+                {"T_DKT_FELADAT_OSSZES", ConnectionErrorTableResource.T_DKT_FELADAT},
+                {"T_DKT_FILE", ConnectionErrorTableResource.T_DKT_FILE},
+                {"T_DKT_FILE_OSSZES", ConnectionErrorTableResource.T_DKT_FILE},
+                {"T_ELEARNING", ConnectionErrorTableResource.T_ELEARNING},
+                {"T_ELEARNING_OSSZES", ConnectionErrorTableResource.T_ELEARNING_OSSZES},
+                {"T_ELETPALYAMODELLFOKOZATTIPUS", ConnectionErrorTableResource.T_ELETPALYAMODELLFOKOZATTIPUS},
+                {"T_ELETPALYAMODELLFOKOZATTIPUS_OSSZES", ConnectionErrorTableResource.T_ELETPALYAMODELLFOKOZATTIPUS_OSSZES},
+                {"T_ELETPALYAMODELLSTATUSZOK", ConnectionErrorTableResource.T_ELETPALYAMODELLSTATUSZOK},
+                {"T_ELETPALYAMODELLSTATUSZOK_OSSZES", ConnectionErrorTableResource.T_ELETPALYAMODELLSTATUSZOK_OSSZES},
+                {"T_ELSODLEGESIKTESZKOZ", ConnectionErrorTableResource.T_ELSODLEGESIKTESZKOZ},
+                {"T_ELSODLEGESIKTESZKOZ_OSSZES", ConnectionErrorTableResource.T_ELSODLEGESIKTESZKOZ_OSSZES},
+                {"T_EMAIL", ConnectionErrorTableResource.T_EMAIL},
+                {"T_EMAIL_OSSZES", ConnectionErrorTableResource.T_EMAIL_OSSZES},
+                {"T_EMAILTIPUS", ConnectionErrorTableResource.T_EMAILTIPUS},
+                {"T_EMAILTIPUS_OSSZES", ConnectionErrorTableResource.T_EMAILTIPUS_OSSZES},
+                {"T_ENAPLOFORRAS", ConnectionErrorTableResource.T_ENAPLOFORRAS},
+                {"T_ENAPLOFORRAS_OSSZES", ConnectionErrorTableResource.T_ENAPLOFORRAS_OSSZES},
+                {"T_ENAPLOHASZNALAT", ConnectionErrorTableResource.T_ENAPLOHASZNALAT},
+                {"T_ENAPLOHASZNALAT_OSSZES", ConnectionErrorTableResource.T_ENAPLOHASZNALAT_OSSZES},
+                {"T_ENAPLOINFRA", ConnectionErrorTableResource.T_ENAPLOINFRA},
+                {"T_ENAPLOINFRA_OSSZES", ConnectionErrorTableResource.T_ENAPLOINFRA_OSSZES},
+                {"T_ENAPLOTIPUS", ConnectionErrorTableResource.T_ENAPLOTIPUS},
+                {"T_ENAPLOTIPUS_OSSZES", ConnectionErrorTableResource.T_ENAPLOTIPUS_OSSZES},
+                {"T_ENTITYATTRIBUTEHISTORY", ConnectionErrorTableResource.T_ENTITYATTRIBUTEHISTORY},
+                {"T_ENTITYATTRIBUTEHISTORY_OSSZES", ConnectionErrorTableResource.T_ENTITYATTRIBUTEHISTORY_OSSZES},
+                {"T_ENTITYHISTORY", ConnectionErrorTableResource.T_ENTITYHISTORY},
+                {"T_ENTITYHISTORY_OSSZES", ConnectionErrorTableResource.T_ENTITYHISTORY_OSSZES},
+                {"T_ERETTSEGIEREDMENY", ConnectionErrorTableResource.T_ERETTSEGIEREDMENY},
+                {"T_ERETTSEGIEREDMENY_OSSZES", ConnectionErrorTableResource.T_ERETTSEGIEREDMENY_OSSZES},
+                {"T_ERETTSEGIKERDES", ConnectionErrorTableResource.T_ERETTSEGIKERDES},
+                {"T_ERETTSEGIKERDES_OSSZES", ConnectionErrorTableResource.T_ERETTSEGIKERDES_OSSZES},
+                {"T_ERETTSEGISZINT", ConnectionErrorTableResource.T_ERETTSEGISZINT},
+                {"T_ERETTSEGISZINT_OSSZES", ConnectionErrorTableResource.T_ERETTSEGISZINT_OSSZES},
+                {"T_ERETTSEGITANTARGY", ConnectionErrorTableResource.T_ERETTSEGITANTARGY},
+                {"T_ERETTSEGITANTARGY_OSSZES", ConnectionErrorTableResource.T_ERETTSEGITANTARGY_OSSZES},
+                {"T_ERETTSEGITANTARGYADATOK", ConnectionErrorTableResource.T_ERETTSEGITANTARGYADATOK},
+                {"T_ERETTSEGITANTARGYADATOK_OSSZES", ConnectionErrorTableResource.T_ERETTSEGITANTARGYADATOK_OSSZES},
+                {"T_ERETTSEGITIPUS", ConnectionErrorTableResource.T_ERETTSEGITIPUS},
+                {"T_ERETTSEGITIPUS_OSSZES", ConnectionErrorTableResource.T_ERETTSEGITIPUS_OSSZES},
+                {"T_ERETTSEGIVALASZ", ConnectionErrorTableResource.T_ERETTSEGIVALASZ},
+                {"T_ERETTSEGIVALASZ_OSSZES", ConnectionErrorTableResource.T_ERETTSEGIVALASZ_OSSZES},
+                {"T_ERRORSTATUS", ConnectionErrorTableResource.T_ERRORSTATUS},
+                {"T_ERRORSTATUS_OSSZES", ConnectionErrorTableResource.T_ERRORSTATUS_OSSZES},
+                {"T_ERRORTYPE", ConnectionErrorTableResource.T_ERRORTYPE},
+                {"T_ERRORTYPE_OSSZES", ConnectionErrorTableResource.T_ERRORTYPE_OSSZES},
+                {"T_ERTEKELESMOD", ConnectionErrorTableResource.T_ERTEKELESMOD},
+                {"T_ERTEKELESMOD_OSSZES", ConnectionErrorTableResource.T_ERTEKELESMOD_OSSZES},
+                {"T_ERTEKELESMONDATBANK", ConnectionErrorTableResource.T_ERTEKELESMONDATBANK},
+                {"T_ERTEKELESMONDATBANK_OSSZES", ConnectionErrorTableResource.T_ERTEKELESMONDATBANK_OSSZES},
+                {"T_ERTEKELESTIPUS", ConnectionErrorTableResource.T_ERTEKELESTIPUS},
+                {"T_ERTEKELESTIPUS_OSSZES", ConnectionErrorTableResource.T_ERTEKELESTIPUS_OSSZES},
+                {"T_ERTELMIFOGYATEKOSTIPUS", ConnectionErrorTableResource.T_ERTELMIFOGYATEKOSTIPUS},
+                {"T_ERTELMIFOGYATEKOSTIPUS_OSSZES", ConnectionErrorTableResource.T_ERTELMIFOGYATEKOSTIPUS_OSSZES},
+                {"T_ERTESITES", ConnectionErrorTableResource.T_ERTESITES},
+                {"T_ERTESITES_OSSZES", ConnectionErrorTableResource.T_ERTESITES_OSSZES},
+                {"T_ERTESITESGENERALASTORTENET", ConnectionErrorTableResource.T_ERTESITESGENERALASTORTENET},
+                {"T_ERTESITESGENERALASTORTENET_OSSZES", ConnectionErrorTableResource.T_ERTESITESGENERALASTORTENET_OSSZES},
+                {"T_ERTESITESSZINTIPUS", ConnectionErrorTableResource.T_ERTESITESSZINTIPUS},
+                {"T_ERTESITESSZINTIPUS_OSSZES", ConnectionErrorTableResource.T_ERTESITESSZINTIPUS_OSSZES},
+                {"T_ERTESITESTIPUS", ConnectionErrorTableResource.T_ERTESITESTIPUS},
+                {"T_ERTESITESTIPUS_OSSZES", ConnectionErrorTableResource.T_ERTESITESTIPUS_OSSZES},
+                {"T_ESEMENYSTATUSZ", ConnectionErrorTableResource.T_ESEMENYSTATUSZ},
+                {"T_ESEMENYSTATUSZ_OSSZES", ConnectionErrorTableResource.T_ESEMENYSTATUSZ_OSSZES},
+                {"T_ESEMENYTIPUS", ConnectionErrorTableResource.T_ESEMENYTIPUS},
+                {"T_ESEMENYTIPUS_OSSZES", ConnectionErrorTableResource.T_ESEMENYTIPUS_OSSZES},
+                {"T_ESLADAT", ConnectionErrorTableResource.T_ESLADAT},
+                {"T_ESLADAT_OSSZES", ConnectionErrorTableResource.T_ESLADAT_OSSZES},
+                {"T_ESLADATTIPUS", ConnectionErrorTableResource.T_ESLADATTIPUS},
+                {"T_ESLADATTIPUS_OSSZES", ConnectionErrorTableResource.T_ESLADATTIPUS_OSSZES},
+                {"T_ESZKOZ", ConnectionErrorTableResource.T_ESZKOZ},
+                {"T_ESZKOZ_OSSZES", ConnectionErrorTableResource.T_ESZKOZ_OSSZES},
+                {"T_ESZKOZCEL", ConnectionErrorTableResource.T_ESZKOZCEL},
+                {"T_ESZKOZCEL_OSSZES", ConnectionErrorTableResource.T_ESZKOZCEL_OSSZES},
+                {"T_ESZKOZJELLEG", ConnectionErrorTableResource.T_ESZKOZJELLEG},
+                {"T_ESZKOZJELLEG_OSSZES", ConnectionErrorTableResource.T_ESZKOZJELLEG_OSSZES},
+                {"T_ESZKOZKATEGORIA", ConnectionErrorTableResource.T_ESZKOZKATEGORIA},
+                {"T_ESZKOZKATEGORIA_OSSZES", ConnectionErrorTableResource.T_ESZKOZKATEGORIA_OSSZES},
+                {"T_ESZKOZTIPUS", ConnectionErrorTableResource.T_ESZKOZTIPUS},
+                {"T_ESZKOZTIPUS_OSSZES", ConnectionErrorTableResource.T_ESZKOZTIPUS_OSSZES},
+                {"T_ETKEZESIKEDVEZMENYTIPUS", ConnectionErrorTableResource.T_ETKEZESIKEDVEZMENYTIPUS},
+                {"T_ETKEZESIKEDVEZMENYTIPUS_OSSZES", ConnectionErrorTableResource.T_ETKEZESIKEDVEZMENYTIPUS_OSSZES},
+                {"T_EVFOLYAMTIPUS", ConnectionErrorTableResource.T_EVFOLYAMTIPUS},
+                {"T_EVFOLYAMTIPUS_OSSZES", ConnectionErrorTableResource.T_EVFOLYAMTIPUS_OSSZES},
+                {"T_EVFOLYAMTIPUS_OKTATASINEVELE", ConnectionErrorTableResource.T_EVFOLYAMTIPUS_OKTATASINEVELE},
+                {"T_EVFOLYAMTIPUS_OKTATASINEVELE_OSSZES", ConnectionErrorTableResource.T_EVFOLYAMTIPUS_OKTATASINEVELE_OSSZES},
+                {"T_FELADATELLATASIHELY", ConnectionErrorTableResource.T_FELADATELLATASIHELY},
+                {"T_FELADATELLATASIHELY_OSSZES", ConnectionErrorTableResource.T_FELADATELLATASIHELY_OSSZES},
+                {"T_FELHASZNALO", ConnectionErrorTableResource.T_FELHASZNALO},
+                {"T_FELHASZNALO_OSSZES", ConnectionErrorTableResource.T_FELHASZNALO_OSSZES},
+                {"T_FELHASZNALOBELEPES", ConnectionErrorTableResource.T_FELHASZNALOBELEPES},
+                {"T_FELHASZNALOBELEPES_OSSZES", ConnectionErrorTableResource.T_FELHASZNALOBELEPES_OSSZES},
+                {"T_FELHASZNALOBELEPESTORTENET", ConnectionErrorTableResource.T_FELHASZNALOBELEPESTORTENET},
+                {"T_FELHASZNALOBELEPESTORTENET_OSSZES", ConnectionErrorTableResource.T_FELHASZNALOBELEPESTORTENET_OSSZES},
+                {"T_FELHASZNALOBELEPESTORTENET_S", ConnectionErrorTableResource.T_FELHASZNALOBELEPESTORTENET_S},
+                {"T_FELHASZNALO_SZEREPKOR", ConnectionErrorTableResource.T_FELHASZNALO_SZEREPKOR},
+                {"T_FELJEGYZESTIPUS", ConnectionErrorTableResource.T_FELJEGYZESTIPUS},
+                {"T_FELJEGYZESTIPUS_OSSZES", ConnectionErrorTableResource.T_FELJEGYZESTIPUS_OSSZES},
+                {"T_FELVETELSTATUSZATIPUS", ConnectionErrorTableResource.T_FELVETELSTATUSZATIPUS},
+                {"T_FELVETELSTATUSZATIPUS_OSSZES", ConnectionErrorTableResource.T_FELVETELSTATUSZATIPUS_OSSZES},
+                {"T_FENNTARTO", ConnectionErrorTableResource.T_FENNTARTO},
+                {"T_FENNTARTO_OSSZES", ConnectionErrorTableResource.T_FENNTARTO_OSSZES},
+                {"T_FENNTARTOTIPUS", ConnectionErrorTableResource.T_FENNTARTOTIPUS},
+                {"T_FENNTARTOTIPUS_OSSZES", ConnectionErrorTableResource.T_FENNTARTOTIPUS_OSSZES},
+                {"T_FOGADOORA", ConnectionErrorTableResource.T_FOGADOORA},
+                {"T_FOGADOORA_OSSZES", ConnectionErrorTableResource.T_FOGADOORA_OSSZES},
+                {"T_FOGLALKOZAS", ConnectionErrorTableResource.T_FOGLALKOZAS},
+                {"T_FOGLALKOZAS_OSSZES", ConnectionErrorTableResource.T_FOGLALKOZAS_OSSZES},
+                {"T_FOGLALKOZASAMITANULO_OSSZES", ConnectionErrorTableResource.T_FOGLALKOZASAMITANULO_OSSZES },
+                {"T_FOGLALKOZASARCHIV", ConnectionErrorTableResource.T_FOGLALKOZASARCHIV},
+                {"T_FOGLALKOZASARCHIV_OSSZES", ConnectionErrorTableResource.T_FOGLALKOZASARCHIV_OSSZES},
+                {"T_FOGLALKOZASOK_TANAROK", ConnectionErrorTableResource.T_FOGLALKOZASOK_TANAROK},
+                {"T_FOGLALKOZASTIPUS", ConnectionErrorTableResource.T_FOGLALKOZASTIPUS},
+                {"T_FOGLALKOZASTIPUS_OSSZES", ConnectionErrorTableResource.T_FOGLALKOZASTIPUS_OSSZES},
+                {"T_FOGLALKOZTATASTIPUSA", ConnectionErrorTableResource.T_FOGLALKOZTATASTIPUSA},
+                {"T_FOGLALKOZTATASTIPUSA_OSSZES", ConnectionErrorTableResource.T_FOGLALKOZTATASTIPUSA_OSSZES},
+                {"T_FORRAS", ConnectionErrorTableResource.T_FORRAS},
+                {"T_FORRAS_OSSZES", ConnectionErrorTableResource.T_FORRAS_OSSZES},
+                {"T_GIMNAZIUMIEVFOLYAMTIPUS", ConnectionErrorTableResource.T_GIMNAZIUMIEVFOLYAMTIPUS},
+                {"T_GIMNAZIUMIEVFOLYAMTIPUS_OSSZES", ConnectionErrorTableResource.T_GIMNAZIUMIEVFOLYAMTIPUS_OSSZES},
+                {"T_GONDVISELO", ConnectionErrorTableResource.T_GONDVISELO},
+                {"T_GONDVISELO_OSSZES", ConnectionErrorTableResource.T_GONDVISELO_OSSZES},
+                {"T_HALLASSERULTTIPUS", ConnectionErrorTableResource.T_HALLASSERULTTIPUS},
+                {"T_HALLASSERULTTIPUS_OSSZES", ConnectionErrorTableResource.T_HALLASSERULTTIPUS_OSSZES},
+                {"T_HATRANYOSHELYZETTIPUS", ConnectionErrorTableResource.T_HATRANYOSHELYZETTIPUS},
+                {"T_HATRANYOSHELYZETTIPUS_OSSZES", ConnectionErrorTableResource.T_HATRANYOSHELYZETTIPUS_OSSZES},
+                {"T_HAZIFELADATOK", ConnectionErrorTableResource.T_HAZIFELADATOK},
+                {"T_HAZIFELADATOK_OSSZES", ConnectionErrorTableResource.T_HAZIFELADATOK_OSSZES},
+                {"T_HELYETTESITESIIDOSZAK", ConnectionErrorTableResource.T_HELYETTESITESIIDOSZAK},
+                {"T_HELYETTESITESIIDOSZAK_OSSZES", ConnectionErrorTableResource.T_HELYETTESITESIIDOSZAK_OSSZES},
+                {"T_HELYETTESITESTIPUS", ConnectionErrorTableResource.T_HELYETTESITESTIPUS},
+                {"T_HELYETTESITESTIPUS_OSSZES", ConnectionErrorTableResource.T_HELYETTESITESTIPUS_OSSZES},
+                {"T_HETIRENDTIPUS", ConnectionErrorTableResource.T_HETIRENDTIPUS},
+                {"T_HETIRENDTIPUS_OSSZES", ConnectionErrorTableResource.T_HETIRENDTIPUS_OSSZES},
+                {"T_HETNAPJATIPUS", ConnectionErrorTableResource.T_HETNAPJATIPUS},
+                {"T_HETNAPJATIPUS_OSSZES", ConnectionErrorTableResource.T_HETNAPJATIPUS_OSSZES},
+                {"T_HIBAJEGYSTATUSZ", ConnectionErrorTableResource.T_HIBAJEGYSTATUSZ},
+                {"T_HIBAJEGYSTATUSZ_OSSZES", ConnectionErrorTableResource.T_HIBAJEGYSTATUSZ_OSSZES},
+                {"T_HITTANADATSZOLGALTATAS", ConnectionErrorTableResource.T_HITTANADATSZOLGALTATAS},
+                {"T_HITTANADATSZOLGALTATAS_OSSZES", ConnectionErrorTableResource.T_HITTANADATSZOLGALTATAS_OSSZES},
+                {"T_HITTANTIPUS", ConnectionErrorTableResource.T_HITTANTIPUS},
+                {"T_HITTANTIPUS_OSSZES", ConnectionErrorTableResource.T_HITTANTIPUS_OSSZES},
+                {"T_HONAPOK", ConnectionErrorTableResource.T_HONAPOK},
+                {"T_HONAPOK_OSSZES", ConnectionErrorTableResource.T_HONAPOK_OSSZES},
+                {"T_IDOKERET", ConnectionErrorTableResource.T_IDOKERET},
+                {"T_IDOKERET_OSSZES", ConnectionErrorTableResource.T_IDOKERET_OSSZES},
+                {"T_IGAZOLAS", ConnectionErrorTableResource.T_IGAZOLAS},
+                {"T_IGAZOLAS_OSSZES", ConnectionErrorTableResource.T_IGAZOLAS_OSSZES},
+                {"T_IGAZOLASTIPUS", ConnectionErrorTableResource.T_IGAZOLASTIPUS},
+                {"T_IGAZOLASTIPUS_OSSZES", ConnectionErrorTableResource.T_IGAZOLASTIPUS_OSSZES},
+                {"T_IGAZOLVANYTIPUS", ConnectionErrorTableResource.T_IGAZOLVANYTIPUS},
+                {"T_IGAZOLVANYTIPUS_OSSZES", ConnectionErrorTableResource.T_IGAZOLVANYTIPUS_OSSZES},
+                {"T_IKTATOTTDOKUMENTUM", ConnectionErrorTableResource.T_IKTATOTTDOKUMENTUM},
+                {"T_IKTATOTTDOKUMENTUM_OSSZES", ConnectionErrorTableResource.T_IKTATOTTDOKUMENTUM_OSSZES},
+                {"T_IKTATOTTDOKUMENTUMOK", ConnectionErrorTableResource.T_IKTATOTTDOKUMENTUMOK},
+                {"T_IKTATOTTDOKUMENTUMOK_OSSZES", ConnectionErrorTableResource.T_IKTATOTTDOKUMENTUMOK_OSSZES},
+                {"T_IKTESZKOZHASZNALATMOD", ConnectionErrorTableResource.T_IKTESZKOZHASZNALATMOD},
+                {"T_IKTESZKOZHASZNALATMOD_OSSZES", ConnectionErrorTableResource.T_IKTESZKOZHASZNALATMOD_OSSZES},
+                {"T_IKTKOMPETENCIASZINT", ConnectionErrorTableResource.T_IKTKOMPETENCIASZINT},
+                {"T_IKTKOMPETENCIASZINT_OSSZES", ConnectionErrorTableResource.T_IKTKOMPETENCIASZINT_OSSZES},
+                {"T_INGYENESTANKONYVELLATAS", ConnectionErrorTableResource.T_INGYENESTANKONYVELLATAS},
+                {"T_INGYENESTANKONYVELLATAS_OSSZES", ConnectionErrorTableResource.T_INGYENESTANKONYVELLATAS_OSSZES},
+                {"T_INTEZMENY", ConnectionErrorTableResource.T_INTEZMENY},
+                {"T_INTEZMENY_OSSZES", ConnectionErrorTableResource.T_INTEZMENY_OSSZES},
+                {"T_INTEZMENYADATOK", ConnectionErrorTableResource.T_INTEZMENYADATOK},
+                {"T_INTEZMENYADATOK_OSSZES", ConnectionErrorTableResource.T_INTEZMENYADATOK_OSSZES},
+                {"T_INTEZMENYADATSZOLGALTATAS", ConnectionErrorTableResource.T_INTEZMENYADATSZOLGALTATAS},
+                {"T_INTEZMENYADATSZOLGALTATAS_OSSZES", ConnectionErrorTableResource.T_INTEZMENYADATSZOLGALTATAS_OSSZES},
+                {"T_INTEZMENYESZKOZADATSZOLGALTA", ConnectionErrorTableResource.T_INTEZMENYESZKOZADATSZOLGALTA},
+                {"T_INTEZMENYESZKOZADATSZOLGALTA_OSSZES", ConnectionErrorTableResource.T_INTEZMENYESZKOZADATSZOLGALTA_OSSZES},
+                {"T_JELSZOVISSZAALLITAS", ConnectionErrorTableResource.T_JELSZOVISSZAALLITAS},
+                {"T_JELSZOVISSZAALLITAS_OSSZES", ConnectionErrorTableResource.T_JELSZOVISSZAALLITAS_OSSZES},
+                {"T_JOGOSULTFELHASZNALOK_HOZZARE", ConnectionErrorTableResource.T_JOGOSULTFELHASZNALOK_HOZZARE},
+                {"T_JOGOSULTSAG", ConnectionErrorTableResource.T_JOGOSULTSAG},
+                {"T_JOGOSULTSAG_OSSZES", ConnectionErrorTableResource.T_JOGOSULTSAG_OSSZES},
+                {"T_JOGOSULTSAG_FELHASZNALO", ConnectionErrorTableResource.T_JOGOSULTSAG_FELHASZNALO},
+                {"T_JUTTATAS", ConnectionErrorTableResource.T_JUTTATAS},
+                {"T_JUTTATAS_OSSZES", ConnectionErrorTableResource.T_JUTTATAS},
+                {"T_KEPESITES", ConnectionErrorTableResource.T_KEPESITES},
+                {"T_KEPESITES_OSSZES", ConnectionErrorTableResource.T_KEPESITES_OSSZES},
+                {"T_KEPESITES_VEGZETTSEG", ConnectionErrorTableResource.T_KEPESITES_VEGZETTSEG},
+                {"T_KIRTELEPHELY", ConnectionErrorTableResource.T_KIRTELEPHELY},
+                {"T_KIRTELEPHELY_OSSZES", ConnectionErrorTableResource.T_KIRTELEPHELY_OSSZES},
+                {"T_KIZAROCSOPORTTIPUS", ConnectionErrorTableResource.T_KIZAROCSOPORTTIPUS},
+                {"T_KIZAROCSOPORTTIPUS_OSSZES", ConnectionErrorTableResource.T_KIZAROCSOPORTTIPUS_OSSZES},
+                {"T_KKAMIVEGZETTSEG", ConnectionErrorTableResource.T_KKAMIVEGZETTSEG},
+                {"T_KKAMIVEGZETTSEG_OSSZES", ConnectionErrorTableResource.T_KKAMIVEGZETTSEG_OSSZES},
+                {"T_KKGYOGYPEDVEGZETTSEG", ConnectionErrorTableResource.T_KKGYOGYPEDVEGZETTSEG},
+                {"T_KKGYOGYPEDVEGZETTSEG_OSSZES", ConnectionErrorTableResource.T_KKGYOGYPEDVEGZETTSEG_OSSZES},
+                {"T_KKTANARVEGZETTSEG", ConnectionErrorTableResource.T_KKTANARVEGZETTSEG},
+                {"T_KKTANARVEGZETTSEG_OSSZES", ConnectionErrorTableResource.T_KKTANARVEGZETTSEG_OSSZES},
+                {"T_KKTANITOVEZGETTSEG", ConnectionErrorTableResource.T_KKTANITOVEZGETTSEG},
+                {"T_KKTANITOVEZGETTSEG_OSSZES", ConnectionErrorTableResource.T_KKTANITOVEZGETTSEG_OSSZES},
+                {"T_KOZMUSZAMLA", ConnectionErrorTableResource.T_KOZMUSZAMLA},
+                {"T_KOZMUSZAMLA_OSSZES", ConnectionErrorTableResource.T_KOZMUSZAMLA_OSSZES},
+                {"T_KOZMUSZAMLATIPUS", ConnectionErrorTableResource.T_KOZMUSZAMLATIPUS},
+                {"T_KOZMUSZAMLATIPUS_OSSZES", ConnectionErrorTableResource.T_KOZMUSZAMLATIPUS_OSSZES},
+                {"T_KOZOSSEGISZOLGALATTIPUS", ConnectionErrorTableResource.T_KOZOSSEGISZOLGALATTIPUS},
+                {"T_KOZOSSEGISZOLGALATTIPUS_OSSZES", ConnectionErrorTableResource.T_KOZOSSEGISZOLGALATTIPUS_OSSZES},
+                {"T_KOZTERULETJELLEG", ConnectionErrorTableResource.T_KOZTERULETJELLEG},
+                {"T_KOZTERULETJELLEG_OSSZES", ConnectionErrorTableResource.T_KOZTERULETJELLEG_OSSZES},
+                {"T_KRETATIPUS", ConnectionErrorTableResource.T_KRETATIPUS},
+                {"T_KRETATIPUS_OSSZES", ConnectionErrorTableResource.T_KRETATIPUS_OSSZES},
+                {"T_KULFOLDISTATUSZTIPUS", ConnectionErrorTableResource.T_KULFOLDISTATUSZTIPUS},
+                {"T_KULFOLDISTATUSZTIPUS_OSSZES", ConnectionErrorTableResource.T_KULFOLDISTATUSZTIPUS_OSSZES},
+                {"T_LATASSERULTTIPUS", ConnectionErrorTableResource.T_LATASSERULTTIPUS},
+                {"T_LATASSERULTTIPUS_OSSZES", ConnectionErrorTableResource.T_LATASSERULTTIPUS_OSSZES},
+                {"T_LICENCE", ConnectionErrorTableResource.T_LICENCE},
+                {"T_LICENCE_OSSZES", ConnectionErrorTableResource.T_LICENCE_OSSZES},
+                {"T_LICENCEFUNKCIOKTIPUS", ConnectionErrorTableResource.T_LICENCEFUNKCIOKTIPUS},
+                {"T_LICENCEFUNKCIOKTIPUS_OSSZES", ConnectionErrorTableResource.T_LICENCEFUNKCIOKTIPUS_OSSZES},
+                {"T_LOG", ConnectionErrorTableResource.T_LOG},
+                {"T_LOG_OSSZES", ConnectionErrorTableResource.T_LOG_OSSZES},
+                {"T_LOGEVENTTYPE", ConnectionErrorTableResource.T_LOGEVENTTYPE},
+                {"T_LOGEVENTTYPE_OSSZES", ConnectionErrorTableResource.T_LOGEVENTTYPE_OSSZES},
+                {"T_LOGLEVELTYPE", ConnectionErrorTableResource.T_LOGLEVELTYPE},
+                {"T_LOGLEVELTYPE_OSSZES", ConnectionErrorTableResource.T_LOGLEVELTYPE_OSSZES},
+                {"T_MAGANTANULOSAGOKA", ConnectionErrorTableResource.T_MAGANTANULOSAGOKA},
+                {"T_MAGANTANULOSAGOKA_OSSZES", ConnectionErrorTableResource.T_MAGANTANULOSAGOKA_OSSZES},
+                {"T_MAGATARTASERTEKELESTIPUS", ConnectionErrorTableResource.T_MAGATARTASERTEKELESTIPUS},
+                {"T_MAGATARTASERTEKELESTIPUS_OSSZES", ConnectionErrorTableResource.T_MAGATARTASERTEKELESTIPUS_OSSZES},
+                {"T_MEGYE", ConnectionErrorTableResource.T_MEGYE},
+                {"T_MEGYE_OSSZES", ConnectionErrorTableResource.T_MEGYE_OSSZES},
+                {"T_MEROALLAS", ConnectionErrorTableResource.T_MEROALLAS},
+                {"T_MEROALLAS_OSSZES", ConnectionErrorTableResource.T_MEROALLAS_OSSZES},
+                {"T_MEROHELY", ConnectionErrorTableResource.T_MEROHELY},
+                {"T_MEROHELY_OSSZES", ConnectionErrorTableResource.T_MEROHELY_OSSZES},
+                {"T_MEROHELYTIPUS", ConnectionErrorTableResource.T_MEROHELYTIPUS},
+                {"T_MEROHELYTIPUS_OSSZES", ConnectionErrorTableResource.T_MEROHELYTIPUS_OSSZES},
+                {"T_MERTEKEGYSEGTIPUS", ConnectionErrorTableResource.T_MERTEKEGYSEGTIPUS},
+                {"T_MERTEKEGYSEGTIPUS_OSSZES", ConnectionErrorTableResource.T_MERTEKEGYSEGTIPUS_OSSZES},
+                {"T_MESSAGESTATUS", ConnectionErrorTableResource.T_MESSAGESTATUS},
+                {"T_MESSAGESTATUS_OSSZES", ConnectionErrorTableResource.T_MESSAGESTATUS_OSSZES},
+                {"T_MUKODESIHELY", ConnectionErrorTableResource.T_MUKODESIHELY},
+                {"T_MUKODESIHELY_OSSZES", ConnectionErrorTableResource.T_MUKODESIHELY_OSSZES},
+                {"T_MUKODESIHELYADATSZOLGALTATAS", ConnectionErrorTableResource.T_MUKODESIHELYADATSZOLGALTATAS},
+                {"T_MUKODESIHELYADATSZOLGALTATAS_OSSZES", ConnectionErrorTableResource.T_MUKODESIHELYADATSZOLGALTATAS_OSSZES},
+                {"T_MUKODESIHELYTIPUS", ConnectionErrorTableResource.T_MUKODESIHELYTIPUS},
+                {"T_MUKODESIHELYTIPUS_OSSZES", ConnectionErrorTableResource.T_MUKODESIHELYTIPUS_OSSZES},
+                {"T_MULASZTASSTATISZTIKATIPUS", ConnectionErrorTableResource.T_MULASZTASSTATISZTIKATIPUS},
+                {"T_MULASZTASSTATISZTIKATIPUS_OSSZES", ConnectionErrorTableResource.T_MULASZTASSTATISZTIKATIPUS_OSSZES},
+                {"T_MULASZTASTIPUS", ConnectionErrorTableResource.T_MULASZTASTIPUS},
+                {"T_MULASZTASTIPUS_OSSZES", ConnectionErrorTableResource.T_MULASZTASTIPUS_OSSZES},
+                {"T_MUNKAIDOKEDVEZMENYOKA", ConnectionErrorTableResource.T_MUNKAIDOKEDVEZMENYOKA},
+                {"T_MUNKAIDOKEDVEZMENYOKA_OSSZES", ConnectionErrorTableResource.T_MUNKAIDOKEDVEZMENYOKA_OSSZES},
+                {"T_MUNKAKORTIPUS", ConnectionErrorTableResource.T_MUNKAKORTIPUS},
+                {"T_MUNKAKORTIPUS_OSSZES", ConnectionErrorTableResource.T_MUNKAKORTIPUS_OSSZES},
+                {"T_MUNKAUGYIADATOK", ConnectionErrorTableResource.T_MUNKAUGYIADATOK},
+                {"T_MUNKAUGYIADATOK_OSSZES", ConnectionErrorTableResource.T_MUNKAUGYIADATOK_OSSZES},
+                {"T_MUNKAVISZONYJELLEGE", ConnectionErrorTableResource.T_MUNKAVISZONYJELLEGE},
+                {"T_MUNKAVISZONYJELLEGE_OSSZES", ConnectionErrorTableResource.T_MUNKAVISZONYJELLEGE_OSSZES},
+                {"T_MUNKAVISZONYTIPUS", ConnectionErrorTableResource.T_MUNKAVISZONYTIPUS},
+                {"T_MUNKAVISZONYTIPUS_OSSZES", ConnectionErrorTableResource.T_MUNKAVISZONYTIPUS_OSSZES},
+                {"T_NAPLOELLENORZES", ConnectionErrorTableResource.T_NAPLOELLENORZES},
+                {"T_NAPLOELLENORZES_OSSZES", ConnectionErrorTableResource.T_NAPLOELLENORZES_OSSZES},
+                {"T_NAPTARIHET", ConnectionErrorTableResource.T_NAPTARIHET},
+                {"T_NAPTARIHET_OSSZES", ConnectionErrorTableResource.T_NAPTARIHET_OSSZES},
+                {"T_NAPTARINAP", ConnectionErrorTableResource.T_NAPTARINAP},
+                {"T_NAPTARINAP_OSSZES", ConnectionErrorTableResource.T_NAPTARINAP_OSSZES},
+                {"T_NAPTIPUS", ConnectionErrorTableResource.T_NAPTIPUS},
+                {"T_NAPTIPUS_OSSZES", ConnectionErrorTableResource.T_NAPTIPUS_OSSZES},
+                {"T_NATKERDOIV", ConnectionErrorTableResource.T_NATKERDOIV},
+                {"T_NATKERDOIV_OSSZES", ConnectionErrorTableResource.T_NATKERDOIV_OSSZES},
+                {"T_NEBULO", ConnectionErrorTableResource.T_NEBULO},
+                {"T_NEBULO_OSSZES", ConnectionErrorTableResource.T_NEBULO_OSSZES},
+                {"T_NEM", ConnectionErrorTableResource.T_NEM},
+                {"T_NEM_OSSZES", ConnectionErrorTableResource.T_NEM_OSSZES},
+                {"T_NEMKOTOTTMUNKAIDO", ConnectionErrorTableResource.T_NEMKOTOTTMUNKAIDO},
+                {"T_NEMKOTOTTMUNKAIDO_OSSZES", ConnectionErrorTableResource.T_NEMKOTOTTMUNKAIDO_OSSZES},
+                {"T_OKTATASINEVELESIFELADAT", ConnectionErrorTableResource.T_OKTATASINEVELESIFELADAT},
+                {"T_OKTATASINEVELESIFELADAT_OSSZES", ConnectionErrorTableResource.T_OKTATASINEVELESIFELADAT_OSSZES},
+                {"T_OLDALLATOGATOTTSAG", ConnectionErrorTableResource.T_OLDALLATOGATOTTSAG},
+                {"T_OLDALLATOGATOTTSAG_OSSZES", ConnectionErrorTableResource.T_OLDALLATOGATOTTSAG_OSSZES},
+                {"T_ORAK_TANAROK", ConnectionErrorTableResource.T_ORAK_TANAROK},
+                {"T_ORALATOGATAS", ConnectionErrorTableResource.T_ORALATOGATAS},
+                {"T_ORALATOGATAS_OSSZES", ConnectionErrorTableResource.T_ORALATOGATAS_OSSZES},
+                {"T_ORAREND", ConnectionErrorTableResource.T_ORAREND},
+                {"T_ORAREND_OSSZES", ConnectionErrorTableResource.T_ORAREND_OSSZES},
+                {"T_ORARENDIORA", ConnectionErrorTableResource.T_ORARENDIORA},
+                {"T_ORARENDIORA_OSSZES", ConnectionErrorTableResource.T_ORARENDIORA_OSSZES},
+                {"T_ORARENDIORATULAJDONSAG", ConnectionErrorTableResource.T_ORARENDIORATULAJDONSAG},
+                {"T_ORARENDIORATULAJDONSAG_OSSZES", ConnectionErrorTableResource.T_ORARENDIORATULAJDONSAG_OSSZES},
+                {"T_ORARENDORATULAJDONSAG", ConnectionErrorTableResource.T_ORARENDORATULAJDONSAG},
+                {"T_ORARENDORATULAJDONSAG_OSSZES", ConnectionErrorTableResource.T_ORARENDORATULAJDONSAG_OSSZES},
+                {"T_ORARENDSABLON", ConnectionErrorTableResource.T_ORARENDSABLON},
+                {"T_ORARENDSABLON_OSSZES", ConnectionErrorTableResource.T_ORARENDSABLON_OSSZES},
+                {"T_ORATERV", ConnectionErrorTableResource.T_ORATERV},
+                {"T_ORATERV_OSSZES", ConnectionErrorTableResource.T_ORATERV_OSSZES},
+                {"T_ORATERVTARGY", ConnectionErrorTableResource.T_ORATERVTARGY},
+                {"T_ORATERVTARGY_OSSZES", ConnectionErrorTableResource.T_ORATERVTARGY_OSSZES},
+                {"T_ORATULAJDONSAGTIPUS", ConnectionErrorTableResource.T_ORATULAJDONSAGTIPUS},
+                {"T_ORATULAJDONSAGTIPUS_OSSZES", ConnectionErrorTableResource.T_ORATULAJDONSAGTIPUS_OSSZES},
+                {"T_ORSZAGTIPUS", ConnectionErrorTableResource.T_ORSZAGTIPUS},
+                {"T_ORSZAGTIPUS_OSSZES", ConnectionErrorTableResource.T_ORSZAGTIPUS_OSSZES},
+                {"T_OSSZEGTULLEPESTIPUS", ConnectionErrorTableResource.T_OSSZEGTULLEPESTIPUS},
+                {"T_OSSZEGTULLEPESTIPUS_OSSZES", ConnectionErrorTableResource.T_OSSZEGTULLEPESTIPUS_OSSZES},
+                {"T_OSZTALY", ConnectionErrorTableResource.T_OSZTALY},
+                {"T_OSZTALY_OSSZES", ConnectionErrorTableResource.T_OSZTALY_OSSZES},
+                {"T_OSZTALYCSOPORT", ConnectionErrorTableResource.T_OSZTALYCSOPORT},
+                {"T_OSZTALYCSOPORT_OSSZES", ConnectionErrorTableResource.T_OSZTALYCSOPORT_OSSZES},
+                {"T_OSZTALYCSOPORT_TANEVRENDJE", ConnectionErrorTableResource.T_OSZTALYCSOPORT_TANEVRENDJE},
+                {"T_OSZTALYCSOPORT_TANULOESEMENY", ConnectionErrorTableResource.T_OSZTALYCSOPORT_TANULOESEMENY},
+                {"T_OSZTALYFONOKIERTEKELES", ConnectionErrorTableResource.T_OSZTALYFONOKIERTEKELES},
+                {"T_OSZTALYFONOKIERTEKELES_OSSZES", ConnectionErrorTableResource.T_OSZTALYFONOKIERTEKELES_OSSZES},
+                {"T_OSZTALYZATERTEKELES", ConnectionErrorTableResource.T_OSZTALYZATERTEKELES},
+                {"T_OSZTALYZATERTEKELES_OSSZES", ConnectionErrorTableResource.T_OSZTALYZATERTEKELES_OSSZES},
+                {"T_OSZTALYZATTIPUS", ConnectionErrorTableResource.T_OSZTALYZATTIPUS},
+                {"T_OSZTALYZATTIPUS_OSSZES", ConnectionErrorTableResource.T_OSZTALYZATTIPUS_OSSZES},
+                {"T_PEDAGOGUSELETPALYAMODELL", ConnectionErrorTableResource.T_PEDAGOGUSELETPALYAMODELL},
+                {"T_PEDAGOGUSELETPALYAMODELL_OSSZES", ConnectionErrorTableResource.T_PEDAGOGUSELETPALYAMODELL_OSSZES},
+                {"T_PEDAGOGUSIKTADATSZOLGALTATAS", ConnectionErrorTableResource.T_PEDAGOGUSIKTADATSZOLGALTATAS},
+                {"T_PEDAGOGUSIKTADATSZOLGALTATAS_OSSZES", ConnectionErrorTableResource.T_PEDAGOGUSIKTADATSZOLGALTATAS_OSSZES},
+                {"T_PEDAGOGUSSTATUSZ", ConnectionErrorTableResource.T_PEDAGOGUSSTATUSZ},
+                {"T_PEDAGOGUSSTATUSZ_OSSZES", ConnectionErrorTableResource.T_PEDAGOGUSSTATUSZ_OSSZES},
+                {"T_PENZNEMTIPUS", ConnectionErrorTableResource.T_PENZNEMTIPUS},
+                {"T_PENZNEMTIPUS_OSSZES", ConnectionErrorTableResource.T_PENZNEMTIPUS_OSSZES},
+                {"T_PRIORITAS", ConnectionErrorTableResource.T_PRIORITAS},
+                {"T_PRIORITAS_OSSZES", ConnectionErrorTableResource.T_PRIORITAS_OSSZES},
+                {"T_RENDSZERBEALLITAS", ConnectionErrorTableResource.T_RENDSZERBEALLITAS},
+                {"T_RENDSZERBEALLITAS_OSSZES", ConnectionErrorTableResource.T_RENDSZERBEALLITAS_OSSZES},
+                {"T_RENDSZERBEALLITASTIPUS", ConnectionErrorTableResource.T_RENDSZERBEALLITASTIPUS},
+                {"T_RENDSZERBEALLITASTIPUS_OSSZES", ConnectionErrorTableResource.T_RENDSZERBEALLITASTIPUS_OSSZES},
+                {"T_RENDSZERERTESITESEK", ConnectionErrorTableResource.T_RENDSZERERTESITESEK},
+                {"T_RENDSZERERTESITESEK_OSSZES", ConnectionErrorTableResource.T_RENDSZERERTESITESEK_OSSZES},
+                {"T_RESZSZAKKEPESITESTIPUS", ConnectionErrorTableResource.T_RESZSZAKKEPESITESTIPUS},
+                {"T_RESZSZAKKEPESITESTIPUS_OSSZES", ConnectionErrorTableResource.T_RESZSZAKKEPESITESTIPUS_OSSZES},
+                {"T_ROKONSAGIFOK", ConnectionErrorTableResource.T_ROKONSAGIFOK},
+                {"T_ROKONSAGIFOK_OSSZES", ConnectionErrorTableResource.T_ROKONSAGIFOK_OSSZES},
+                {"T_SMSMESSAGESTATUS", ConnectionErrorTableResource.T_SMSMESSAGESTATUS},
+                {"T_SMSMESSAGESTATUS_OSSZES", ConnectionErrorTableResource.T_SMSMESSAGESTATUS_OSSZES},
+                {"T_SOROLASOKATIPUS", ConnectionErrorTableResource.T_SOROLASOKATIPUS},
+                {"T_SOROLASOKATIPUS_OSSZES", ConnectionErrorTableResource.T_SOROLASOKATIPUS_OSSZES},
+                {"T_SYSTEMSETTINGSCONTROLTYPE", ConnectionErrorTableResource.T_SYSTEMSETTINGSCONTROLTYPE},
+                {"T_SYSTEMSETTINGSCONTROLTYPE_OSSZES", ConnectionErrorTableResource.T_SYSTEMSETTINGSCONTROLTYPE_OSSZES},
+                {"T_SZAKKEPESITESTIPUS", ConnectionErrorTableResource.T_SZAKKEPESITESTIPUS},
+                {"T_SZAKKEPESITESTIPUS_OSSZES", ConnectionErrorTableResource.T_SZAKKEPESITESTIPUS_OSSZES},
+                {"T_SZAKMACSOPORTTIPUS", ConnectionErrorTableResource.T_SZAKMACSOPORTTIPUS},
+                {"T_SZAKMACSOPORTTIPUS_OSSZES", ConnectionErrorTableResource.T_SZAKMACSOPORTTIPUS_OSSZES},
+                {"T_SZEREPKOR", ConnectionErrorTableResource.T_SZEREPKOR},
+                {"T_SZEREPKOR_OSSZES", ConnectionErrorTableResource.T_SZEREPKOR_OSSZES},
+                {"T_SZEREPKORTIPUS", ConnectionErrorTableResource.T_SZEREPKORTIPUS},
+                {"T_SZEREPKORTIPUS_OSSZES", ConnectionErrorTableResource.T_SZEREPKORTIPUS_OSSZES},
+                {"T_SZERVEZET", ConnectionErrorTableResource.T_SZERVEZET},
+                {"T_SZERVEZET_OSSZES", ConnectionErrorTableResource.T_SZERVEZET_OSSZES},
+                {"T_SZERZODOSZEMELYPOZICIO", ConnectionErrorTableResource.T_SZERZODOSZEMELYPOZICIO},
+                {"T_SZERZODOSZEMELYPOZICIO_OSSZES", ConnectionErrorTableResource.T_SZERZODOSZEMELYPOZICIO_OSSZES},
+                {"T_SZORGALOMERTEKELESTIPUS", ConnectionErrorTableResource.T_SZORGALOMERTEKELESTIPUS},
+                {"T_SZORGALOMERTEKELESTIPUS_OSSZES", ConnectionErrorTableResource.T_SZORGALOMERTEKELESTIPUS_OSSZES},
+                {"T_SZOVEGESERTEKELESEK", ConnectionErrorTableResource.T_SZOVEGESERTEKELESEK},
+                {"T_SZOVEGESERTEKELESEK_OSSZES", ConnectionErrorTableResource.T_SZOVEGESERTEKELESEK_OSSZES},
+                {"T_TAGOZATTIPUS", ConnectionErrorTableResource.T_TAGOZATTIPUS},
+                {"T_TAGOZATTIPUS_OSSZES", ConnectionErrorTableResource.T_TAGOZATTIPUS_OSSZES},
+                {"T_TANARIATLAGSULY", ConnectionErrorTableResource.T_TANARIATLAGSULY},
+                {"T_TANARIATLAGSULY_OSSZES", ConnectionErrorTableResource.T_TANARIATLAGSULY_OSSZES},
+                {"T_TANARTARGYATLAG", ConnectionErrorTableResource.T_TANARTARGYATLAG},
+                {"T_TANEV", ConnectionErrorTableResource.T_TANEV},
+                {"T_TANEV_OSSZES", ConnectionErrorTableResource.T_TANEV_OSSZES},
+                {"T_TANEVRENDJE", ConnectionErrorTableResource.T_TANEVRENDJE},
+                {"T_TANEVRENDJE_OSSZES", ConnectionErrorTableResource.T_TANEVRENDJE_OSSZES},
+                {"T_TANITASIORA", ConnectionErrorTableResource.T_TANITASIORA},
+                {"T_TANITASIORA_OSSZES", ConnectionErrorTableResource.T_TANITASIORA_OSSZES},
+                {"T_TANITASIORATULAJDONSAG", ConnectionErrorTableResource.T_TANITASIORATULAJDONSAG},
+                {"T_TANITASIORATULAJDONSAG_OSSZES", ConnectionErrorTableResource.T_TANITASIORATULAJDONSAG_OSSZES},
+                {"T_TANMENET", ConnectionErrorTableResource.T_TANMENET},
+                {"T_TANMENET_OSSZES", ConnectionErrorTableResource.T_TANMENET_OSSZES},
+                {"T_TANORA", ConnectionErrorTableResource.T_TANORA},
+                {"T_TANORA_OSSZES", ConnectionErrorTableResource.T_TANORA_OSSZES},
+                {"T_TANORAORATULAJDONSAG", ConnectionErrorTableResource.T_TANORAORATULAJDONSAG},
+                {"T_TANORAORATULAJDONSAG_OSSZES", ConnectionErrorTableResource.T_TANORAORATULAJDONSAG_OSSZES},
+                {"T_TANTARGY", ConnectionErrorTableResource.T_TANTARGY},
+                {"T_TANTARGY_OSSZES", ConnectionErrorTableResource.T_TANTARGY_OSSZES},
+                {"T_TANTARGYNEVHEZKATEGORIA", ConnectionErrorTableResource.T_TANTARGYNEVHEZKATEGORIA},
+                {"T_TANTARGYNEVHEZKATEGORIA_OSSZES", ConnectionErrorTableResource.T_TANTARGYNEVHEZKATEGORIA_OSSZES},
+                {"T_TANTERV", ConnectionErrorTableResource.T_TANTERV},
+                {"T_TANTERV_OSSZES", ConnectionErrorTableResource.T_TANTERV_OSSZES},
+                {"T_TANTERVIJELLEG", ConnectionErrorTableResource.T_TANTERVIJELLEG},
+                {"T_TANTERVIJELLEG_OSSZES", ConnectionErrorTableResource.T_TANTERVIJELLEG_OSSZES},
+                {"T_TANULO", ConnectionErrorTableResource.T_TANULO},
+                {"T_TANULO_OSSZES", ConnectionErrorTableResource.T_TANULO_OSSZES},
+                {"T_TANULOCSOPORT", ConnectionErrorTableResource.T_TANULOCSOPORT},
+                {"T_TANULOCSOPORT_OSSZES", ConnectionErrorTableResource.T_TANULOCSOPORT_OSSZES},
+                {"T_TANULOERTEKELES", ConnectionErrorTableResource.T_TANULOERTEKELES},
+                {"T_TANULOERTEKELES_OSSZES", ConnectionErrorTableResource.T_TANULOERTEKELES_OSSZES},
+                {"T_TANULOERTEKELESLATTAMOZAS", ConnectionErrorTableResource.T_TANULOERTEKELESLATTAMOZAS},
+                {"T_TANULOERTEKELESLATTAMOZAS_OSSZES", ConnectionErrorTableResource.T_TANULOERTEKELESLATTAMOZAS_OSSZES},
+                {"T_TANULOESEMENY", ConnectionErrorTableResource.T_TANULOESEMENY},
+                {"T_TANULOESEMENY_OSSZES", ConnectionErrorTableResource.T_TANULOESEMENY_OSSZES},
+                {"T_TANULOESEMENYLATTAMOZAS", ConnectionErrorTableResource.T_TANULOESEMENYLATTAMOZAS},
+                {"T_TANULOESEMENYLATTAMOZAS_OSSZES", ConnectionErrorTableResource.T_TANULOESEMENYLATTAMOZAS_OSSZES},
+                {"T_TANULOESLADATOK", ConnectionErrorTableResource.T_TANULOESLADATOK},
+                {"T_TANULOESLADATOK_OSSZES", ConnectionErrorTableResource.T_TANULOESLADATOK_OSSZES},
+                {"T_TANULOHAZIFELADAT", ConnectionErrorTableResource.T_TANULOHAZIFELADAT},
+                {"T_TANULOHAZIFELADAT_OSSZES", ConnectionErrorTableResource.T_TANULOHAZIFELADAT_OSSZES},
+                {"T_TANULOHAZIFELADATSTATUSZ", ConnectionErrorTableResource.T_TANULOHAZIFELADATSTATUSZ},
+                {"T_TANULOHAZIFELADATSTATUSZ_OSSZES", ConnectionErrorTableResource.T_TANULOHAZIFELADATSTATUSZ_OSSZES},
+                {"T_TANULOKOZOSSEGISZOLGALAT", ConnectionErrorTableResource.T_TANULOKOZOSSEGISZOLGALAT},
+                {"T_TANULOKOZOSSEGISZOLGALAT_OSSZES", ConnectionErrorTableResource.T_TANULOKOZOSSEGISZOLGALAT_OSSZES},
+                {"T_TANULOMENTESSEG", ConnectionErrorTableResource.T_TANULOMENTESSEG},
+                {"T_TANULOMENTESSEG_OSSZES", ConnectionErrorTableResource.T_TANULOMENTESSEG_OSSZES},
+                {"T_TANULOMULASZTAS", ConnectionErrorTableResource.T_TANULOMULASZTAS},
+                {"T_TANULOMULASZTAS_OSSZES", ConnectionErrorTableResource.T_TANULOMULASZTAS_OSSZES},
+                {"T_TANULOMULASZTASLATTAMOZAS", ConnectionErrorTableResource.T_TANULOMULASZTASLATTAMOZAS},
+                {"T_TANULOMULASZTASLATTAMOZAS_OSSZES", ConnectionErrorTableResource.T_TANULOMULASZTASLATTAMOZAS_OSSZES},
+                {"T_TANULOMULASZTASSTATISZTIKA", ConnectionErrorTableResource.T_TANULOMULASZTASSTATISZTIKA},
+                {"T_TANULOMULASZTASSTATISZTIKA_OSSZES", ConnectionErrorTableResource.T_TANULOMULASZTASSTATISZTIKA_OSSZES},
+                {"T_TANULOTANTARGYATLAG", ConnectionErrorTableResource.T_TANULOTANTARGYATLAG},
+                {"T_TANULOTANTARGYATLAG_OSSZES", ConnectionErrorTableResource.T_TANULOTANTARGYATLAG_OSSZES},
+                {"T_TANULOTANUGYIADATOK", ConnectionErrorTableResource.T_TANULO},
+                {"T_TANULOTANUGYIADATOK_OSSZES", ConnectionErrorTableResource.T_TANULO},
+                {"T_TANULOTARGYMULASZTASSTATISZT", ConnectionErrorTableResource.T_TANULOTARGYMULASZTASSTATISZT},
+                {"T_TANULOTARGYMULASZTASSTATISZT_OSSZES", ConnectionErrorTableResource.T_TANULOTARGYMULASZTASSTATISZT_OSSZES},
+                {"T_TANULO_TANULOESEMENY", ConnectionErrorTableResource.T_TANULO_TANULOESEMENY},
+                {"T_TARGYKATEGORIATIPUS", ConnectionErrorTableResource.T_TARGYKATEGORIATIPUS},
+                {"T_TARGYKATEGORIATIPUS_OSSZES", ConnectionErrorTableResource.T_TARGYKATEGORIATIPUS_OSSZES},
+                {"T_TARGYOSZTALYATLAG", ConnectionErrorTableResource.T_TARGYOSZTALYATLAG},
+                {"T_TARGYTANULOATLAG", ConnectionErrorTableResource.T_TARGYTANULOATLAG},
+                {"T_TBJOGVISZONY", ConnectionErrorTableResource.T_TBJOGVISZONY},
+                {"T_TBJOGVISZONY_OSSZES", ConnectionErrorTableResource.T_TBJOGVISZONY},
+                {"T_TELEFON", ConnectionErrorTableResource.T_TELEFON},
+                {"T_TELEFON_OSSZES", ConnectionErrorTableResource.T_TELEFON_OSSZES},
+                {"T_TELEFONTIPUS", ConnectionErrorTableResource.T_TELEFONTIPUS},
+                {"T_TELEFONTIPUS_OSSZES", ConnectionErrorTableResource.T_TELEFONTIPUS_OSSZES},
+                {"T_TELEPULES", ConnectionErrorTableResource.T_TELEPULES},
+                {"T_TELEPULES_OSSZES", ConnectionErrorTableResource.T_TELEPULES_OSSZES},
+                {"T_TEREM", ConnectionErrorTableResource.T_TEREM},
+                {"T_TEREM_OSSZES", ConnectionErrorTableResource.T_TEREM_OSSZES},
+                {"T_TEREMTIPUS", ConnectionErrorTableResource.T_TEREMTIPUS},
+                {"T_TEREMTIPUS_OSSZES", ConnectionErrorTableResource.T_TEREMTIPUS_OSSZES},
+                {"T_TESTNEVELESTIPUS", ConnectionErrorTableResource.T_TESTNEVELESTIPUS},
+                {"T_TESTNEVELESTIPUS_OSSZES", ConnectionErrorTableResource.T_TESTNEVELESTIPUS_OSSZES},
+                {"T_TEVEKENYSEG", ConnectionErrorTableResource.T_TEVEKENYSEG},
+                {"T_TEVEKENYSEG_OSSZES", ConnectionErrorTableResource.T_TEVEKENYSEG_OSSZES},
+                {"T_TEVEKENYSEGTIPUS", ConnectionErrorTableResource.T_TEVEKENYSEGTIPUS},
+                {"T_TEVEKENYSEGTIPUS_OSSZES", ConnectionErrorTableResource.T_TEVEKENYSEGTIPUS_OSSZES},
+                {"T_TOVABBIMUNKAUGYIADATOK", ConnectionErrorTableResource.T_TOVABBIMUNKAUGYIADATOK},
+                {"T_TOVABBIMUNKAUGYIADATOK_OSSZES", ConnectionErrorTableResource.T_TOVABBIMUNKAUGYIADATOK_OSSZES},
+                {"T_USERPROFILE", ConnectionErrorTableResource.T_USERPROFILE},
+                {"T_USERPROFILE_OSSZES", ConnectionErrorTableResource.T_USERPROFILE_OSSZES},
+                {"T_UZENETJOGKORTIPUS", ConnectionErrorTableResource.T_UZENETJOGKORTIPUS},
+                {"T_UZENETJOGKORTIPUS_OSSZES", ConnectionErrorTableResource.T_UZENETJOGKORTIPUS_OSSZES},
+                {"T_VALLAS", ConnectionErrorTableResource.T_VALLAS},
+                {"T_VALLAS_OSSZES", ConnectionErrorTableResource.T_VALLAS_OSSZES},
+                {"T_VEGZETTSEG", ConnectionErrorTableResource.T_VEGZETTSEG},
+                {"T_VEGZETTSEG_OSSZES", ConnectionErrorTableResource.T_VEGZETTSEG_OSSZES},
+                {"T_VEGZETTSEGTIPUS", ConnectionErrorTableResource.T_VEGZETTSEGTIPUS},
+                {"T_VEGZETTSEGTIPUS_OSSZES", ConnectionErrorTableResource.T_VEGZETTSEGTIPUS_OSSZES},
+                {"T_VEZETOIORASZAMOKTIPUS", ConnectionErrorTableResource.T_VEZETOIORASZAMOKTIPUS},
+                {"T_VEZETOIORASZAMOKTIPUS_OSSZES", ConnectionErrorTableResource.T_VEZETOIORASZAMOKTIPUS_OSSZES},
+                {"T_WIFIELERES", ConnectionErrorTableResource.T_WIFIELERES},
+                {"T_WIFIELERES_OSSZES", ConnectionErrorTableResource.T_WIFIELERES_OSSZES},
+                {"T_ZARADEK", ConnectionErrorTableResource.T_ZARADEK},
+                {"T_ZARADEK_OSSZES", ConnectionErrorTableResource.T_ZARADEK},
+                {"T_ZARADEKNYELV", ConnectionErrorTableResource.T_ZARADEK},
+                {"T_ZARADEKNYELV_OSSZES", ConnectionErrorTableResource.T_ZARADEK},
+            };
+
+        /// <summary>
+        /// Az osztály konstruktora. Lásd még <see cref="EntityUtil.GetAssociationDescription"/>.
+        /// </summary>
+        /// <param name="entityName">Az entitás neve</param>
+        /// <param name="associationName">Az asszociáció neve</param>
+        /// <param name="description">Az asszociáció leírása</param>
+        public EntityDeleteFailedException(string entityName, string associationName, string description)
+            : base(ErrorMessage)
+        {
+            SetValue("EntityName", entityName);
+            SetValue("AssociationName", associationName);
+            SetValue("Description", description);
+        }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="message">A kivétel üzenete</param>
+        public EntityDeleteFailedException(string message, List<EntityConnectionModel> connections)
+            : base(message)
+        {
+            if (connections != null)
+            {
+                _connectionErrorMessage = string.Join(", ",
+                    connections.GroupBy(c => c.TargetTableName, StringComparer.OrdinalIgnoreCase)
+                        .Select(c => string.Format("{0}: {1} db", s_connectionErrorTableList.TryGetValue(c.Key, out var tableName) ? tableName : c.Key, c.Max(a => a.RowsCount))));
+            }
+            else
+            {
+                _connectionErrorMessage = string.Empty;
+            }
+
+            SetValue("ConnectionErrorMessage", ConnectionErrorMessage);
+        }
+
+        private string _connectionErrorMessage;
+        public string ConnectionErrorMessage
+        {
+            get
+            {
+                return _connectionErrorMessage;
+            }
+        }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="info">Sorosítási adatok</param>
+        /// <param name="context">Sorosítási adatfolyam</param>
+        public EntityDeleteFailedException(SerializationInfo info, StreamingContext context) : base(info, context) { }
+    }
+}

Framework/Entities/EntityDictionaryItemPropertyAttribute.cs

@@ -0,0 +1,64 @@
+using System;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Entitás DictionaryItem tulajdonságait leíró attribútum.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Property, Inherited = true, AllowMultiple = true)]
+    public sealed class EntityDictionaryItemPropertyAttribute : Attribute
+    {
+        private string m_DictionaryItemFieldName;
+        private string m_DictionaryItemClassName;
+        private Type m_DictionaryItemClassType;
+
+        /// <summary>
+        /// Az attributum konstruktora
+        /// </summary>
+        /// <param name="dictionaryItemFieldName">A dictitem mező neve</param>
+        /// <param name="dictionaryItemClassName">A dictitem osztály neve</param>
+        /// <param name="dictionaryItemClassType">A dictitem osztály típusa</param>
+        public EntityDictionaryItemPropertyAttribute(string dictionaryItemFieldName, string dictionaryItemClassName, Type dictionaryItemClassType)
+        {
+            m_DictionaryItemClassName = dictionaryItemClassName;
+            m_DictionaryItemFieldName = dictionaryItemFieldName;
+            m_DictionaryItemClassType = dictionaryItemClassType;
+        }
+
+        /// <summary>
+        /// Az attributum konstruktora
+        /// </summary>
+        /// <param name="dictionaryItemFieldName">A dictitem mező neve</param>
+        /// <param name="dictionaryItemClassName">A dictitem osztály neve</param>
+        public EntityDictionaryItemPropertyAttribute(string dictionaryItemFieldName, string dictionaryItemClassName)
+        {
+            m_DictionaryItemClassName = dictionaryItemClassName;
+            m_DictionaryItemFieldName = dictionaryItemFieldName;
+            m_DictionaryItemClassType = null;
+        }
+
+        public string DictionaryItemFieldName
+        {
+            get
+            {
+                return m_DictionaryItemFieldName;
+            }
+        }
+
+        public string DictionaryItemClassName
+        {
+            get
+            {
+                return m_DictionaryItemClassName;
+            }
+        }
+
+        public Type DictionaryItemClassType
+        {
+            get
+            {
+                return m_DictionaryItemClassType;
+            }
+        }
+    }
+}

Framework/Entities/EntityException.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Runtime.Serialization;
+using Kreta.Framework.Localization;
+using Kreta.Framework.Logging;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Entitás kivételek absztrakt ősosztálya.
+    /// </summary>
+    [ErrorCode(Events.ENTITY_GENERAL)]
+    [FriendlyName(1000017, "Ismeretlen entitáshiba történt, kérjük értesítse az üzemeltetőt.\r\nHivatkozási hiba azonosító: {Id}")]
+    [Serializable]
+    public abstract class EntityException : FrameworkException
+    {
+        const string _errorMessage = "Unknown entity error occurred.";
+
+        /// <summary>
+        /// Az osztály alapértelmezett konstruktora.
+        /// </summary>
+        protected EntityException()
+            : base(_errorMessage) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="message">A kivétel üzenete</param>
+        protected EntityException(string message)
+            : base(message) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="message">A kivétel üzenete</param>
+        /// <param name="innerException">A belső kivétel</param>
+        protected EntityException(string message, Exception innerException)
+            : base(message, innerException) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="info">Sorosítási adatok</param>
+        /// <param name="context">Sorosítási adatfolyam</param>
+        protected EntityException(SerializationInfo info, StreamingContext context)
+            : base(info, context) { }
+    }
+}

Framework/Entities/EntityExpiredException.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Runtime.Serialization;
+using Kreta.Framework.Localization;
+using Kreta.Framework.Logging;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Hivatkozás lejárt entitás verziója.
+    /// </summary>
+    [FriendlyName(1000029, "Az entitás verziója eltér a megadottól.")]
+    [ErrorCode(Events.ENTITY_EXPIREDVERSION)]
+    [Serializable]
+    public sealed class EntityExpiredException : EntityException
+    {
+        const string _errorMessage = "The referred entity version is not up-to date.";
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="entityName">Az entitás neve</param>
+        /// <param name="entityId">Az entitás adatbázisbeli azonosítója</param>
+        /// <param name="entitySerial">Az entitás verziószáma</param>
+        public EntityExpiredException(string entityName, int entityId, int entitySerial)
+            : base(_errorMessage + " [EntityName: {EntityName}, EntityId: {EntityId}, EntitySerial: {EntitySerial}]")
+        {
+            SetValue("EntityName", entityName);
+            SetValue("EntityId", entityId);
+            SetValue("EntitySerial", entitySerial);
+        }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="entityName">Az entitás neve</param>
+        /// <param name="entityId">Az entitás adatbázisbeli azonosítója</param>
+        /// <param name="entitySerial">Az entitás verziószáma</param>
+        /// <param name="requestedSerial">Az entitás hivatkozott verziószáma</param>
+        public EntityExpiredException(string entityName, int entityId, int entitySerial, int requestedSerial)
+            : base(_errorMessage + " [EntityName: {EntityName}, EntityId: {EntityId}, EntitySerial: {EntitySerial}, RequestedSerial: {RequestedSerial}]")
+        {
+            SetValue("EntityName", entityName);
+            SetValue("EntityId", entityId);
+            SetValue("EntitySerial", entitySerial);
+            SetValue("RequestedSerial", requestedSerial);
+        }
+
+        /// <summary>
+        /// Az osztály alapértelmezett konstruktora.
+        /// </summary>        
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public EntityExpiredException() { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="message">A kivétel üzenete</param>
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public EntityExpiredException(string message)
+            : base(message) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="message">A kivétel üzenete</param>
+        /// <param name="innerException">A belső kivétel</param>
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public EntityExpiredException(string message, Exception innerException)
+            : base(message, innerException) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="info">Sorosítási adatok</param>
+        /// <param name="context">Sorosítási adatfolyam</param>
+        EntityExpiredException(SerializationInfo info, StreamingContext context)
+            : base(info, context) { }
+    }
+}

Framework/Entities/EntityHandler.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Collections;
+using System.Linq;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Az <see cref="IEntityHandler"/> megvalósítások ősosztálya.
+    /// </summary>
+    public class EntityHandler : IEntityHandler
+    {
+        private static Hashtable m_Handlers = new Hashtable();
+
+        /// <summary>
+        /// Létre van-e hozva az entitáshoz EntityHandler
+        /// </summary>
+        public bool IsCreated { get; set; }
+
+        /// <summary>
+        /// Létrehoz egy <see cref="IEntityHandler"/> objektumot a
+        /// megadott entitáshoz.
+        /// </summary>
+        /// <param name="entityName">Az entitás neve</param>
+        /// <returns>Az entitáshoz tartozó <see cref="IEntityHandler"/> objektum</returns>
+        public static IEntityHandler Create(Type entityType)
+        {
+            // <<Factory Method>>
+            Type handlertype = null;
+
+            while (handlertype == null && entityType != typeof(Entity))
+            {
+                var entityName = EntityAttributeCache.GetEntityNameFromCache(entityType);
+                if (string.IsNullOrWhiteSpace(entityName))
+                {
+                    throw new ArgumentNullException("entityName");
+                }
+
+                handlertype = m_Handlers[entityName.ToLower()] as Type;
+
+                entityType = entityType.BaseType;
+            }
+
+            bool isCreated = true;
+            if (handlertype == null)
+            {
+                isCreated = false;
+                handlertype = typeof(EntityHandler);
+            }
+
+            var entityHandler = (IEntityHandler)Activator.CreateInstance(handlertype, true);
+            entityHandler.IsCreated = isCreated;        // van-e lefejlesztve hozzá EntityHandler
+
+            return entityHandler;
+        }
+
+        /// <summary>
+        /// Inicializálja az entitás esemény kezelőket.
+        /// </summary>
+        internal static void Init()
+        {
+            Hashtable handlers = new Hashtable();
+            var handlertypes = from assembly in AppDomain.CurrentDomain.GetAssemblies()
+                               where SDAServer.Instance.IsAssemblyAllowed(assembly)
+                               from type in assembly.GetTypes()
+                               where (type.IsDefined(typeof(EntityHandlerAttribute), false)) && (typeof(IEntityHandler).IsAssignableFrom(type))
+                               select type;
+
+            foreach (var handlertype in handlertypes)
+            {
+                foreach (EntityHandlerAttribute attribute in handlertype.GetCustomAttributes(typeof(EntityHandlerAttribute), false))
+                {
+                    string name = attribute.EntityName.ToLower();
+                    if (!handlers.ContainsKey(name))
+                    {
+                        handlers[name] = handlertype;
+                    }
+                    else
+                    {
+                        throw new Kreta.Framework.DataIntegrityException("Egy entitáshoz több Handler-t találtam: " + attribute.EntityName);
+                    }
+                }
+            }
+            m_Handlers = handlers;
+        }
+
+        #region IEntityHandler
+
+        /// <summary>
+        /// Az entitás insert művelete előtt fut le. Ha a leszármazott nem írja felül, akkor nem csinál semmit.
+        /// </summary>
+        /// <param name="entity">Az entitás</param>
+        public virtual void BeforeInsert(Entity entity)
+        {
+        }
+
+        /// <summary>
+        /// Az entitás insert művelete után fut le. Ha a leszármazott nem írja felül, akkor nem csinál semmit.
+        /// </summary>
+        /// <param name="entity">Az entitás</param>
+        public virtual void AfterInsert(Entity entity)
+        {
+        }
+
+        /// <summary>
+        /// Az entitás update művelete előtt fut le. Ha a leszármazott nem írja felül, akkor nem csinál semmit.
+        /// </summary>
+        /// <param name="entity">Az entitás</param>
+        public virtual void BeforeUpdate(Entity entity)
+        {
+        }
+
+        /// <summary>
+        /// Az entitás update művelete után fut le. Ha a leszármazott nem írja felül, akkor nem csinál semmit.
+        /// </summary>
+        /// <param name="entity">Az entitás</param>
+        public virtual void AfterUpdate(Entity entity)
+        {
+        }
+
+        /// <summary>
+        /// Az entitás delete művelete előtt fut le. Ha a leszármazott nem írja felül, akkor nem csinál semmit.
+        /// </summary>
+        /// <param name="entity">Az entitás</param>
+        public virtual void BeforeDelete(Entity entity)
+        {
+        }
+
+        /// <summary>
+        /// Az entitás delete művelete után fut le. Ha a leszármazott nem írja felül, akkor nem csinál semmit.
+        /// </summary>
+        /// <param name="entity">Az entitás</param>
+        public virtual void AfterDelete(Entity entity)
+        {
+        }
+
+        #endregion
+    }
+}

Framework/Entities/EntityHandlerAttribute.cs

@@ -0,0 +1,37 @@
+using System;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Az attribútum egy adott entitáshoz tartozó esemény kezelő osztályt azonosít.
+    /// </summary>
+    /// <remarks>
+    /// Az attribútumot olyan osztályra kell tenni, amely megvalósítja az
+    /// <see cref="IEntityHandler"/> felületet.
+    /// </remarks>
+    [AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = true)]
+    public sealed class EntityHandlerAttribute : Attribute
+    {
+        private string m_EntityName;
+
+        /// <summary>
+        /// Az attribútum konstruktora.
+        /// </summary>
+        /// <param name="entityName">Az entitás neve, amihez a kezelő tartozik</param>
+        public EntityHandlerAttribute(string entityName)
+        {
+            m_EntityName = entityName;
+        }
+
+        /// <summary>
+        /// Az entitás neve, amihez a kezelő tartozik.
+        /// </summary>
+        public string EntityName
+        {
+            get
+            {
+                return m_EntityName;
+            }
+        }
+    }
+}

Framework/Entities/EntityNotFoundException.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Runtime.Serialization;
+using Kreta.Framework.Localization;
+using Kreta.Framework.Logging;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Nem létező entitásra történt hivatkozás.
+    /// </summary>
+    [FriendlyName(1000024, "A hivatkozott entitás nem található.")]
+    [ErrorCode(Events.ENTITY_NOTFOUND)]
+    [Serializable]
+    public sealed class EntityNotFoundException : EntityException
+    {
+        const string _errorMessage = "The entity does not exist.";
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="entityName">Az entitás neve</param>
+        /// <param name="entityId">Az entitás adatbázisbeli azonosítója</param>
+        public EntityNotFoundException(string entityName, int entityId)
+            : base(_errorMessage)
+        {
+            SetValue("EntityName", entityName);
+            SetValue("EntityId", entityId);
+        }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="entityName">Az entitás neve</param>
+        /// <param name="associationName">Az asszociáció neve</param>
+        /// <param name="partnerId">Az asszociációs partner azonosítója</param>
+        public EntityNotFoundException(string entityName, string associationName, int partnerId)
+            : base(_errorMessage)
+        {
+            SetValue("EntityName", entityName);
+            SetValue("AssociationName", associationName);
+            SetValue("PartnerId", partnerId);
+        }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="entityName">Az entitás neve</param>
+        /// <param name="entityId">Az entitás adatbázisbeli azonosítója</param>
+        /// <param name="entitySerial">Az entitás verziószáma</param>
+        public EntityNotFoundException(string entityName, int entityId, int entitySerial)
+            : base(_errorMessage)
+        {
+            SetValue("EntityName", entityName);
+            SetValue("EntityId", entityId);
+            SetValue("EntitySerial", entitySerial);
+        }
+
+        /// <summary>
+        /// Az osztály alapértelmezett konstruktora.
+        /// </summary>        
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public EntityNotFoundException() { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="message">A kivétel üzenete</param>
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public EntityNotFoundException(string message)
+            : base(message) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="message">A kivétel üzenete</param>
+        /// <param name="innerException">A belső kivétel</param>
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public EntityNotFoundException(string message, Exception innerException)
+            : base(message, innerException) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="info">Sorosítási adatok</param>
+        /// <param name="context">Sorosítási adatfolyam</param>
+        EntityNotFoundException(SerializationInfo info, StreamingContext context)
+            : base(info, context) { }
+    }
+}

Framework/Entities/EntityPropertyAttribute.cs

@@ -0,0 +1,154 @@
+using System;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Entitás tulajdonságait leíró attribútum.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Property, Inherited = true, AllowMultiple = true)]
+    public sealed class EntityPropertyAttribute : Attribute
+    {
+        private string m_Name;
+        private EntityPropertyBaseType m_BaseType;
+        private Type m_PropertyType;
+        private EntityCopyMethod m_CopyMethod;
+        private string m_AssocFieldName;
+        private string m_TableName;
+        private string m_PartnerAssocFieldName;
+
+        /// <summary>
+        /// Az osztály konstruktora
+        /// </summary>
+        /// <param name="name">A tulajdonság neve</param>
+        /// <param name="baseType">A tulajdonság alaptípusa</param>
+        /// <param name="propertyType">A tulajdonság .NET típusa</param>
+        /// <param name="copyMethod">A tulajdonság másolási módja</param>
+        public EntityPropertyAttribute(string name, EntityPropertyBaseType baseType, Type propertyType, EntityCopyMethod copyMethod)
+        {
+            m_Name = name;
+            m_BaseType = baseType;
+            m_PropertyType = propertyType;
+            m_CopyMethod = copyMethod;
+        }
+
+        /// <summary>
+        /// Az osztály konstruktora
+        /// </summary>
+        /// <param name="name">A tulajdonság neve</param>
+        /// <param name="baseType">A tulajdonság alaptípusa</param>
+        /// <param name="propertyType">A tulajdonság .NET típusa</param>
+        /// <param name="copyMethod">A tulajdonság másolási módja</param>
+        /// <param name="assocfieldname">A tulajdonság asszociációs osztályának kapcsoló ID mezője.</param>
+        public EntityPropertyAttribute(string name, EntityPropertyBaseType baseType, Type propertyType, EntityCopyMethod copyMethod, string assocfieldname)
+        {
+            m_Name = name;
+            m_BaseType = baseType;
+            m_PropertyType = propertyType;
+            m_CopyMethod = copyMethod;
+            m_AssocFieldName = assocfieldname;
+        }
+
+        /// <summary>
+        /// Az osztály konstruktora
+        /// </summary>
+        /// <param name="name">A tulajdonság neve</param>
+        /// <param name="baseType">A tulajdonság alaptípusa</param>
+        /// <param name="propertyType">A tulajdonság .NET típusa</param>
+        /// <param name="copyMethod">A tulajdonság másolási módja</param>
+        /// <param name="assocfieldname">A tulajdonság asszociációs osztályának kapcsoló ID mezője.</param>
+        public EntityPropertyAttribute(string name, EntityPropertyBaseType baseType, Type propertyType, EntityCopyMethod copyMethod, string assocfieldname, string partnerassocfieldname, string tablename)
+        {
+            m_Name = name;
+            m_BaseType = baseType;
+            m_PropertyType = propertyType;
+            m_CopyMethod = copyMethod;
+            m_AssocFieldName = assocfieldname;
+            m_PartnerAssocFieldName = partnerassocfieldname;
+            m_TableName = tablename;
+        }
+
+        /// <summary>
+        /// A tulajdonság neve.
+        /// </summary>
+        public string Name
+        {
+            get
+            {
+                return m_Name;
+            }
+        }
+
+        public string AssocFieldName
+        {
+            get
+            {
+                return m_AssocFieldName;
+            }
+        }
+
+        public string PartnerAssocFieldName
+        {
+            get
+            {
+                return m_PartnerAssocFieldName;
+            }
+        }
+
+        public string TableName
+        {
+            get
+            {
+                return m_TableName;
+            }
+        }
+
+        /// <summary>
+        /// A tulajdonság fajtája.
+        /// </summary>
+        public EntityPropertyBaseType BaseType
+        {
+            get
+            {
+                return m_BaseType;
+            }
+        }
+
+        /// <summary>
+        /// A tulajdonság típusa.
+        /// </summary>
+        public Type PropertyType
+        {
+            get
+            {
+                return m_PropertyType;
+            }
+        }
+
+        /// <summary>
+        /// A tulajdonság másolási módja.
+        /// </summary>
+        /// <remarks>
+        /// Entitás másolásánál használatos, és megmondja, hogy a másolat entitásnál
+        /// a tulajdonságot milyen módon kell másolni. Asszociációknál van értelmezve.
+        /// <list type="bullet">
+        /// <item>
+        /// <term>DeepCopy</term>
+        /// <description>Az asszociációs partnert is le kell másolni.</description>
+        /// </item>
+        /// <item>
+        /// <term>ShallowCopy</term>
+        /// <description>Az asszociációs partnert nem kell másolni, a másolat identitása megegyezhet
+        /// az eredetivel.
+        /// </description>
+        /// </item>
+        /// </list>
+        /// </remarks>
+        public EntityCopyMethod CopyMethod
+        {
+            get
+            {
+                return m_CopyMethod;
+            }
+        }
+    }
+}

Framework/Entities/EntityPropertyBaseType.cs

@@ -0,0 +1,23 @@
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Entitás tulajdonság alap típusa.
+    /// </summary>
+    public enum EntityPropertyBaseType
+    {
+        /// <summary>
+        /// Entitás
+        /// </summary>
+        Entity = 0,
+
+        /// <summary>
+        /// Entitás lista
+        /// </summary>
+        EntityCollection = 1,
+
+        /// <summary>
+        /// Érték típus
+        /// </summary>
+        ValueType = 2,
+    }
+}

Framework/Entities/EntityReadOnlyException.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Runtime.Serialization;
+using Kreta.Framework.Localization;
+using Kreta.Framework.Logging;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Hivatkozás lejárt entitás verziója.
+    /// </summary>
+    [FriendlyName(1000076, "Az adott rekordra nincs írási joga! ({EntityName}: {EntityId})")]
+    [ErrorCode(Events.ENTITY_READONLY)]
+    [Serializable]
+    public sealed class EntityReadOnlyException : EntityException
+    {
+        const string _errorMessage = "Az adott rekordra nincs írási joga! ({EntityName}: {EntityId})";
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="entityName">Az entitás neve</param>
+        /// <param name="entityId">Az entitás adatbázisbeli azonosítója</param>
+        public EntityReadOnlyException(string entityName, int entityId)
+            : base(_errorMessage)
+        {
+            SetValue("EntityName", entityName);
+            SetValue("EntityId", entityId);
+        }
+
+        /// <summary>
+        /// Az osztály alapértelmezett konstruktora.
+        /// </summary>        
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public EntityReadOnlyException() { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="message">A kivétel üzenete</param>
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public EntityReadOnlyException(string message)
+            : base(message) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="message">A kivétel üzenete</param>
+        /// <param name="innerException">A belső kivétel</param>
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public EntityReadOnlyException(string message, Exception innerException)
+            : base(message, innerException) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="info">Sorosítási adatok</param>
+        /// <param name="context">Sorosítási adatfolyam</param>
+        EntityReadOnlyException(SerializationInfo info, StreamingContext context)
+            : base(info, context) { }
+    }
+}

Framework/Entities/EntityState.cs

@@ -0,0 +1,33 @@
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Entitások lehetséges állapotai
+    /// </summary>
+    public enum EntityState
+    {
+        /// <summary>
+        /// Az entitás inicializálatlan
+        /// </summary>
+        Uninitialized = 0,
+
+        /// <summary>
+        /// Az entitás új, és még nincs mentve
+        /// </summary>
+        New = 1,
+
+        /// <summary>
+        /// Az entitás attribútumai inicializáltak
+        /// </summary>
+        Initialized = 2,
+
+        /// <summary>
+        /// Az entitás attribútumai módosultak
+        /// </summary>
+        Modified = 3,
+
+        /// <summary>
+        /// Az entitás törölt, műveletvégzés nem lehetséges rajta
+        /// </summary>
+        Removed = 4,
+    }
+}

Framework/Entities/EntityStateException.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Runtime.Serialization;
+using Kreta.Framework.Localization;
+using Kreta.Framework.Logging;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Érvénytelen entitás művelet.
+    /// </summary>
+    [FriendlyName(1000011, "Súlyos üzleti logikai hiba, kérjük értesítse az üzemeltetőt.\r\nHivatkozási hiba azonosító: {Id}")]
+    [ErrorCode(Events.ENTITY_INVALIDSTATE)]
+    [Serializable]
+    public sealed class EntityStateException : EntityException
+    {
+        const string _errorMessage = "The operation cannot be completed according to state of the entity.";
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="currentState">Az entitás jelenlegi állapota.</param>
+        public EntityStateException(EntityState currentState)
+            : base(_errorMessage)
+        {
+            this.SetValue("CurrentState", currentState);
+        }
+
+        /// <summary>
+        /// Az osztály alapértelmezett konstruktora.
+        /// </summary>        
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public EntityStateException() { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="message">A kivétel üzenete</param>
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public EntityStateException(string message)
+            : base(message) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="message">A kivétel üzenete</param>
+        /// <param name="innerException">A belső kivétel</param>
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public EntityStateException(string message, Exception innerException)
+            : base(message, innerException) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="info">Sorosítási adatok</param>
+        /// <param name="context">Sorosítási adatfolyam</param>
+        EntityStateException(SerializationInfo info, StreamingContext context)
+            : base(info, context) { }
+    }
+}

Framework/Entities/EntityUtil.cs

@@ -0,0 +1,177 @@
+using System;
+using System.Text.RegularExpressions;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Segédosztály entitás funkcionalitások részére.
+    /// </summary>
+    public static class EntityUtil
+    {
+        // <<Facade>>
+
+        /// <summary>
+        /// A jelenlegi nyelv indexe, kizárólag a generált kód használja, kézi kód számára tabu.
+        /// </summary>
+        public static int CurrentLanguageIndex
+        {
+            get
+            {
+                return LanguageContext.Current.LanguageIndex;
+            }
+        }
+
+        /// <summary>
+        /// Visszaadja egy asszociáció leírását, ha az definiált.
+        /// </summary>
+        /// <param name="sourceTable">A forrás tábla neve</param>
+        /// <param name="sourceColumn">Az asszociáció kapcsolómezőjének neve</param>
+        /// <returns>Az asszociáció leírása, ha az létezik; egyébként 'N/A'.</returns>
+        public static string GetAssociationDescription(string sourceTable, string sourceColumn)
+        {
+            if (string.IsNullOrWhiteSpace(sourceTable) || string.IsNullOrWhiteSpace(sourceColumn))
+            {
+                return "N/A";
+            }
+
+            try
+            {
+                using (SDA.DataProvider.SDACommand command = new SDA.DataProvider.SDACommand())
+                {
+                    command.Connection = UserContext.Instance.SDAConnection;
+                    command.Transaction = UserContext.Instance.SDATransaction;
+                    command.CommandText = @"
+select distinct
+    T_DSTRANSLATION.C_DISPLAYTEXT
+from
+  T_FDLPALETTELINK
+  left join T_DSTRANSLATION on T_DSTRANSLATION.C_FDLPALETTELINKID = T_FDLPALETTELINK.ID
+where
+  lower(T_FDLPALETTELINK.C_DBKEYTABLEOFSOURCE) = :pTABLE
+  and
+  lower(T_FDLPALETTELINK.C_DBKEYFIELDOFSOURCE) = :pCOLUMN
+";
+                    command.Parameters.Add("pTABLE", sourceTable.ToLower());
+                    command.Parameters.Add("pCOLUMN", sourceColumn.ToLower());
+                    object result = command.ExecuteScalar();
+                    if (result != null && !(result is DBNull))
+                    {
+                        return result.ToString().Replace("\u0001", "\n");
+                    }
+
+                    return "N/A";
+                }
+            }
+            catch (Exception exception)
+            {
+                SDAServer.Instance.Logger.ExceptionThrown(exception);
+                return "N/A";
+            }
+        }
+
+        /// <summary>
+        /// Reguláris kifejezéseket elemző függvény. A generált kód használja, kézi kód számára tabu.
+        /// </summary>
+        /// <param name="data">Ezt a karakterláncot elemezzük, hogy megfelel-e a kifejezésünknek</param>
+        /// <param name="regexPattern">Ezt a mintát keressuk a karakterláncban</param>
+        /// <returns>True, ha illeszkedik; egyébként false</returns>
+        public static bool VerifyRegEx(char data, string regexPattern)
+        {
+            return VerifyRegEx(data.ToString(), regexPattern);
+        }
+
+        /// <summary>
+        /// Reguláris kifejezéseket elemző függvény. A generált kód használja, kézi kód számára tabu.
+        /// </summary>
+        /// <param name="data">Ezt a karakterláncot elemezzük, hogy megfelel-e a kifejezésünknek</param>
+        /// <param name="regexPattern">Ezt a mintát keressuk a karakterláncban</param>
+        /// <returns>True, ha illeszkedik; egyébként false</returns>
+        public static bool VerifyRegEx(string data, string regexPattern)
+        {
+            if (data == null)
+            {
+                return false;
+            }
+
+            RegexOptions options = RegexOptions.Singleline;
+            MatchCollection matches = Regex.Matches(data, regexPattern, options);
+
+            foreach (Match match in matches)
+            {
+                if (match.Success && match.Index == 0 && match.Length == data.Length)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        #region CRUD Logika weben
+
+        /// <summary>
+        /// Azonosító alapján feltölti az entitást adatbázisból.
+        /// </summary>
+        /// <param name="entity">A betöltendő entitás</param>
+        /// <param name="sessionId">A munkamenet azonosítója</param>
+        /// <param name="id">Az entitás azonosítója</param>
+        /// <param name="serial">Az entitás verziószáma</param>
+        public static void LoadById(Entity entity, string sessionId, int id, int serial)
+        {
+            if (UserContext.Instance == null)
+            {
+                try
+                {
+                    SDAServer.Instance.SessionManager.ActivateSession(sessionId);
+                    entity.LoadByID(id, serial);
+                }
+                catch (Exception exception)
+                {
+                    SDAServer.Instance.Logger.ExceptionThrown(exception);
+                    throw;
+                }
+                finally
+                {
+                    SDAServer.Instance.SessionManager.DeActivateSession(sessionId);
+                }
+            }
+            else
+            {
+                entity.LoadByID(id, serial);
+            }
+        }
+
+        /// <summary>
+        /// Azonosító alapján feltölti az entitást adatbázisból.
+        /// </summary>
+        /// <param name="entity">A betöltendő entitás</param>
+        /// <param name="sessionId">A munkamenet azonosítója</param>
+        /// <param name="id">Az entitás azonosítója</param>
+        public static void LoadById(Entity entity, string sessionId, int id)
+        {
+            if (UserContext.Instance == null)
+            {
+                try
+                {
+                    SDAServer.Instance.SessionManager.ActivateSession(sessionId);
+                    entity.LoadByID(id);
+                }
+                catch (Exception exception)
+                {
+                    SDAServer.Instance.Logger.ExceptionThrown(exception);
+                    throw;
+                }
+                finally
+                {
+                    SDAServer.Instance.SessionManager.DeActivateSession(sessionId);
+                }
+            }
+            else
+            {
+                entity.LoadByID(id);
+            }
+        }
+
+        #endregion
+    }
+}

Framework/Entities/Generic/EntityDBHelper.cs

@@ -0,0 +1,215 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Kreta.Framework.Collections.Generic;
+
+namespace Kreta.Framework.Entities.Generic
+{
+    public abstract class EntityDBHelper<EntityType> : IEntityDBHelper<EntityType> //, IEntityDBHelper
+        where EntityType : Kreta.Framework.Entities.Entity
+    {
+        protected abstract EntityType CreateEntityInstance();
+
+        #region IEntityDBHelper<EntityType> Members
+
+        public abstract string EmptyQueryCommandText
+        {
+            get;
+        }
+
+        public abstract string DynamicQueryCommandText
+        {
+            get;
+        }
+
+        public abstract IDictionary<string, string> DynamicColumns
+        {
+            get;
+        }
+
+        public SDA.DataProvider.SDACommand CreateEmptyQueryCommand()
+        {
+            return DAUtil.CreateCommand(EmptyQueryCommandText);
+        }
+
+        public SDA.DataProvider.SDACommand CreateDynamicQueryCommand(ColumnFilterMode columnFilterMode, IEnumerable<string> columns)
+        {
+            if (columns == null)
+            {
+                columns = new List<string>();
+            }
+
+            var columnText = "";
+            foreach (var column in DynamicColumns.Where(dc => (columnFilterMode == ColumnFilterMode.DEFAULT_ALLOWED) ^ (columns.Contains(dc.Key))))
+            {
+                columnText += column.Value + ",";
+            }
+
+            var queryCommandText = DynamicQueryCommandText.Replace("{COLUMNS}", columnText);
+            return DAUtil.CreateCommand(queryCommandText);
+        }
+
+        public abstract void LoadEntityFields(EntityType entity, SDA.DataProvider.SDADataReader reader, ColumnFilterMode columnFilterMode, IEnumerable<string> columns);
+        public abstract void LoadEntityFields(EntityType entity, SDA.DataProvider.SDADataReader reader);
+
+        public void LoadFromReader(EntityType entity, SDA.DataProvider.SDADataReader reader)
+        {
+            entity.ID = ((int)reader.GetDecimal(0));
+
+            LoadEntityFields(entity, reader);
+
+            int index = reader.FieldCount - 6;
+            entity.Torolt = reader[index] != DBNull.Value && reader.GetBoolean(index);
+            index++;
+            entity.Serial = ((int)reader.GetDecimal(index++));
+            entity.EntityCreated = DAUtil.ReadDateTime(reader, index++);
+            entity.EntityCreator = reader[index] != DBNull.Value ? reader.GetInt32(index) : 0;
+            index++;
+            entity.EntityLastChanged = DAUtil.ReadDateTime(reader, index++);
+            entity.EntityModifier = reader[index] != DBNull.Value ? reader.GetInt32(index) : new int?();
+
+            entity.SetLoaded();
+        }
+
+        public void LoadFromReader(EntityType entity, SDA.DataProvider.SDADataReader reader, ColumnFilterMode columnFilterMode, IEnumerable<string> columns)
+        {
+            entity.ID = ((int)reader.GetDecimal(0));
+
+            LoadEntityFields(entity, reader, columnFilterMode, columns);
+
+            int index = reader.FieldCount - 6;
+            entity.Torolt = reader[index] != DBNull.Value && reader.GetBoolean(index);
+            index++;
+            entity.Serial = ((int)reader.GetDecimal(index++));
+            entity.EntityCreated = DAUtil.ReadDateTime(reader, index++);
+            entity.EntityCreator = reader[index] != DBNull.Value ? reader.GetInt32(index) : 0;
+            index++;
+            entity.EntityLastChanged = DAUtil.ReadDateTime(reader, index++);
+            entity.EntityModifier = reader[index] != DBNull.Value ? reader.GetInt32(index++) : new int?();
+            entity.SetLoaded();
+        }
+
+        public bool LoadEntityCollection(IEntityCollection<EntityType> collection, SDA.DataProvider.SDACommand command)
+        {
+            using (SDA.DataProvider.SDADataReader reader = command.ExecuteReader())
+            {
+                while (reader.Read())
+                {
+                    EntityType entity = CreateEntityInstance();
+                    LoadFromReader(entity, reader);
+                    ((EntityCollection<EntityType>)collection).InternalAdd(entity);
+                }
+                return true;
+            }
+        }
+
+        public bool LoadEntityCollection(IEntityCollection<EntityType> collection, SDA.DataProvider.SDACommand command, ColumnFilterMode columnFilterMode, IEnumerable<string> columns)
+        {
+            using (SDA.DataProvider.SDADataReader reader = command.ExecuteReader())
+            {
+                while (reader.Read())
+                {
+                    EntityType entity = CreateEntityInstance();
+                    LoadFromReader(entity, reader, columnFilterMode, columns);
+                    ((EntityCollection<EntityType>)collection).InternalAdd(entity);
+                }
+                return true;
+            }
+        }
+
+        public bool LoadSingleEntity(EntityType entity, SDA.DataProvider.SDACommand command)
+        {
+            using (SDA.DataProvider.SDADataReader reader = command.ExecuteReader())
+            {
+                if (reader.Read())
+                {
+                    LoadFromReader(entity, reader);
+
+                    if (reader.Read())
+                    {
+                        throw new Kreta.Framework.DataIntegrityException("Egyediség megsértése: " + entity.GetEntityName());
+                    }
+                    return true;
+                }
+
+                return false;
+            }
+        }
+
+        public bool LoadSingleEntity(EntityType entity, SDA.DataProvider.SDACommand command, ColumnFilterMode columnFilterMode, IEnumerable<string> columns)
+        {
+            using (SDA.DataProvider.SDADataReader reader = command.ExecuteReader())
+            {
+                if (reader.Read())
+                {
+                    LoadFromReader(entity, reader, columnFilterMode, columns);
+
+                    if (reader.Read())
+                    {
+                        throw new Kreta.Framework.DataIntegrityException("Egyediség megsértése: " + entity.GetEntityName());
+                    }
+                    return true;
+                }
+
+                return false;
+            }
+        }
+
+        public bool LoadByPartnerId(EntityType entity, string filterText, int partnerId)
+        {
+            using (SDA.DataProvider.SDACommand command = CreateEmptyQueryCommand())
+            {
+                command.CommandText += filterText;
+                command.Parameters.Add("pID", SDA.DataProvider.SDADBType.Int).Value = partnerId;
+                return LoadSingleEntity(entity, command, ColumnFilterMode.DEFAULT_ALLOWED, null);
+            }
+        }
+
+        public bool LoadByPartnerId(IEntityCollection<EntityType> collection, string filterText, int partnerId)
+        {
+            using (SDA.DataProvider.SDACommand command = CreateEmptyQueryCommand())
+            {
+                command.CommandText += filterText;
+                command.Parameters.Add("pID", SDA.DataProvider.SDADBType.Int).Value = partnerId;
+                return LoadEntityCollection(collection, command, ColumnFilterMode.DEFAULT_ALLOWED, null);
+            }
+        }
+
+        public abstract void BindAttributes(EntityType entity, SDA.DataProvider.SDACommand command);
+
+        public abstract void BindAssociations(EntityType entity, SDA.DataProvider.SDACommand command);
+
+        public abstract void DynamicBindAttributes(EntityType entity, SDA.DataProvider.SDACommand command);
+
+        public void CreateParameterBinding(SDA.DataProvider.SDACommand command, Dictionary<string, object> commandParameters)
+        {
+            if (commandParameters != null)
+            {
+                foreach (KeyValuePair<string, object> kvp in commandParameters)
+                {
+                    // mssql nem szereti parameter nevben a ":"-ot
+                    string pName = kvp.Key;
+                    if (pName.StartsWith(":"))
+                    {
+                        pName = pName.TrimStart(new char[] { ':' });
+                    }
+
+                    if (kvp.Value.GetType() == typeof(int))
+                    {
+                        command.Parameters.Add(pName, SDA.DataProvider.SDADBType.Int).Value = Convert.ToInt32(kvp.Value);
+                    }
+                    if (kvp.Value.GetType() == typeof(string))
+                    {
+                        command.Parameters.Add(pName, SDA.DataProvider.SDADBType.String).Value = Convert.ToString(kvp.Value);
+                    }
+                    if (kvp.Value.GetType() == typeof(DateTime))
+                    {
+                        command.Parameters.Add(pName, SDA.DataProvider.SDADBType.DateTime).Value = Convert.ToDateTime(kvp.Value, LanguageContext.Current.RegionSettings);
+                    }
+                }
+            }
+        }
+
+        #endregion
+    }
+}

Framework/Entities/Generic/EntityDataAccessor.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using Kreta.Framework.Collections;
+using Kreta.Framework.Collections.Generic;
+
+namespace Kreta.Framework.Entities.Generic
+{
+    /// <summary>
+    /// Entitások adatbázisműveleteit végző objektumának őse
+    /// </summary>
+    public abstract class EntityDataAccessor<EntityType> : IEntityDataAccessor<EntityType>, IEntityDataAccessor
+        where EntityType : Kreta.Framework.Entities.Entity
+    {
+
+        protected abstract IEntityDBHelper<EntityType> dbhelper
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Beállítja a létrehozóját egy entitásnak
+        /// </summary>
+        /// <param name="entity">A beállítandó entitás</param>
+        protected void SetEntityCreator(EntityType entity, DateTime timestamp, int uniqueidentifier)
+        {
+            entity.EntityCreated = timestamp;
+            entity.EntityCreator = uniqueidentifier;
+            //entity.EntitySubsCreator = UserContext.Instance.SubstituteEmployeePrintName;
+        }
+
+        /// <summary>
+        /// Beállítja a módosítóját egy entitásnak
+        /// </summary>
+        /// <param name="entity">A beállítandó entitás</param>
+        protected void SetEntityModifier(EntityType entity, DateTime timestamp, int uniqueidentifier)
+        {
+            entity.EntityLastChanged = timestamp;
+            entity.EntityModifier = uniqueidentifier;
+            //entity.EntitySubsLastModifier = UserContext.Instance.SubstituteEmployeePrintName;
+        }
+
+        #region ISDAEntityDataAccessor<EntityType> Members
+
+        public abstract bool LoadEntity(EntityType entity, int entityId);
+
+        public virtual bool FilteredLoadEntity(EntityType entity, int entityId, ColumnFilterMode columnFilterMode, IEnumerable<string> columns)
+        {
+            return LoadEntity(entity, entityId);
+        }
+
+        public abstract void LoadWithFilter(IEntityCollection<EntityType> collection, string filter, Dictionary<string, object> commandParameters);
+
+        public virtual void LoadWithFilter(IEntityCollection<EntityType> collection, string filter, ColumnFilterMode columnFilterMode, IEnumerable<string> columns, Dictionary<string, object> commandParameters)
+        {
+            LoadWithFilter(collection, filter, commandParameters);
+        }
+
+        public abstract void InsertEntity(EntityType entity);
+
+        public abstract bool UpdateEntity(EntityType entity);
+
+        public abstract bool UpdateAssociations(EntityType entity);
+
+        public abstract void DeleteEntity(EntityType entity, bool logikai = true);
+
+        #endregion
+
+        #region IEntityDataAccessor Members
+
+        bool IEntityDataAccessor.LoadEntity(Entity entity, int entityId)
+        {
+            return LoadEntity((EntityType)entity, entityId);
+        }
+
+        bool IEntityDataAccessor.FilteredLoadEntity(Entity entity, int entityId, ColumnFilterMode columnFilterMode, IEnumerable<string> columns)
+        {
+            return FilteredLoadEntity((EntityType)entity, entityId, columnFilterMode, columns);
+        }
+
+        void IEntityDataAccessor.LoadWithFilter(IEntityCollection collection, string filter, Dictionary<string, object> commandParameters)
+        {
+            LoadWithFilter((IEntityCollection<EntityType>)collection, filter, commandParameters);
+        }
+
+        void IEntityDataAccessor.InsertEntity(Entity entity)
+        {
+            InsertEntity((EntityType)entity);
+        }
+
+        bool IEntityDataAccessor.UpdateEntity(Entity entity)
+        {
+            return UpdateEntity((EntityType)entity);
+        }
+
+        bool IEntityDataAccessor.UpdateAssociations(Entity entity)
+        {
+            return UpdateAssociations((EntityType)entity);
+        }
+
+        void IEntityDataAccessor.DeleteEntity(Entity entity, bool logikai)
+        {
+            DeleteEntity((EntityType)entity, logikai);
+        }
+
+        #endregion
+    }
+}

Framework/Entities/Generic/IEntityDBHelper.cs

@@ -0,0 +1,39 @@
+using System.Collections.Generic;
+using Kreta.Framework.Collections.Generic;
+
+namespace Kreta.Framework.Entities.Generic
+{
+    public interface IEntityDBHelper<EntityType>
+        where EntityType : Kreta.Framework.Entities.Entity
+    {
+        string EmptyQueryCommandText { get; }
+
+        SDA.DataProvider.SDACommand CreateEmptyQueryCommand();
+
+        SDA.DataProvider.SDACommand CreateDynamicQueryCommand(ColumnFilterMode columnFilterMode, IEnumerable<string> columns);
+
+        void LoadEntityFields(EntityType entity, SDA.DataProvider.SDADataReader reader, ColumnFilterMode columnFilterMode, IEnumerable<string> columns);
+
+        void LoadFromReader(EntityType entity, SDA.DataProvider.SDADataReader reader, ColumnFilterMode columnFilterMode, IEnumerable<string> columns);
+
+        bool LoadEntityCollection(IEntityCollection<EntityType> collection, SDA.DataProvider.SDACommand command);
+
+        bool LoadEntityCollection(IEntityCollection<EntityType> collection, SDA.DataProvider.SDACommand command, ColumnFilterMode columnFilterMode, IEnumerable<string> columns);
+
+        bool LoadSingleEntity(EntityType entity, SDA.DataProvider.SDACommand command);
+
+        bool LoadSingleEntity(EntityType entity, SDA.DataProvider.SDACommand command, ColumnFilterMode columnFilterMode, IEnumerable<string> columns);
+
+        bool LoadByPartnerId(EntityType entity, string filterText, int partnerId);
+
+        bool LoadByPartnerId(IEntityCollection<EntityType> collection, string filterText, int partnerId);
+
+        void BindAttributes(EntityType entity, SDA.DataProvider.SDACommand command);
+
+        void DynamicBindAttributes(EntityType entity, SDA.DataProvider.SDACommand command);
+
+        void BindAssociations(EntityType entity, SDA.DataProvider.SDACommand command);
+
+        void CreateParameterBinding(SDA.DataProvider.SDACommand command, Dictionary<string, object> commandParameters);
+    }
+}

Framework/Entities/Generic/IEntityDataAccessor.cs

@@ -0,0 +1,75 @@
+using System.Collections.Generic;
+using Kreta.Framework.Collections.Generic;
+
+namespace Kreta.Framework.Entities.Generic
+{
+    /// <summary>
+    /// Entitások adatbázisműveleteit végző objektumának felülete.
+    /// </summary>
+    public interface IEntityDataAccessor<EntityType>
+        where EntityType : Kreta.Framework.Entities.Entity
+    {
+        /// <summary>
+        /// Betölti egy entitás állapotát az adatbázisból.
+        /// </summary>
+        /// <param name="entity">A betöltendő entitás</param>
+        /// <param name="entityId">Az entitás adatbázisbeli azonosítója</param>
+        /// <returns>True, ha sikeres; egyébként false</returns>
+        bool LoadEntity(EntityType entity, int entityId);
+
+        /// <summary>
+        /// Oszlopszűrten beltölti egy entitás állapotát az adatbázisból
+        /// </summary>
+        /// <param name="entity">A betöltendő entitás</param>
+        /// <param name="entityId">Az entitás adatbázisbeli azonosítója</param>
+        /// <param name="columnFilterMode">A szűrés módja, megengedő vagy tiltó</param>
+        /// <param name="columns">A szűrendő oszlopok felsorolása</param>
+        /// <returns>True, ha sikeres; egyébként False</returns>
+        bool FilteredLoadEntity(EntityType entity, int entityId, ColumnFilterMode columnFilterMode, IEnumerable<string> columns);
+
+        /// <summary>
+        /// Betölt egy entitás listát a megadott szűrő feltétellel.
+        /// </summary>
+        /// <param name="collection">A feltöltendő lista</param>
+        /// <param name="filter">A szűrő SQL töredék</param>
+        /// <param name="commandParameters">a szűrőben megadott paraméterek commandBinding atalakitasa</param>
+        void LoadWithFilter(IEntityCollection<EntityType> collection, string filter, Dictionary<string, object> commandParameters);
+
+        /// <summary>
+        /// Oszlopszűrten betölt egy entitás listát a megadott szűrő feltétellel.
+        /// </summary>
+        /// <param name="collection">A feltöltendő lista</param>
+        /// <param name="filter">A szűrő SQL töredék</param>
+        /// <param name="columnFilterMode">A szűrés módja, megengedő vagy tiltó</param>
+        /// <param name="columns">A szűrendő oszlopok felsorolása</param>
+        /// <param name="commandParameters">a szűrőben megadott paraméterek commandBinding atalakitasa</param>
+        void LoadWithFilter(IEntityCollection<EntityType> collection, string filter, ColumnFilterMode columnFilterMode, IEnumerable<string> columns, Dictionary<string, object> commandParameters);
+
+        /// <summary>
+        /// Létrehoz egy új entitás példányt az adatbázisban.
+        /// </summary>
+        /// <param name="entity">A létrehozandó entitás</param>
+        void InsertEntity(EntityType entity);
+
+        /// <summary>
+        /// Módosít egy entitás példányt az adatbázisban.
+        /// </summary>
+        /// <param name="entity">A módosítandó entitás</param>
+        /// <returns>True, ha sikeres; egyébként false</returns>
+        bool UpdateEntity(EntityType entity);
+
+        /// <summary>
+        /// Módosítja egy entitás példány asszociációs kapcsolómezőit az adatbázisban.
+        /// </summary>
+        /// <param name="entity">A módosítandó entitás</param>
+        /// <returns>True, ha sikeres; egyébként false</returns>
+        bool UpdateAssociations(EntityType entity);
+
+        /// <summary>
+        /// Töröl egy entitás példányt az adatbázisból.
+        /// </summary>
+        /// <param name="entity">A törlendő entitás</param>
+        /// <param name="logikai">Logikai törlés (Archiv flag)</param>
+        void DeleteEntity(EntityType entity, bool logikai = true);
+    }
+}

Framework/Entities/IEntityDataAccessor.cs

@@ -0,0 +1,62 @@
+using System.Collections.Generic;
+using Kreta.Framework.Collections;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Entitások adatbázisműveleteit végző objektumának felülete.
+    /// </summary>
+    public interface IEntityDataAccessor
+    {
+        /// <summary>
+        /// Betölti egy entitás állapotát az adatbázisból.
+        /// </summary>
+        /// <param name="entity">A betöltendő entitás</param>
+        /// <param name="entityId">Az entitás adatbázisbeli azonosítója</param>
+        /// <returns>True, ha sikeres; egyébként False</returns>
+        bool LoadEntity(Entity entity, int entityId);
+
+        /// <summary>
+        /// Oszlopszűrten beltölti egy entitás állapotát az adatbázisból
+        /// </summary>
+        /// <param name="entity">A betöltendő entitás</param>
+        /// <param name="entityId">Az entitás adatbázisbeli azonosítója</param>
+        /// <param name="columnFilterMode">A szűrés módja, megengedő vagy tiltó</param>
+        /// <param name="columns">A szűrendő oszlopok felsorolása</param>
+        /// <returns>True, ha sikeres; egyébként False</returns>
+        bool FilteredLoadEntity(Entity entity, int entityId, ColumnFilterMode columnFilterMode, IEnumerable<string> columns);
+
+        /// <summary>
+        /// Betölt egy entitás listát a megadott szűrő feltétellel.
+        /// </summary>
+        /// <param name="collection">A feltöltendő lista</param>
+        /// <param name="filter">A szűrő SQL töredék</param>
+        void LoadWithFilter(IEntityCollection collection, string filter, Dictionary<string, object> commandParameters);
+
+        /// <summary>
+        /// Létrehoz egy új entitás példányt az adatbázisban.
+        /// </summary>
+        /// <param name="entity">A létrehozandó entitás</param>
+        void InsertEntity(Entity entity);
+
+        /// <summary>
+        /// Módosít egy entitás példányt az adatbázisban.
+        /// </summary>
+        /// <param name="entity">A módosítandó entitás</param>
+        /// <returns>True, ha sikeres; egyébként false</returns>
+        bool UpdateEntity(Entity entity);
+
+        /// <summary>
+        /// Módosítja egy entitás példány asszociációs kapcsolómezőit az adatbázisban.
+        /// </summary>
+        /// <param name="entity">A módosítandó entitás</param>
+        /// <returns>True, ha sikeres; egyébként false</returns>
+        bool UpdateAssociations(Entity entity);
+
+        /// <summary>
+        /// Töröl egy entitás példányt az adatbázisból.
+        /// </summary>
+        /// <param name="entity">A törlendő entitás</param>
+        void DeleteEntity(Entity entity, bool logikai = true);
+    }
+}

Framework/Entities/IEntityHandler.cs

@@ -0,0 +1,49 @@
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Entitás eseményeket kezelő osztályok felülete. Lásd még <see cref="EntityHandler"/>.
+    /// </summary>
+    public interface IEntityHandler
+    {
+        /// <summary>
+        /// Az entitás insert művelete előtt fut le.
+        /// </summary>
+        /// <param name="entity">Az entitás</param>
+        void BeforeInsert(Entity entity);
+
+        /// <summary>
+        /// Az entitás insert művelete után fut le.
+        /// </summary>
+        /// <param name="entity">Az entitás</param>
+        void AfterInsert(Entity entity);
+
+        /// <summary>
+        /// Az entitás update művelete előtt fut le.
+        /// </summary>
+        /// <param name="entity">Az entitás</param>
+        void BeforeUpdate(Entity entity);
+
+        /// <summary>
+        /// Az entitás update művelete után fut le.
+        /// </summary>
+        /// <param name="entity">Az entitás</param>
+        void AfterUpdate(Entity entity);
+
+        /// <summary>
+        /// Az entitás delete művelete előtt fut le.
+        /// </summary>
+        /// <param name="entity">Az entitás</param>
+        void BeforeDelete(Entity entity);
+
+        /// <summary>
+        /// Az entitás delete művelete után fut le.
+        /// </summary>
+        /// <param name="entity">Az entitás</param>
+        void AfterDelete(Entity entity);
+
+        /// <summary>
+        /// Létre van-e hozva az entitáshoz EntityHandler
+        /// </summary>
+        bool IsCreated { get; set; }
+    }
+}

Framework/Entities/InvalidEntityAttributeException.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Runtime.Serialization;
+using Kreta.Framework.Localization;
+using Kreta.Framework.Logging;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Érvénytelen entitás attribútumot jelző kivétel.
+    /// </summary>
+    [FriendlyName(1000027, "Az entitás érvénytelen attribútummal rendelkezik: a(z) {AttributeName} {Error}.")]
+    [ErrorCode(Events.ENTITY_INVALIDDATA)]
+    [Serializable]
+    public sealed class InvalidEntityAttributeException : EntityException
+    {
+        const string _errorMessage = "The entity has invalid attribute: {AttributeName} {Error}.";
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="entityName">Az entitás neve</param>
+        /// <param name="attributeName">Az attribútum neve</param>
+        public InvalidEntityAttributeException(string entityName, string attributeName)
+            : this(entityName, attributeName, EntityAttributeError.Unknown) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="entityName">Az entitás neve</param>
+        /// <param name="attributeName">Az attribútum neve</param>
+        /// <param name="error">A hiba típusa</param>
+        public InvalidEntityAttributeException(string entityName, string attributeName, EntityAttributeError error)
+            : this(entityName, attributeName, error, null) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="entityName">Az entitás neve</param>
+        /// <param name="attributeName">Az attribútum neve</param>
+        /// <param name="error">A hiba típusa</param>
+        /// <param name="innerException">Az előző kivétel</param>
+        public InvalidEntityAttributeException(string entityName, string attributeName, EntityAttributeError error, Exception innerException)
+            : base(_errorMessage, innerException)
+        {
+            SetValue("EntityName", entityName);
+            SetValue("AttributeName", attributeName);
+            SetValue("Error", error);
+        }
+
+        /// <summary>
+        /// Az osztály alapértelmezett konstruktora.
+        /// </summary>        
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public InvalidEntityAttributeException() { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="message">A kivétel üzenete</param>
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public InvalidEntityAttributeException(string message)
+            : base(message) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="message">A kivétel üzenete</param>
+        /// <param name="innerException">A belső kivétel</param>
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public InvalidEntityAttributeException(string message, Exception innerException)
+            : base(message, innerException) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="info">Sorosítási adatok</param>
+        /// <param name="context">Sorosítási adatfolyam</param>
+        InvalidEntityAttributeException(SerializationInfo info, StreamingContext context)
+            : base(info, context) { }
+    }
+}

Framework/Entities/ReadOnlyEntityAttributeException.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Runtime.Serialization;
+using Kreta.Framework.Localization;
+using Kreta.Framework.Logging;
+
+namespace Kreta.Framework.Entities
+{
+    /// <summary>
+    /// Módosítási kísérlet történt az entitás csak olvasható attribútumára.
+    /// </summary>
+    [FriendlyName(1000005, "A(z) '{AttributeName}' attribútum csak olvasható.")]
+    [ErrorCode(Events.ENTITY_READONLYATTRIBUTE)]
+    [Serializable]
+    public sealed class ReadOnlyEntityAttributeException : EntityException
+    {
+        const string _errorMessage = "The attribute is read-only.";
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="entityName">Az entitás neve</param>
+        /// <param name="attributeName">Az attribútum neve</param>
+        public ReadOnlyEntityAttributeException(string entityName, string attributeName)
+            : base(_errorMessage)
+        {
+            SetValue("EntityName", entityName);
+            SetValue("AttributeName", attributeName);
+        }
+
+        /// <summary>
+        /// Az osztály alapértelmezett konstruktora.
+        /// </summary>        
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public ReadOnlyEntityAttributeException() { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="message">A kivétel üzenete</param>
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public ReadOnlyEntityAttributeException(string message)
+            : base(message) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="message">A kivétel üzenete</param>
+        /// <param name="innerException">A belső kivétel</param>
+        [Obsolete("Ezt a konstruktort ne használd!")]
+        public ReadOnlyEntityAttributeException(string message, Exception innerException)
+            : base(message, innerException) { }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="info">Sorosítási adatok</param>
+        /// <param name="context">Sorosítási adatfolyam</param>
+        ReadOnlyEntityAttributeException(SerializationInfo info, StreamingContext context)
+            : base(info, context) { }
+    }
+}