public void PagingQuery(PagingQueryContext <AppSetting> context)
{
context.QueryResult = HibernateTemplate.ExecuteFind((ISession session) =>
{
var criteria = session.CreateCriteria <AppSetting>("app");
if (context.QueryParams.ContainsKey("Name"))
{
criteria.Add(Restrictions.Eq("app.Name", context.GetQueryParam <string>("Name")));
}
if (context.QueryParams.ContainsKey("Type"))
{
criteria.Add(Restrictions.Eq("app.Type", context.GetQueryParam <AppSettingType>("Type")));
}
if (context.QueryParams.ContainsKey("Ids"))
{
criteria.Add(Restrictions.In("app.Id", context.GetQueryParam <string>("Ids").Split(',')));
}
context.TotalCount = criteria.SetProjection(Projections.Count("app.Id")).UniqueResult <int>();
if (context.TotalCount == 0)
{
return(new List <AppSetting>());
}
criteria.SetProjection(new IProjection[] { null });
criteria.SetResultTransformer(CriteriaSpecification.DistinctRootEntity);
return(criteria.SetFirstResult((context.Page - 1) * context.PageSize)
.SetMaxResults(context.PageSize)
.List <AppSetting>());
});
}
public object DoInTransaction(ITransactionStatus status)
{
Assert.IsTrue(TransactionSynchronizationManager.HasResource(sf), "Has thread session");
HibernateTemplate ht = new HibernateTemplate(sf);
return(ht.ExecuteFind(new ThrowExceptionHibernateCallback()));
}
public object DoInTransaction(ITransactionStatus status)
{
HibernateTemplate ht = new HibernateTemplate(sf);
ht.TemplateFlushMode = TemplateFlushMode.Eager;
return(ht.ExecuteFind(new RequiresNewTxCallbackInner(holder)));
}
public object DoInTransaction(ITransactionStatus status)
{
Assert.IsTrue(TransactionSynchronizationManager.HasResource(sessionFactory), "Has thread session");
HibernateTemplate ht = new HibernateTemplate(sessionFactory);
return(ht.ExecuteFind(new TransactionCommitWithFlushFailureHibernateCallback(list)));
}
/// <summary>
/// {@inheritDoc}
/// </summary>
///
/* @SuppressWarnings("unchecked")*/
public virtual IList <ValueSetEntry> SelectValueSetsByCode(
Type vocabularyDomainType, String code, String version, bool ignoreCase)
{
IList <ValueSetEntry> valueSets = (IList <ValueSetEntry>)HibernateTemplate.ExecuteFind(
new HibernateCodeSetDao.Anonymous_C12(code, vocabularyDomainType, version, ignoreCase));
return(valueSets);
}
public IList <City> GetCityByProvinceCode(string code)
{
return(HibernateTemplate.ExecuteFind <City>(x => {
var c = x.CreateCriteria <City>()
.Add(Expression.Eq("ProvinceCode", code));
HibernateTemplate.PrepareCriteria(c);
return c.List <City>();
}));
}
public IList <SupplierInfo> GetSupplierByName(string name)
{
return(HibernateTemplate.ExecuteFind <SupplierInfo>(x =>
{
var c = x.CreateCriteria <SupplierInfo>()
.Add(Restrictions.Like("SupplierName", "%" + name + "%"));
HibernateTemplate.PrepareCriteria(c);
return c.List <SupplierInfo>();
}));
}
public IList <ActionInfo> GetActionByPath(string path)
{
return(HibernateTemplate.ExecuteFind <ActionInfo>(x =>
{
var c = x.CreateCriteria <ActionInfo>()
.Add(Expression.Eq("UrlPath", path));
HibernateTemplate.PrepareCriteria(c);
return c.List <ActionInfo>();
}));
}
public IList <District> GetDistrictByCityCode(string code)
{
return(HibernateTemplate.ExecuteFind <District>(x =>
{
var c = x.CreateCriteria <District>()
.Add(Expression.Eq("CityCode", code));
HibernateTemplate.PrepareCriteria(c);
return c.List <District>();
}));
}
public IList <Province> GetAllProvince()
{
return(HibernateTemplate.ExecuteFind <Province>(x => {
var c = x.CreateCriteria <Province>()
.AddOrder(Order.Asc("OrderSort"))
.AddOrder(Order.Asc("PinYinNameAbbr"));
HibernateTemplate.PrepareCriteria(c);
return c.List <Province>();
}));
}
public IList <UserInfo> GetUserListByGroupId(int gid)
{
return(HibernateTemplate.ExecuteFind <UserInfo>(x =>
{
var c = x.CreateCriteria <UserInfo>()
.Add(Expression.Eq("GroupId", gid));
HibernateTemplate.PrepareCriteria(c);
return c.List <UserInfo>();
}));
}
/// <summary>
/// Sucht nach allen offenen Rechnungen
/// </summary>
/// <returns></returns>
public IList <Bill> FindUnsettledBills()
{
FindHibernateDelegate <Bill> finder = delegate(ISession session) {
ICriteria criteria = session.CreateCriteria(typeof(Bill));
criteria.Add(Restrictions.Eq("IsSettled", false));
return(criteria.List <Bill>());
};
return(HibernateTemplate.ExecuteFind(finder));
}
public object DoInTransaction(ITransactionStatus status)
{
Assert.IsTrue(!TransactionSynchronizationManager.HasResource(sf), "Hasn't thread session");
Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly);
Assert.IsFalse(TransactionSynchronizationManager.ActualTransactionActive);
HibernateTemplate ht = new HibernateTemplate(sf);
ht.TemplateFlushMode = TemplateFlushMode.Eager;
return(ht.ExecuteFind(new NotSupportedTxCallbackInner()));
}
/// <summary>
/// Liefert eine Liste mit allen Entitäten die entsprechend der Beschreibung sortiert sind.
/// </summary>
/// <param name="sort"></param>
/// <returns></returns>
public IList <T> GetAll(Sort sort)
{
FindHibernateDelegate <T> finder = delegate(ISession session) {
ICriteria criteria = session.CreateCriteria(typeof(T));
criteria = ApplySort(criteria, sort);
IList <T> results = criteria.List <T>();
return(results);
};
IList <T> resultObjects = HibernateTemplate.ExecuteFind(finder);
return(resultObjects);
}
public UserInfo GetUserByAdminId(int usid)
{
var result = HibernateTemplate.ExecuteFind <UserInfo>(x =>
{
var c = x.CreateCriteria <UserInfo>()
.Add(Expression.Eq("AdminUserId", usid));
HibernateTemplate.PrepareCriteria(c);
return(c.List <UserInfo>());
});
return(result.FirstOrDefault <UserInfo>());
}
/// <summary>
/// Liefert alle Nutzer welche die übergebenen Rollen haben.
/// </summary>
/// <param name="roles"></param>
/// <returns></returns>
public IList <User> FindByRole(params string[] roles)
{
FindHibernateDelegate <User> finder = delegate(ISession session) {
ICriteria criteria = session.CreateCriteria <User>();
ICriteria rolesCriteria = criteria.CreateCriteria(Objects.GetPropertyName <User>(user => user.Roles));
rolesCriteria.Add(Restrictions.In("elements", roles));
return(criteria.List <User>());
};
return(HibernateTemplate.ExecuteFind(finder));
}
public IList <ActionInfo> GetActionInfoByGroupIdOrUserId(int?gid, int?uid)
{
var sql = string.Empty;
if (!gid.HasValue && !uid.HasValue)
{
return(null);
}
else if (gid.HasValue && !uid.HasValue)
{
sql = @"select aci.* from actionInfo aci,AuthorityInfo aui
where aci.actionId=aui.actionId and aui.groupId=:groupId;";
return(HibernateTemplate.ExecuteFind <ActionInfo>(x => {
var q = x.CreateSQLQuery(sql);
HibernateTemplate.PrepareQuery(q);
return q.AddEntity(typeof(ActionInfo))
.SetInt32("groupId", gid.Value)
.List <ActionInfo>();
}));
}
else if (!gid.HasValue && uid.HasValue)
{
sql = @"select aci.* from actionInfo aci,AuthorityInfo aui
where aci.actionId=aui.actionId and aui.userId=:userId;";
return(HibernateTemplate.ExecuteFind <ActionInfo>(x =>
{
var q = x.CreateSQLQuery(sql);
HibernateTemplate.PrepareQuery(q);
return q.AddEntity(typeof(ActionInfo))
.SetInt32("userId", uid.Value)
.List <ActionInfo>();
}));
}
else
{
sql = @"select aci.* from actionInfo aci,AuthorityInfo aui
where aci.actionId=aui.actionId
and (aui.groupId=:groupId or aui.userId=:userId);";
return(HibernateTemplate.ExecuteFind <ActionInfo>(x =>
{
var q = x.CreateSQLQuery(sql);
HibernateTemplate.PrepareQuery(q);
return q.AddEntity(typeof(ActionInfo))
.SetInt32("groupId", gid.Value)
.SetInt32("userId", uid.Value)
.List <ActionInfo>();
}));
}
}
public bool RemoveAuthorityList(List <int> idList, int uid, int gid)
{
var authorityList = HibernateTemplate.ExecuteFind <AuthorityInfo>(x =>
{
var c = x.CreateCriteria <AuthorityInfo>()
.Add(Restrictions.And(Restrictions.In("ActionId", idList),
Restrictions.Or(Expression.Eq("UserId", uid), Expression.Eq("GroupId", gid))));
return(c.List <AuthorityInfo>());
});
foreach (var a in authorityList)
{
HibernateTemplate.Delete(a);
}
return(true);
}
public virtual List <DomainType> FindAllWithCustomQuery(string queryString,
NhibernateParameterCollection nhibernateQueryParams,
int firstRow, int maxRows)
{
if (string.IsNullOrEmpty(queryString))
{
throw new ArgumentNullException("queryString");
}
IList <DomainType> list = null;
try
{
list = HibernateTemplate.ExecuteFind <DomainType>(
delegate(ISession session)
{
IQuery query = session.CreateQuery(queryString);
if (nhibernateQueryParams != null && nhibernateQueryParams.Count > 0)
{
foreach (NhibernateParameter param in nhibernateQueryParams)
{
query.SetParameter(param.ParameterName, param.Value, param.DbType);
}
}
if (firstRow != int.MinValue)
{
query.SetFirstResult(firstRow);
}
if (maxRows != int.MinValue)
{
query.SetMaxResults(maxRows);
}
return(query.List <DomainType>());
});
}
catch (Exception ex)
{
logger.Error(ex.Message);
throw new DataException("Could not perform FindAllWithCustomQuery for " + typeof(DomainType).Name, ex);
}
return(ConvertToTypedList(list));
}
public IList <SupplierInfo> SearchSupplier(string keyWord, int pageStart, int pageLimit, out int total)
{
var _total = 0;
var supplierList = HibernateTemplate.ExecuteFind <SupplierInfo>(x =>
{
var c = x.CreateCriteria <SupplierInfo>()
.Add(Restrictions.Like("Name", "%" + keyWord + "%"));
_total = c.List().Count;
c.SetFirstResult(pageStart)
.SetMaxResults(pageLimit);
HibernateTemplate.PrepareCriteria(c);
return(c.List <SupplierInfo>());
});
total = _total;
return(supplierList);
}
public IList <SupplierInfo> GetAllSupplierList(int pageStart, int pageLimit, out int total)
{
var _total = 0;
HibernateTemplate.CacheQueries = false;
var supplierList = HibernateTemplate.ExecuteFind <SupplierInfo>(x =>
{
var c = x.CreateCriteria <SupplierInfo>();
_total = c.List().Count;
c.SetFirstResult(pageStart)
.SetMaxResults(pageLimit);
HibernateTemplate.PrepareCriteria(c);
return(c.List <SupplierInfo>());
});
total = _total;
return(supplierList);
}
public IList <T> GetEntityList <T>(IEnumerable <ICriterion> criterions, IEnumerable <Order> orders, int firstIndex = 0, int maxCount = int.MaxValue, bool useSecondLevelCache = true)
{
if (!useSecondLevelCache)
{
HibernateTemplate.CacheQueries = false;
}
return(HibernateTemplate.ExecuteFind(session =>
{
// Create Entity Criteria
var criteria = session.CreateCriteria(typeof(T));
// Set criterions
if (criterions != null && criterions.Any())
{
foreach (var criterion in criterions)
{
criteria.Add(criterion);
}
}
// Set orders
if (orders != null && orders.Any())
{
foreach (var order in orders)
{
criteria.AddOrder(order);
}
}
// Set range
criteria.SetFirstResult(firstIndex);
criteria.SetMaxResults(maxCount);
HibernateTemplate.PrepareCriteria(criteria);
return criteria.List <T>();
}));
}
/// <summary>
/// {@inheritDoc}
/// </summary>
///
/* @SuppressWarnings("unchecked")*/
public virtual IList <ValueSetEntry> SelectValueSetsByVocabularyDomain(
String domainName, String version)
{
return((IList <ValueSetEntry>)HibernateTemplate.ExecuteFind(new HibernateCodeSetDao.Anonymous_C8(domainName, version)));
}
public virtual IList <TDomain> FindByExample(TDomain domain)
{
FindByExampleCallback <TDomain> findByExampleCallback = new FindByExampleCallback <TDomain>(domain, findByExampleDescriptor);
return(HibernateTemplate.ExecuteFind <TDomain>(findByExampleCallback));
}
public virtual List <DomainType> FindAll(ICriterion[] criterias, Order[] sortItems, int firstRow, int maxRows,
string filterName, string cacheRegionName, out int recordCount)
{
int outRecordCount = 0;
try
{
IList <DomainType> list = HibernateTemplate.ExecuteFind <DomainType>(
delegate(ISession session)
{
//如果有filter打开
if (!string.IsNullOrEmpty(filterName))
{
session.EnableFilter(filterName);
}
//查询l当前页记录的ICriteria
ICriteria criteria = session.CreateCriteria(typeof(DomainType));
//查询记录总数的ICriteria
ICriteria criteriaCount = session.CreateCriteria(typeof(DomainType));
//加载查询条件
if (criterias != null)
{
foreach (ICriterion cond in criterias)
{
criteria.Add(cond);
criteriaCount.Add(cond);
}
}
//加载排序条件
if (sortItems != null)
{
foreach (Order order in sortItems)
{
//查询记录总数的ICriteria不需要加载排序条件
criteria.AddOrder(order);
}
}
//打开缓存
if (!string.IsNullOrEmpty(cacheRegionName))
{
criteria.SetCacheable(true);
criteria.SetCacheRegion(cacheRegionName);
}
//投影查询获取记录总数
criteriaCount.SetProjection(Projections.RowCount());
outRecordCount = criteriaCount.SetMaxResults(1).UniqueResult <int>();
//设置分页查询
if (firstRow != int.MinValue)
{
criteria.SetFirstResult(firstRow);
}
if (maxRows != int.MinValue)
{
criteria.SetMaxResults(maxRows);
}
//获取当前页记录数
IList <DomainType> result = criteria.List <DomainType>();
if (result.Count > outRecordCount)
{
throw new Exception("Query Count Error!");
}
//关闭缓存
if (!string.IsNullOrEmpty(cacheRegionName))
{
criteria.SetCacheable(false);
}
//如果有filter关闭
if (!string.IsNullOrEmpty(filterName))
{
session.DisableFilter(filterName);
}
return(result);
})
;
recordCount = outRecordCount;
return(ConvertToTypedList(list));
}
catch (Exception ex)
{
this.Logger.Error(ex.Message);
throw new DataException("Could not perform FindAll for " + typeof(DomainType).Name, ex);
}
}
public IList <TDomain> FindByCriteria(QueryPartCollector queryPartCollector)
{
FindByCriteriaCallback <TDomain> findByCriteriaCallback = new FindByCriteriaCallback <TDomain>(baseHqlCreator, queryPartCollector);
return(HibernateTemplate.ExecuteFind <TDomain>(findByCriteriaCallback));
}
/// <summary>
/// {@inheritDoc}
/// </summary>
///
/* @SuppressWarnings("unchecked")*/
public virtual IList <VocabularyDomain> SelectAllVocabularyDomains()
{
return((IList <VocabularyDomain>)HibernateTemplate.ExecuteFind(new HibernateCodeSetDao.Anonymous_C10()));
}
/// <summary>
/// {@inheritDoc}
/// </summary>
///
/* @SuppressWarnings("unchecked")*/
public virtual IList <ValueSet> SelectValueSetsByVersion(
String version)
{
return((IList <ValueSet>)HibernateTemplate.ExecuteFind(new HibernateCodeSetDao.Anonymous_C13(version)));
}
/// <summary>
/// {@inheritDoc}
/// </summary>
///
/* @SuppressWarnings("unchecked")*/
public virtual IList <CodeSystem> FindCodeSystems(
CodeSystemSearchCriteria searchCriteria, int startRow,
int endRow)
{
return((IList <CodeSystem>)HibernateTemplate.ExecuteFind(new HibernateCodeSetDao.Anonymous_C5(this, searchCriteria, startRow, endRow)));
}
