public DeclaredPersistentProperty(Property property, MemberInfo memberInfo)
{
ArgumentsTools.CheckNotNull(property, "property");
ArgumentsTools.CheckNotNull(memberInfo, "memberInfo");
Member = memberInfo;
Property = property;
}
public ISet <Tuple <string, System.Type> > FindEntityTypes(long revision)
{
ArgumentsTools.CheckPositive(revision, "revision");
if (!_verCfg.GlobalCfg.IsTrackEntitiesChangedInRevisionEnabled)
{
throw new AuditException(@"This query is designed for Envers default mechanism of tracking entities modified in a given revision." +
" Extend DefaultTrackingModifiedEntitiesRevisionEntity, utilize ModifiedEntityNamesAttribute or set " +
"'nhibernate.envers.track_entities_changed_in_revision' parameter to true.");
}
var session = _auditReaderImplementor.Session;
var sessionImplementor = _auditReaderImplementor.SessionImplementor;
var revisions = new HashSet <long> {
revision
};
var query = _verCfg.RevisionInfoQueryCreator.RevisionsQuery(session, revisions);
var revisionInfo = query.UniqueResult();
if (revisionInfo != null)
{
// If revision exists
var entityNames = _verCfg.ModifiedEntityNamesReader.ModifiedEntityTypes(revisionInfo);
if (entityNames != null)
{
// Generate result that contains entity names and corresponding CLR classes.
var result = new HashSet <Tuple <string, System.Type> >();
foreach (var entityName in entityNames)
{
result.Add(new Tuple <string, System.Type>(entityName, Toolz.ResolveEntityClass(sessionImplementor, entityName)));
}
return(result);
}
}
return(new HashSet <Tuple <string, System.Type> >());
}
/**
* Creates a query, which will return entities satisfying some conditions (specified later),
* at a given revision.
* @param c Class of the entities for which to query.
* @param revision Revision number at which to execute the query.
* @return A query for entities at a given revision, to which conditions can be added and which
* can then be executed. The result of the query will be a list of entities (beans), unless a
* projection is added.
*/
public IAuditQuery ForEntitiesAtRevision(System.Type c, long revision)
{
//throw new NotImplementedException("Query not implemented yet");
ArgumentsTools.CheckNotNull(revision, "Entity revision");
ArgumentsTools.CheckPositive(revision, "Entity revision");
return(new EntitiesAtRevisionQuery(auditCfg, auditReaderImplementor, c, revision));
}
private void fillRevisionsResult <T>(IDictionary <long, T> result, IEnumerable <long> revisions)
{
foreach (var revision in revisions)
{
ArgumentsTools.CheckPositive(revision, "Entity revision");
}
var revisionList = verCfg.RevisionInfoQueryCreator.RevisionsQuery(Session, revisions).List();
foreach (T revision in revisionList)
{
var rev = verCfg.RevisionInfoNumberReader.RevisionNumber(revision);
result[rev] = revision;
}
}
public DateTime GetRevisionDate(long revision)
{
ArgumentsTools.CheckPositive(revision, "Entity revision");
var query = verCfg.RevisionInfoQueryCreator.RevisionDateQuery(Session, revision);
var timestampObject = query.UniqueResult();
if (timestampObject == null)
{
throw new RevisionDoesNotExistException(revision);
}
// The timestamp object is either a date or a long
return(timestampObject is DateTime ? (DateTime)timestampObject : new DateTime((long)timestampObject));
}
public IEnumerable <long> GetRevisions(string entityName, object primaryKey)
{
ArgumentsTools.CheckNotNull(primaryKey, "Primary key");
if (!verCfg.EntCfg.IsVersioned(entityName))
{
throw new NotAuditedException(entityName, entityName + " is not versioned!");
}
var resultList = CreateQuery().ForRevisionsOfEntity(entityName, false, true)
.AddProjection(AuditEntity.RevisionNumber())
.Add(AuditEntity.Id().Eq(primaryKey))
.GetResultList();
return(from object revision in resultList select Convert.ToInt64(revision));
}
public object FindRevision(long revision)
{
ArgumentsTools.CheckPositive(revision, "revision");
var revisions = new List <long>(1)
{
revision
};
var query = verCfg.RevisionInfoQueryCreator.RevisionsQuery(Session, revisions);
var revisionData = query.UniqueResult();
if (revisionData == null)
{
throw new RevisionDoesNotExistException(revision);
}
return(revisionData);
}
public IList GetRevisions(System.Type cls, Object primaryKey)
{
// todo: if a class is not versioned from the beginning, there's a missing ADD rev - what then?
ArgumentsTools.CheckNotNull(cls, "Entity class");
ArgumentsTools.CheckNotNull(primaryKey, "Primary key");
CheckSession();
String entityName = cls.FullName;
if (!verCfg.EntCfg.IsVersioned(entityName))
{
throw new NotAuditedException(entityName, entityName + " is not versioned!");
}
return(CreateQuery().ForRevisionsOfEntity(cls, false, true)
.AddProjection(AuditEntity.RevisionNumber())
.Add(AuditEntity.Id().Eq(primaryKey))
.GetResultList());
}
public long GetRevisionNumberForDate(DateTime date)
{
ArgumentsTools.CheckNotNull(date, "Date of revision");
CheckSession();
IQuery query = verCfg.RevisionInfoQueryCreator.getRevisionNumberForDateQuery(Session, date);
try {
object res = query.UniqueResult();
if (res == null)
{
throw new RevisionDoesNotExistException(date);
}
return((long)res);
} catch (NonUniqueResultException e) {
throw new AuditException(e);
}
}
public T FindRevision <T>(System.Type revisionEntityClass, long revision)
{
ArgumentsTools.CheckNotNull(revision, "Entity revision");
ArgumentsTools.CheckPositive(revision, "Entity revision");
CheckSession();
IQuery query = verCfg.RevisionInfoQueryCreator.getRevisionQuery(Session, revision);
try {
object revisionData = query.UniqueResult();
if (revisionData == null)
{
throw new RevisionDoesNotExistException(revision);
}
return((T)revisionData);
} catch (NonUniqueResultException e) {
throw new AuditException(e);
}
}
public DateTime GetRevisionDate(long revision)
{
ArgumentsTools.CheckNotNull(revision, "Entity revision");
ArgumentsTools.CheckPositive(revision, "Entity revision");
CheckSession();
IQuery query = verCfg.RevisionInfoQueryCreator.getRevisionDateQuery(Session, revision);
try {
Object timestampObject = query.UniqueResult();
if (timestampObject == null)
{
throw new RevisionDoesNotExistException(revision);
}
// The timestamp object is either a date or a long
return(timestampObject is DateTime ? (DateTime)timestampObject : new DateTime((long)timestampObject));
} catch (NonUniqueResultException e) {
throw new AuditException(e);
}
}
public object Find(System.Type cls, object primaryKey, long revision)
{
ArgumentsTools.CheckNotNull(primaryKey, "Primary key");
ArgumentsTools.CheckNotNull(revision, "Entity revision");
ArgumentsTools.CheckPositive(revision, "Entity revision");
CheckSession();
String entityName = cls.FullName;
if (!verCfg.EntCfg.IsVersioned(entityName))
{
throw new NotAuditedException(entityName, entityName + " is not versioned!");
}
if (FirstLevelCache.Contains(entityName, revision, primaryKey))
{
return(FirstLevelCache[entityName, revision, primaryKey]);
}
Object result;
try
{
// The result is put into the cache by the entity instantiator called from the query
result = CreateQuery().ForEntitiesAtRevision(cls, revision)
.Add(AuditEntity.Id().Eq(primaryKey)).GetSingleResult();
}
catch (NonUniqueResultException e)
{
throw new AuditException(e);
}
catch (HibernateException e)
{//ORIG: NoResultException e
result = null;
}
return(result);
}
public object Find(string entityName, object primaryKey, long revision, bool includeDeletions)
{
ArgumentsTools.CheckNotNull(primaryKey, "Primary key");
ArgumentsTools.CheckPositive(revision, "Entity revision");
if (!verCfg.EntCfg.IsVersioned(entityName))
{
throw new NotAuditedException(entityName, entityName + " is not versioned!");
}
object result;
if (FirstLevelCache.TryGetValue(entityName, revision, primaryKey, out result))
{
return(result);
}
// The result is put into the cache by the entity instantiator called from the query
result = CreateQuery().ForEntitiesAtRevision(entityName, revision, includeDeletions)
.Add(AuditEntity.Id().Eq(primaryKey)).GetSingleResult();
return(result);
}
/// <summary>
/// Creates a query, which will return entities modified at the specified revision.
/// In comparison, the <seealso cref="ForEntitiesAtRevision(System.Type, long)"/> query takes into all entities
/// which were present at a given revision, even if they were not modified.
/// </summary>
/// <param name="entityName">Name of the entity.</param>
/// <param name="revision">Revision number at which to execute the query.</param>
/// <returns>
/// A query for entities changed at a given revision, to which conditions can be added and which
/// can then be executed.
/// </returns>
public IAuditQuery ForEntitiesModifiedAtRevision(string entityName, long revision)
{
ArgumentsTools.CheckPositive(revision, "revision");
return(new EntitiesModifiedAtRevisionQuery(auditCfg, auditReaderImplementor, entityName, revision));
}
/// <summary>
/// Creates a query, which will return entities modified at the specified revision.
/// In comparison, the <seealso cref="ForEntitiesAtRevision(System.Type, long)"/> query takes into all entities
/// which were present at a given revision, even if they were not modified.
/// </summary>
/// <param name="c">Class of the entities for which to query.</param>
/// <param name="revision">Revision number at which to execute the query.</param>
/// <returns>
/// A query for entities changed at a given revision, to which conditions can be added and which
/// can then be executed.
/// </returns>
public IAuditQuery ForEntitiesModifiedAtRevision(System.Type c, long revision)
{
ArgumentsTools.CheckPositive(revision, "revision");
return(new EntitiesModifiedAtRevisionQuery(auditCfg, auditReaderImplementor, c, revision));
}
/// <summary>
/// Creates a query, which will return entities satisfying some conditions (specified later), at a given revision.
/// Deleted entities may be optionally included.
/// </summary>
/// <param name="entityName">Name of entity</param>
/// <param name="revision">Revision number at which to execute the query.</param>
/// <param name="includeDeletions">Whether to include deleted entities in the search.</param>
/// <returns>A query for entities at a given revision, to which conditions can be added and which can then be executed</returns>
/// <remarks>The result of the query will be a list of entities instances, unless a projection is added.</remarks>
public IAuditQuery ForEntitiesAtRevision(string entityName, long revision, bool includeDeletions)
{
ArgumentsTools.CheckPositive(revision, "revision");
return(new EntitiesAtRevisionQuery(auditCfg, auditReaderImplementor, entityName, revision, includeDeletions));
}
/// <summary>
/// Creates a query, which will return entities satisfying some conditions (specified later), at a given revision.
/// </summary>
/// <typeparam name="TEntity">The <see cref="System.Type"/> of the entities for which to query.</typeparam>
/// <param name="revision">Revision number at which to execute the query.</param>
/// <returns>A query for entities at a given revision, to which conditions can be added and which can then be executed</returns>
public IEntityAuditQuery <TEntity> ForEntitiesAtRevision <TEntity>(long revision) where TEntity : class
{
ArgumentsTools.CheckPositive(revision, "Entity revision");
return(new AllEntitiesAtRevisionQuery <TEntity>(auditCfg, auditReaderImplementor, revision));
}
