public void delete(DomainObject subject, SqlConnection connection, SqlTransaction transaction)
        {
            try
            {
                Person person = (Person)subject;

                SqlCommand command = new SqlCommand(
                    "DELETE FROM Persons WHERE PersonID = @PersonId AND chTimestamp = @chTimestamp",
                    connection, transaction);

                command.Parameters.Add("@chTimestamp", person.Timestamp.Value);
                if(subject.isNull("PersonId"))
                {
                    command.Parameters.Add("@PersonId", DBNull.Value );
                }
                else
                {
                    command.Parameters.Add("@PersonId", person.PersonId);
                }
                if(command.ExecuteNonQuery() <= 0)
                {
                    throw new ConcurrencyException();
                }
            }
            catch(SqlException sqle)
            {
                throw new ApplicationException(sqle.Message);
            }
            catch(Exception e)
            {
                throw new ApplicationException(e.Message);
            }
        }

        public void delete(DomainObject subject, SqlConnection connection, SqlTransaction transaction)
        {
            try
            {
                Employee employee = (Employee)subject;

                SqlCommand command = new SqlCommand(
                    "DELETE FROM Employees WHERE EmployeeID = @EmployeeId AND VersionId = @VersionId",
                    connection, transaction);

                command.Parameters.Add("@VersionId", employee.Timestamp.Value);
                if(subject.isNull("EmployeeId"))
                {
                    command.Parameters.Add("@EmployeeId", DBNull.Value );
                }
                else
                {
                    command.Parameters.Add("@EmployeeId", employee.EmployeeId);
                }
                if(command.ExecuteNonQuery() <= 0)
                {
                    throw new ConcurrencyException();
                }
            }
            catch(SqlException sqle)
            {
                throw new ApplicationException(sqle.Message);
            }
            catch(Exception e)
            {
                throw new ApplicationException(e.Message);
            }
        }

		public void WithCustomizedTagNameAndIdentityProperty()
		{
			var id = string.Empty;
			using (var store = NewDocumentStore())
			{
				store.Conventions.AllowQueriesOnId = true;
				var defaultFindIdentityProperty = store.Conventions.FindIdentityProperty;
				store.Conventions.FindIdentityProperty = property =>
					typeof(IEntity).IsAssignableFrom(property.DeclaringType)
					  ? property.Name == "Id2"
					  : defaultFindIdentityProperty(property);

				store.Conventions.FindTypeTagName = type =>
				                                    typeof (IDomainObject).IsAssignableFrom(type)
				                                    	? "domainobjects"
				                                    	: DocumentConvention.DefaultTypeTagName(type);

				using (var session = store.OpenSession())
				{
					var domainObject = new DomainObject();
					session.Store(domainObject);
					var domainObject2 = new DomainObject();
					session.Store(domainObject2);
					session.SaveChanges();
					id = domainObject.Id2;
				}
				var matchingDomainObjects = store.OpenSession().Query<IDomainObject>().Where(_ => _.Id2 == id).ToList();
				Assert.Equal(matchingDomainObjects.Count, 1);
			}


		}

        protected override void deepCopy(DomainObject domainObject)
        {
            base.deepCopy(domainObject);

            File file = (File)domainObject;
            relFileNamePath = file.relFileNamePath;
        }

        public void delete(DomainObject subject, SqlConnection connection, SqlTransaction transaction)
        {
            try
            {
                Territory territory = (Territory)subject;

                SqlCommand command = new SqlCommand(
                    "DELETE FROM Territories WHERE TerritoryID = @TerritoryId AND VersionId = @VersionId",
                    connection, transaction);

                command.Parameters.Add("@VersionId", territory.Timestamp.Value);
                if(subject.isNull("TerritoryId"))
                {
                    command.Parameters.Add("@TerritoryId", DBNull.Value );
                }
                else
                {
                    command.Parameters.Add("@TerritoryId", territory.TerritoryId);
                }
                if(command.ExecuteNonQuery() <= 0)
                {
                    throw new ConcurrencyException();
                }
            }
            catch(SqlException sqle)
            {
                throw new ApplicationException(sqle.Message);
            }
            catch(Exception e)
            {
                throw new ApplicationException(e.Message);
            }
        }

 public override void SetInfoFieldFromObject(DomainObject pobj, DomainObjectInfo info, IPersistenceContext pctx)
 {
     Entity entity = (Entity)GetClassFieldValue(pobj);
     if (entity != null && pctx.IsProxyLoaded(entity))
     {
         SetInfoFieldValue(info, _entityConversion.GetInfoFromObject(entity, pctx));
     }
 }

 public void unregisterDomainObject(DomainObject domainObject)
 {
     Hashtable typeMap = (Hashtable)m_typeMaps[domainObject.GetType().BaseType];
     if(typeMap == null)
         Debug.Assert(false);
     Debug.Assert(typeMap.Contains(domainObject.Id));
     typeMap.Remove(domainObject.Id);
 }

 public void RegisterDirty(DomainObject obj)
 {
     if (!(this.newObjects.Contains(obj) || this.dirtyObjects.Contains(obj)))
     {
         this.dirtyObjects.Add(obj);
         this.OnChanged();
     }
 }

 public static bool IsPersistent(DomainObject entity)
 {
     var keyAttributedProps =
         entity.GetType()
             .GetProperties()
             .FirstOrDefault(p => p.GetCustomAttributes(typeof (KeyAttribute), true).Length == 1);
     return (keyAttributedProps != null) && !keyAttributedProps.GetValue(entity, null).ToString().Equals("0");
 }

        public void Remove(DomainObject item)
        {
            if(item == Person.None) return;
            if (_domainObjects.Contains(item) == false) return;  // Already exists

            IList bindingList = _bindingLists[item.GetType()];

            bindingList.Remove(item);
            _domainObjects.Remove(item);
        }

			public void Persist(DomainObject<Guid, DomainEvent> entity)
			{
				foreach (var @event in entity.GetEvents())
				{
					this.events.Add(@event);
					Console.WriteLine("Saved event {0} to the store.", @event);
				}

				entity.AcceptEvents();
			}

 public override bool Validate(DomainObject domainObject)
 {
     try
     {
         return GetPropertyValue(domainObject).ToString().Length > 0;
     }
     catch
     {
         return false;
     }
 }

 public override void SetObjectFieldFromInfo(DomainObject pobj, DomainObjectInfo info, IPersistenceContext pctx)
 {
     EntityInfo entityInfo = (EntityInfo)GetInfoFieldValue(info);
     if (entityInfo != null && entityInfo.GetEntityRef() != null)
     {
         // don't copy any information from the referenced EntityInfo
         // only take its reference
         Entity entity = pctx.Load(entityInfo.GetEntityRef(), EntityLoadFlags.Proxy);    // proxy, no version check!
         SetClassFieldValue(pobj, entity);
     }
 }

 public List<Comment> GetAll(DomainObject<int> target)
 {
     return DbManager
         .ExecuteList(
             Query("projects_comments")
             .Select(columns)
             .Where("target_uniq_id", target.UniqID))
         .ConvertAll(r => ToComment(r))
         .OrderBy(c => c.CreateOn)
         .ToList();
 }

 public void registerDomainObject(DomainObject domainObject)
 {
     Type type = domainObject.GetType().BaseType;
     Hashtable typeMap = (Hashtable)m_typeMaps[type];
     if(typeMap == null)
     {
         typeMap = new Hashtable();
         m_typeMaps[type] = typeMap;
     }
     Debug.Assert(typeMap.Contains(domainObject) == false);
     typeMap.Add(domainObject.Id, domainObject);
 }

        protected override void checkBusinessRulesOnAdd(DomainObject entity)
        {
            PraviloOceneVezbe pravilo = (PraviloOceneVezbe)entity;
            Notification notification = new Notification();

            PraviloOceneVezbeDAO praviloOceneVezbeDAO = DAOFactoryFactory.DAOFactory.GetPraviloOceneVezbeDAO();
            if (praviloOceneVezbeDAO.postojiPravilo(pravilo.Naziv))
            {
                notification.RegisterMessage("Naziv", "Pravilo sa datim nazivom vec postoji.");
                throw new BusinessException(notification);
            }
        }

        protected override void checkBusinessRulesOnAdd(DomainObject entity)
        {
            Gimnasticar g = (Gimnasticar)entity;
            Notification notification = new Notification();

            GimnasticarDAO gimnasticarDAO = DAOFactoryFactory.DAOFactory.GetGimnasticarDAO();
            if (gimnasticarDAO.postojiGimnasticar(g.Ime, g.Prezime))
            {
                notification.RegisterMessage("Ime", "Gimnasticar sa datim imenom i prezimenom vec postoji.");
                throw new BusinessException(notification);
            }
        }

 public override bool Validate(DomainObject domainObject)
 {
     try
     {
         int id = int.Parse(GetPropertyValue(domainObject).ToString());
         return id >= 0;
     }
     catch
     {
         return false;
     }
 }

 public Comment GetLast(DomainObject<Int32> target)
 {
     return DbManager
         .ExecuteList(
             Query("projects_comments")
             .Select(columns)
             .Where("target_uniq_id", target.UniqID)
             .Where("inactive", false)
             .OrderBy("create_on", false)
             .SetMaxResults(1))
         .ConvertAll(r => ToComment(r))
         .SingleOrDefault();
 }

        protected override void checkBusinessRulesOnUpdate(DomainObject entity)
        {
            PraviloOceneVezbe pravilo = (PraviloOceneVezbe)entity;
            Notification notification = new Notification();

            PraviloOceneVezbeDAO praviloOceneVezbeDAO = DAOFactoryFactory.DAOFactory.GetPraviloOceneVezbeDAO();
            bool nazivChanged = (pravilo.Naziv.ToUpper() != oldNaziv.ToUpper()) ? true : false;
            if (nazivChanged && praviloOceneVezbeDAO.postojiPravilo(pravilo.Naziv))
            {
                notification.RegisterMessage("Naziv", "Pravilo sa datim nazivom vec postoji.");
                throw new BusinessException(notification);
            }
        }