public ICriteria AddCriteria(ICriteria criteria)
{
if (m_order == SortFilter.Orders.ASC)
{
return criteria.AddOrder(NHibernate.Criterion.Order.Asc(m_fieldName));
}
else
{
return criteria.AddOrder(NHibernate.Criterion.Order.Desc(m_fieldName));
}
}
public IList <User> FindAll(string applicationName)
{
ICriteria criteria = CreateCriteria();
criteria.Add(Expression.Eq("ApplicationName", applicationName));
criteria.AddOrder(Order.Asc("Name"));
return(Find(criteria, false));
}
public static IList <EmptyLegOffer> GetEmptyLegBids(EmptyLeg el, Agent a)
{
ICriteria cr = NHibernateHelper.GetCurrentSession().CreateCriteria(typeof(EmptyLegOffer));
cr.Add(Restrictions.Eq("EmptyLeg", el));
cr.Add(Restrictions.Eq("Agent", a));
cr.AddOrder(new Order("TimeOfOffer", false));
return(cr.List <EmptyLegOffer>());
}
public static IList <OperatorBid> GetBidsForRequest(BookRequest b)
{
ICriteria cr = NHibernateHelper.GetCurrentSession().CreateCriteria(typeof(OperatorBid));
cr.Add(Restrictions.Eq("Request", b));
cr.Add(Restrictions.Not(Restrictions.Eq("Status", (short)2)));
cr.AddOrder(new Order("TimeOfBid", false));
return(cr.List <OperatorBid>());
}
public IList <Draft> FindItemByChapterId(string chapterVersionId)
{
ICriteria criteria = CreateCriteria();
criteria.Add(Expression.Eq("VersionId", chapterVersionId));
criteria.AddOrder(Order.Desc("SaveDate"));
return(base.Find(criteria, false));
}
public IList <Provider> GetActives()
{
ICriteria crit = GetCriteria();
crit.Add(Expression.Eq("ProviderStatus", ProviderStatus.Active));
crit.AddOrder(new Order("Name", false));
return(crit.List <Provider>());
}
public ICriteria TranslateToNHQuery(ICriteria criteria)
{
BuildQueryFrom(query, criteria);
if (query.OrderByProperty != null)
{
criteria.AddOrder(new Order(query.OrderByProperty.PropertyName, !query.OrderByProperty.Desc));
}
return(criteria);
}
/// <summary>
/// Get the top 25 invoices ordered by the most recently created invoice
/// </summary>
/// <returns></returns>
public IList <Invoice> GetTop25()
{
ICriteria criteria = Session.CreateCriteria <Invoice>();
criteria.SetMaxResults(25);
criteria.AddOrder(Order.Desc("Id"));
return(criteria.List <Invoice>());
}
public virtual IList <Aluno> SelecionarMatriculados()
{
ICriteria criteria = Sessao.CreateCriteria(this.GetType()).
CreateAlias("Pessoa", "pes");
criteria.Add(Expression.Eq("Situacao", "M"));
criteria.AddOrder(Order.Asc("pes.Nome"));
return(criteria.List <Aluno>());
}
List <WatchPrimpogoda> IRepository <Models.WatchPrimpogoda> .GetAll()
{
using (ISession session = NHibernateHelper.OpenSession())
{
ICriteria criteria = session.CreateCriteria(typeof(WatchPrimpogoda));
criteria.AddOrder(Order.Desc("ID"));
return(criteria.List <WatchPrimpogoda>().ToList <WatchPrimpogoda>());
}
}
public static void CriteriaAddOrders(ICriteria criteria, IList <string> orders)
{
foreach (var order in orders)
{
bool isDesc = order.StartsWith("-");
var pName = isDesc ? order.Substring(1) : order;
criteria.AddOrder(isDesc ? Order.Desc(pName) : Order.Asc(pName));
}
}
public Models.GeospaceReview GetByLast()
{
using (ISession session = NHibernateHelper.OpenSession())
{
ICriteria criteria = session.CreateCriteria(typeof(NewsEntity.Models.GeospaceReview));
criteria.AddOrder(Order.Asc("ID"));
return(criteria.List <NewsEntity.Models.GeospaceReview>().Last());
}
}
public History GetLast(Campaign c)
{
ICriteria crit = this.GetCriteria();
crit.CreateCriteria("Campaign").Add(Expression.Eq("ID", c.ID));
crit.AddOrder(new Order("SentDate", false));
crit.SetMaxResults(1);
return(crit.UniqueResult() as History);
}
public IList <Topic> Find(Category category)
{
ICriteria criteria = CreateCriteria();
criteria.CreateCriteria("Category").Add(Expression.Eq("Id", category.Id));
criteria.AddOrder(Order.Desc("InsertDate"));
return(Find(criteria, false));
}
protected virtual void SetFetchOptions(ICriteria crit, FetchOptions options)
{
if (!string.IsNullOrEmpty(options.SortExpression))
{
crit.AddOrder(options.SortDirection == SortDirection.Ascending ?
Order.Asc(options.SortExpression) :
Order.Desc(options.SortExpression));
}
}
IList <CallbackAspDotNetMvc.Models.Call> IRepository <CallbackAspDotNetMvc.Models.Call> .GetAll()
{
using (ISession session = NHibernateHelper.OpenSession())
{
ICriteria criteria = session.CreateCriteria(typeof(CallbackAspDotNetMvc.Models.Call));
criteria.AddOrder(Order.Desc("updated_at"));
return(criteria.List <CallbackAspDotNetMvc.Models.Call>());
}
}
List <GeospaceReview> IRepository <Models.GeospaceReview> .GetAll()
{
using (ISession session = NHibernateHelper.OpenSession())
{
ICriteria criteria = session.CreateCriteria(typeof(GeospaceReview));
criteria.AddOrder(Order.Desc("ID"));
return(criteria.List <GeospaceReview>().ToList <GeospaceReview>());
}
}
public IEnumerable <TWO> GetWOByDate(DateTime?dateFrom, DateTime?dateTo)
{
ICriteria criteria = Session.CreateCriteria(typeof(TWO));
criteria.Add(Expression.Between("WODate", dateFrom, dateTo));
criteria.Add(Expression.Not(Expression.Eq("DataStatus", "Deleted")));
criteria.AddOrder(Order.Asc("WODate"));
return(criteria.List <TWO>());
}
IList <MeteologyEntity.Models.Groza.Groza> IRepository <MeteologyEntity.Models.Groza.Groza> .GetAll()
{
using (ISession session = NHibernateHelper.OpenSession())
{
ICriteria criteria = session.CreateCriteria(typeof(MeteologyEntity.Models.Groza.Groza));
criteria.AddOrder(Order.Desc("ID"));
return(criteria.List <MeteologyEntity.Models.Groza.Groza>());
}
}
public IList <Item> FindByCategory(Category category, PagingInfo paging)
{
ICriteria criteria = CreateCriteria();
criteria.CreateCriteria("Category").Add(Expression.Eq("Id", category.Id));
criteria.AddOrder(Order.Desc("NewsDate"));
return(Find(criteria, paging, false));
}
IList <Codes.Models.Error> IRepository <Codes.Models.Error> .GetAll()
{
using (ISession session = NHibernateHelper.OpenSession())
{
ICriteria criteria = session.CreateCriteria(typeof(Codes.Models.Error));
criteria.AddOrder(Order.Asc("ID"));
return(criteria.List <Codes.Models.Error>());
}
}
public IList <ProfileProperty> FindByUser(ProfileUser user)
{
ICriteria criteria = CreateCriteria();
criteria.CreateCriteria("User").Add(Expression.Eq("Id", user.Id));
criteria.AddOrder(Order.Desc("Name"));
return(Find(criteria, null));
}
IList<Station> IRepository<Station>.GetAll()
{
using (ISession session = NHibernateHelper.OpenSession())
{
ICriteria criteria = session.CreateCriteria(typeof(Station));
criteria.AddOrder(Order.Asc("ID"));
return criteria.List<Station>();
}
}
public override IList <EventType> GetAll()
{
ICriteria crit = Session.CreateCriteria(typeof(EventType));
crit.AddOrder(new Order("Description", true));
crit.SetCacheable(true);
crit.SetCacheRegion("Static");
return(crit.List <EventType>());
}
IList <Bulletin.Models.Condition> IRepository <Bulletin.Models.Condition> .GetAll()
{
using (ISession session = NHibernateHelper.OpenSession())
{
ICriteria criteria = session.CreateCriteria(typeof(Bulletin.Models.Condition));
criteria.AddOrder(Order.Desc("ID"));
return(criteria.List <Bulletin.Models.Condition>());
}
}
public static ICriteria TranslateIntoNHQuery <T>(this Query query, ICriteria criteria)
{
BuildQueryFrom(query, criteria);
if (query.OrderByProperty != null)
{
criteria.AddOrder(new Order(query.OrderByProperty.PropertyName, !query.OrderByProperty.Desc));
}
return(criteria);
}
public IEnumerable <MEquip> GetListNotDeleted()
{
ICriteria criteria = Session.CreateCriteria(typeof(MEquip));
criteria.Add(Expression.Not(Expression.Eq("DataStatus", "Deleted")));
criteria.AddOrder(new Order("EquipName", true));
//criteria.SetFetchMode("CityId", FetchMode.Eager);
return(criteria.List <MEquip>());
}
IList <Emp> IRepository <Emp> .GetAll()
{
using (ISession session = NHibernateHelper.OpenSession())
{
ICriteria criteria = session.CreateCriteria(typeof(Emp));
criteria.AddOrder(Order.Desc("ID"));
return(criteria.List <Emp>());
}
}
/// <summary>
/// Initializes the session that will be used to enumerate
/// </summary>
private void InitSession()
{
_session = _sessionFactory.OpenSession();
_session.FlushMode = FlushMode.Never;
_tx = _session.BeginTransaction();
try
{
//Handle the case of entity type (InitialLoad)
if (_entityType != null)
{
_criteria = _session.CreateCriteria(_entityType);
_criteria.SetCacheable(false);
//If perform by id, add order to the criteria
if (_performOrderById)
{
IClassMetadata metadata = _sessionFactory.GetClassMetadata(_entityType);
string idPropName = metadata.IdentifierPropertyName;
if (idPropName != null)
{
_criteria.AddOrder(Order.Asc(idPropName));
}
}
}
//Handle the case of Persistency.Query (GetEnumerator)
else if (_persistencyQuery != null)
{
string select = _persistencyQuery.SqlQuery;
_query = _session.CreateQuery(select);
object[] preparedValues = _persistencyQuery.Parameters;
if (preparedValues != null)
{
for (int i = 0; i < preparedValues.Length; i++)
{
_query.SetParameter(i, preparedValues[i]);
}
}
_query.SetCacheable(false);
_query.SetFlushMode(FlushMode.Never);
}
else
{
throw new Exception("NHibernateDataEnumerator must receive an Entity Type or a Query");
}
}
catch (Exception ex)
{
if (_tx != null && _tx.IsActive)
{
_tx.Rollback();
}
if (_session.IsOpen)
{
_session.Close();
}
throw new Exception("Error while constructing an enumerator", ex);
}
}
public IList <Item> FindByOwner(string owner)
{
ICriteria criteria = CreateCriteria();
criteria.Add(Expression.Eq("Owner", owner));
criteria.AddOrder(Order.Desc("NewsDate"));
return(Find(criteria, false));
}
IList <Models.Forecast> IRepository <Models.Forecast> .GetAll()
{
using (ISession session = NHibernateHelper.OpenSession())
{
ICriteria criteria = session.CreateCriteria(typeof(Models.Forecast));
criteria.AddOrder(Order.Desc("ID"));
return(criteria.List <Models.Forecast>());
}
}
/// <summary>
/// Adds a collection of Order (sort by) specifiers to an ICriteria.
/// </summary>
/// <param name="criteria">The ICriteria that will be modified.</param>
/// <param name="orders">The collection of Order specifiers.</param>
internal static void AddOrdersToCriteria(ICriteria criteria, Order[] orders)
{
if (orders != null)
{
foreach (Order order in orders)
{
criteria.AddOrder(order);
}
}
}
public void setOrderBy(ref ICriteria icr)
{
icr.AddOrder(Order.Desc("id"));
}
public void setOrderBy(ref ICriteria icr)
{
icr.AddOrder(new Order("recInd", false));
icr.AddOrder(new Order("recLevel", false));
icr.AddOrder((new Order("hotelName",true)));
}
public static ICriteria OrderComplexSearch(IList<OrderCriteria> critList, ICriteria c)
{
foreach (OrderCriteria s in critList)
{
switch (s.Order)
{
case OrderType.ASC:
c.AddOrder(Order.Asc(s.PropertyName));
break;
case OrderType.DESC:
c.AddOrder(Order.Desc(s.PropertyName));
break;
}
}
return c;
}
protected void setOrderby(ref ICriteria icr)
{
string orderbyName = WebUtil.GetParamAttr("orderbyName",null);
if (orderbyName == null) return;
string orderbyType = WebUtil.GetParamAttr("orderbyType", "desc");
if (orderbyType == "desc") {
icr.AddOrder(Order.Desc(orderbyName));
}
else if (orderbyType == "asc")
{
icr.AddOrder(Order.Asc(orderbyName));
}
else {
icr.AddOrder(Order.Desc(orderbyName));
}
}
private static void AddTimeOrdering(ICriteria criteria)
{
criteria.AddOrder(Order.Asc("Year"));
criteria.AddOrder(Order.Asc("Quarter"));
criteria.AddOrder(Order.Asc("Month"));
}
private static void GetOrder(Sort sort, ICriteria cr)
{
bool sortDir = sort.Direction == "ASC" ? true : false;
Order order = null;
if (sort.Column.IndexOf(".", StringComparison.OrdinalIgnoreCase) >= 0)
order = new Order(sort.Column, sortDir);
else
order = new Order(string.Format("attendance.{0}", sort.Column), sortDir);
cr.AddOrder(order);
}
public void setOrderBy(ref ICriteria icr)
{
icr.AddOrder(Order.Desc("recInd"));
icr.AddOrder(Order.Desc("recLevel"));
icr.AddOrder(Order.Desc("picURL"));
icr.AddOrder(Order.Desc("brandName"));
}
private static void GetOrder(Sort sort, ICriteria cr)
{
bool sortDir = sort.Direction == "ASC" ? true : false;
Order order = new Order(string.Format("dept.{0}", sort.Column), sortDir);
cr.AddOrder(order);
}
public void OnEvent(ICriteria crit)
{
crit.AddOrder(order);
}
private static void AddOrdersToCriteria(ICriteria criteria, IEnumerable<Order> orders)
{
if (orders != null)
{
foreach (Order order in orders)
{
criteria.AddOrder(order);
}
}
}
public void Get_OnCriteria(object sender, ICriteria criteria)
{
criteria.AddOrder(Order.Asc("Code"));
// ICriterion criterion = Restrictions.Eq("Name", "测试123");
// criteria.Add(criterion);
}
/// <summary>
///
/// </summary>
/// <param name="hibernateCriteria"></param>
/// <param name="where"></param>
/// <param name="orders"></param>
private void AddCriteriaAndOrder(ICriteria hibernateCriteria, IEnumerable<ICriterion> where, IEnumerable<Order> orders)
{
foreach (ICriterion criterion in where)
{
hibernateCriteria.Add(criterion);
}
foreach (Order order in orders)
{
hibernateCriteria.AddOrder(order);
}
}
/// <summary>
/// Initializes the session that will be used to enumerate
/// </summary>
private void InitSession()
{
_session = _sessionFactory.OpenSession();
_session.FlushMode = FlushMode.Never;
_tx = _session.BeginTransaction();
try
{
//Handle the case of entity type (InitialLoad)
if (_entityType != null)
{
_criteria = _session.CreateCriteria(_entityType);
_criteria.SetCacheable(false);
//If perform by id, add order to the criteria
if (_performOrderById)
{
IClassMetadata metadata = _sessionFactory.GetClassMetadata(_entityType);
string idPropName = metadata.IdentifierPropertyName;
if (idPropName != null)
_criteria.AddOrder(Order.Asc(idPropName));
}
}
//Handle the case of Persistency.Query (GetEnumerator)
else if (_persistencyQuery != null)
{
string select = _persistencyQuery.SqlQuery;
_query = _session.CreateQuery(select);
object[] preparedValues = _persistencyQuery.Parameters;
if (preparedValues != null)
{
for (int i = 0; i < preparedValues.Length; i++)
{
_query.SetParameter(i, preparedValues[i]);
}
}
_query.SetCacheable(false);
_query.SetFlushMode(FlushMode.Never);
}
else throw new Exception("NHibernateDataEnumerator must receive an Entity Type or a Query");
}
catch(Exception ex)
{
if (_tx != null && _tx.IsActive)
_tx.Rollback();
if (_session.IsOpen)
_session.Close();
throw new Exception("Error while constructing an enumerator", ex);
}
}
