/// <summary>
/// Ruft Seitenweise die beantragten Nutzer der Plattform ab.
/// </summary>
/// <param name="pageable">Informationen über aufzurufende Seite und Seitengröße</param>
/// <param name="searchTerm"></param>
/// <returns></returns>
public IPage <ProposedUser> FindProposedUser(IPageable pageable, string searchTerm)
{
Require.NotNull(pageable, "pageable");
Action <ICriteria> criterionsDelegate = delegate(ICriteria criteria) {
if (!string.IsNullOrEmpty(searchTerm))
{
/*Die Prüfung ob die Properties die Suchzeichenfolge enthalten per Oder verknüpfen*/
Disjunction orCriterias = new Disjunction();
orCriterias.Add(Restrictions.Like(Objects.GetPropertyName <ProposedUser>(user => user.UserName),
searchTerm,
MatchMode.Anywhere));
orCriterias.Add(Restrictions.Like(Objects.GetPropertyName <ProposedUser>(user => user.Email),
searchTerm,
MatchMode.Anywhere));
orCriterias.Add(Restrictions.Like(Objects.GetPropertyName <ProposedUser>(user => user.FirstName),
searchTerm,
MatchMode.Anywhere));
orCriterias.Add(Restrictions.Like(Objects.GetPropertyName <ProposedUser>(user => user.LastName),
searchTerm,
MatchMode.Anywhere));
criteria.Add(orCriterias);
}
};
/*Sortierung hinzufügen*/
Action <ICriteria> ordersDelegate = delegate(ICriteria criteria) {
criteria.AddOrder(Order.Asc("LastName"));
criteria.AddOrder(Order.Asc("FirstName"));
};
return(Find(pageable, criterionsDelegate, ordersDelegate));
}
private void FilterContentPublishedCriteria(ICriteria crit, ContentCategory cc, ContentType ct)
{
crit.Add(Expression.Eq("Category", cc));
crit.Add(Expression.Eq("Type", ct));
crit.Add(Expression.Eq("Status", ContentPublishedStatus.Enabled));
Conjunction c1 = new Conjunction();
c1.Add(Expression.Ge("ScheduleFrom", DateTime.Today));
c1.Add(Expression.IsNull("ScheduleTo"));
Conjunction c2 = new Conjunction();
c2.Add(Expression.IsNull("ScheduleFrom"));
c2.Add(Expression.IsNull("ScheduleTo"));
Conjunction c3 = new Conjunction();
c3.Add(Expression.Ge("ScheduleFrom", DateTime.Today));
c3.Add(Expression.Le("ScheduleTo", DateTime.Today));
Disjunction d = new Disjunction();
d.Add(c1);
d.Add(c2);
d.Add(c3);
crit.Add(d);
crit.AddOrder(new Order("CreatedOn", false));
crit.AddOrder(new Order("ScheduleFrom", false));
}
public List <Student> Search(StudentSearchCriteria criteria)
{
var students = session.QueryOver <Student>();
if (!String.IsNullOrEmpty(criteria.PartialName))
{
string pn = String.Format("%{0}%", criteria.PartialName.Substring(0, Math.Min(50, criteria.PartialName.Length)));
Disjunction disjunction = new Disjunction();
disjunction.Add(Restrictions.On <Student>(e => e.FirstName).IsLike(pn));
disjunction.Add(Restrictions.On <Student>(e => e.LastName).IsLike(pn));
students = students.Where(disjunction);
}
if (criteria.Id.HasValue)
{
students = students.Where(x => x.Id == criteria.Id);
}
if (criteria.MathGeniusId.HasValue)
{
students = students.Where(x => x.MathGeniusId == criteria.MathGeniusId);
}
if (criteria.GraduationYear.HasValue)
{
students = students.Where(x => x.GraduationYear == criteria.GraduationYear);
}
return(students.List <Student>().ToList());
}
public IList <Friend> Search(RegisteredUser user, string friend, FriendStatus status, int limit)
{
ICriteria crit = NHibernateSession.Current.CreateCriteria(typeof(Friend));
crit.SetFetchMode("User", FetchMode.Join);
crit.Add(Restrictions.Eq("BasicUser.Id", user.Id));
crit.Add(Expression.Not(Expression.Eq("Status", FriendStatus.Denied)));
if (status != FriendStatus.All)
{
crit.Add(Expression.Eq("Status", status));
}
Disjunction d = new Disjunction();
if (!string.IsNullOrEmpty(friend))
{
ICriteria critUser = crit.CreateCriteria("User");
d.Add(Expression.Like("FirstName", friend, MatchMode.Anywhere));
d.Add(Expression.Like("LastName", friend, MatchMode.Anywhere));
d.Add(Expression.Like("EmailAddress", friend, MatchMode.Anywhere));
critUser.Add(d);
}
if (limit > 0)
{
crit.SetMaxResults(limit);
}
return(crit.List <Friend>());
}
public IList <TransactionHistoryWeekly> GetInfo(int productID, int week, int year, int period)
{
ICriteria crit = GetCriteria();
crit.Add(Expression.Eq("ProductID", new Product(productID)));
int weekDif = (week - period);
if (weekDif <= 0)
{
Disjunction dis = new Disjunction();
dis.Add(new AndExpression(new BetweenExpression("Week", 52 + weekDif, 52), new EqExpression("Year", year - 1)));
dis.Add(new AndExpression(new BetweenExpression("Week", 1, week), new EqExpression("Year", year)));
crit.Add(dis);
}
else
{
crit.Add(new AndExpression(new BetweenExpression("Week", week - period, week), new EqExpression("Year", year)));
}
crit.AddOrder(new Order("Year", false));
crit.AddOrder(new Order("Week", false));
return(crit.List <TransactionHistoryWeekly>());
}
public IList <Campaign> GetActive(string applicationName, bool onlyFixed)
{
ICriteria crit = GetCriteria( );
// Check Schedule Range
Conjunction range = new Conjunction();
range.Add(Expression.Le("StartDate", DateTime.Today));
range.Add(Expression.Ge("EndDate", DateTime.Today));
// If EndDate is null, avoid range check
Disjunction nullDate = new Disjunction( );
nullDate.Add(new NullExpression("EndDate"));
nullDate.Add(range);
// Apply filters
crit.AddOrder(new Order("StartDate", false))
.Add(Expression.Eq("Status", CampaignStatus.Enabled))
.Add(Expression.Eq("ApplicationName", applicationName))
.Add(nullDate);
// If fixed only, check dynamic code is null
if (onlyFixed)
{
crit.Add(new NullExpression("DynamicCode"));
}
return(crit.List <Campaign>( ));
}
public ICriteria SearchCriteria(string info, DateTime?fromDate, DateTime?toDate, ImportStatus?status)
{
ICriteria crit = GetCriteria();
if (!string.IsNullOrEmpty(info))
{
Disjunction d = new Disjunction();
d.Add(Restrictions.InsensitiveLike("Description", info, MatchMode.Anywhere));
d.Add(Restrictions.InsensitiveLike("File", info, MatchMode.Anywhere));
crit.Add(d);
}
if (fromDate != null)
{
crit.Add(Expression.Ge("DateImported", fromDate));
}
if (toDate != null)
{
crit.Add(Expression.Le("DateImported", toDate));
}
if (status != null)
{
crit.Add(Expression.Eq("ImportStatus", status));
}
return(crit);
}
private ICriteria ListSearchCriteria(string search, Type type, CategoryBase parent)
{
ICriteria crit = GetCriteria();
if (type != null)
{
crit = NHibernateSession.CreateCriteria(type);
}
if (!string.IsNullOrEmpty(search))
{
Disjunction d = new Disjunction();
d.Add(Expression.InsensitiveLike("Name", search, MatchMode.Anywhere));
d.Add(Expression.InsensitiveLike("Description", search, MatchMode.Anywhere));
d.Add(Expression.InsensitiveLike("NameEnglish", search, MatchMode.Anywhere));
d.Add(Expression.InsensitiveLike("DescripionEnglish", search, MatchMode.Anywhere));
crit.Add(d);
}
if (parent != null)
{
crit.Add(Expression.Eq("Parent", parent));
}
return(crit);
}
private ICriteria ListLevelOnePagesCriteria(string search, CatalogPage parent, CategoryPageStatus?status)
{
ICriteria crit = GetCriteria();
if (!string.IsNullOrEmpty(search))
{
Disjunction d = new Disjunction();
d.Add(Expression.InsensitiveLike("Name", search, MatchMode.Anywhere));
d.Add(Expression.InsensitiveLike("Description", search, MatchMode.Anywhere));
d.Add(Expression.InsensitiveLike("NameEnglish", search, MatchMode.Anywhere));
d.Add(Expression.InsensitiveLike("DescripionEnglish", search, MatchMode.Anywhere));
crit.Add(d);
}
if (parent != null)
{
crit.Add(Expression.Eq("Parent", parent));
}
if (status != null)
{
crit.Add(Expression.Eq("CategoryPageStatus", status));
}
DetachedCriteria levelOneCriteria = DetachedCriteria.For <CatalogPage>().SetProjection(Projections.Property("ID"))
.Add(Expression.IsNull("Parent"));
ICriterion levelOneSubquery = Subqueries.PropertyIn("Parent", levelOneCriteria);
crit.Add(levelOneSubquery);
return(crit);
}
public IList <TransactionHistoryWeekly> GetSalesTotal(Product productID, int week, int year)
{
List <TransactionHistoryWeekly> info = new List <TransactionHistoryWeekly>();
for (int interval = 4; interval <= 52;)
{
ICriteria crit = GetCriteria();
crit.Add(Expression.Eq("ProductID", productID));
int weekDif = (week - interval);
if (weekDif <= 0)
{
Disjunction dis = new Disjunction();
dis.Add(new AndExpression(new BetweenExpression("Week", 52 + weekDif, 52), new EqExpression("Year", year - 1)));
dis.Add(new AndExpression(new BetweenExpression("Week", 1, week), new EqExpression("Year", year)));
crit.Add(dis);
}
else
{
crit.Add(new AndExpression(new BetweenExpression("Week", week - interval, week), new EqExpression("Year", year)));
}
crit.SetProjection(Projections.ProjectionList()
.Add(Projections.Sum("Sale"))
.Add(Projections.GroupProperty("ProductID"))
);
crit.SetResultTransformer(new NHibernate.Transform.AliasToBeanConstructorResultTransformer(typeof(TransactionHistoryWeekly).GetConstructors()[1]));
TransactionHistoryWeekly res = crit.UniqueResult <TransactionHistoryWeekly>();
if (res == null)
{
res = new TransactionHistoryWeekly();
res.Sale = 0;
}
info.Add(res);
switch (interval)
{
case 4:
interval = 13;
break;
case 13:
interval = 26;
break;
case 26:
interval = 52;
break;
case 52:
interval = 60;
break;
}
}
return(info);
}
internal override WalkedToken Walk(WalkedToken left, WalkedToken right)
{
Disjunction crit = new Disjunction();
crit.Add(left.Criterion);
crit.Add(right.Criterion);
return WalkedToken.FromCriterion(crit);
}
internal override WalkedToken Walk(WalkedToken left, WalkedToken right)
{
Disjunction crit = new Disjunction();
crit.Add(left.Criterion);
crit.Add(right.Criterion);
return(WalkedToken.FromCriterion(crit));
}
public List <ProductStatisticWeekly> CalculateStatistic(int week, int year, Period period)
{
int interval = 0;
if (Convert.ToInt32(period) == 1)
{
interval = 4;
}
else if (Convert.ToInt32(period) == 2)
{
interval = 8;
}
else if (Convert.ToInt32(period) == 3)
{
interval = 13;
}
else if (Convert.ToInt32(period) == 4)
{
interval = 26;
}
else if (Convert.ToInt32(period) == 5)
{
interval = 53;
}
ICriteria crit = GetCriteria();
int weekDif = (week - interval);
if (weekDif <= 0)
{
Disjunction dis = new Disjunction();
dis.Add(
new AndExpression(new BetweenExpression("Week", 53 + weekDif, 53),
new EqExpression("Year", year - 1)));
dis.Add(new AndExpression(new BetweenExpression("Week", 1, week), new EqExpression("Year", year)));
crit.Add(dis);
}
else
{
crit.Add(
new AndExpression(new BetweenExpression("Week", week - interval, week),
new EqExpression("Year", year)));
}
crit.SetProjection(Projections.ProjectionList()
.Add(Projections.Avg("Purchase"))
.Add(Projections.Avg("Sale"))
.Add(Projections.GroupProperty("ProductID"))
);
crit.SetResultTransformer(
new AliasToBeanConstructorResultTransformer(typeof(ProductStatisticWeekly).GetConstructors()[1]));
return(crit.List <ProductStatisticWeekly>() as List <ProductStatisticWeekly>);
}
private ICriteria GetDistributorsCriteria(string name, Country country, PriceList priceList,
Lookup paymentTerm, DistributorStatus? status,
GridState gridState, Incoterm? saleCondition, Lookup type, CatalogPage page, IList priceListIds, bool isActive)
{
ICriteria crit = GetCriteria();
if (priceListIds != null)
{
int[] intPriceListIds = new int[priceListIds.Count];
for (int i = 0; i < priceListIds.Count; i++)
intPriceListIds[i] = Convert.ToInt32(priceListIds[i]);
ICriteria critDistributor = crit.CreateCriteria("PriceList");
critDistributor.Add(Expression.In("ID", intPriceListIds));
}
if (!string.IsNullOrEmpty(name))
{
Disjunction d = new Disjunction();
d.Add(Expression.InsensitiveLike("Name", name, MatchMode.Anywhere));
d.Add(Expression.InsensitiveLike("Code", name, MatchMode.Anywhere));
crit.Add(d);
}
if (country != null)
{
ICriteria critCountry = crit.CreateCriteria("Country");
critCountry.Add(Expression.Eq("ID", country.ID));
}
if (priceList != null)
{
ICriteria critPriceList = crit.CreateCriteria("PriceList");
critPriceList.Add(Expression.Eq("ID", priceList.ID));
}
if (paymentTerm != null)
crit.Add(Expression.Eq("PaymentTerm", paymentTerm));
if (status != null)
crit.Add(Expression.Eq("DistributorStatus", status));
else
if (isActive == false)
crit.Add(Expression.Eq("DistributorStatus", DistributorStatus.Active));
if (saleCondition != null)
crit.Add(Expression.Eq("SaleConditions", saleCondition));
if (type != null)
crit.Add(Expression.Eq("Type", type));
if (page != null)
crit.CreateCriteria("PriceList").CreateCriteria("CategoryPages").Add(Expression.Eq("ID", page.ID));
return crit;
}
public IList <CatalogPage> GetPagesByFilters(GridState gridState, IList <Filters.IFilter> filters)
{
ICriteria crit = GetCriteria();
MasterPriceSearchParameters mpsp = FilterHelper.GetSearchFilters(filters);
if (!string.IsNullOrEmpty(mpsp.Description))
{
Disjunction d = new Disjunction();
d.Add(Restrictions.InsensitiveLike("Description", mpsp.Description, MatchMode.Anywhere));
d.Add(Restrictions.InsensitiveLike("DescriptionAlternative", mpsp.Description, MatchMode.Anywhere));
d.Add(Restrictions.InsensitiveLike("Name", mpsp.Description, MatchMode.Anywhere));
d.Add(Restrictions.InsensitiveLike("NameAlternative", mpsp.Description, MatchMode.Anywhere));
crit.Add(d);
}
if (mpsp.CatalogPage != null)
{
crit.Add(Expression.Eq("Parent", mpsp.CatalogPage));
}
if (mpsp.CategoryPageStatus != null)
{
crit.Add(Expression.Eq("CategoryPageStatus", mpsp.CategoryPageStatus));
}
DetachedCriteria levelOneCriteria = DetachedCriteria.For <CatalogPage>().SetProjection(Projections.Property("ID"))
.Add(Expression.IsNull("Parent"));
ICriterion levelOneSubquery = Subqueries.PropertyIn("Parent", levelOneCriteria);
crit.Add(levelOneSubquery);
string[] sort = gridState.SortField.Split('.');
ICriteria critSort = crit;
string sortField = gridState.SortField;
if (!sortField.Contains("TimeStamp") && sort.Length > 1)
{
critSort = crit.GetCriteriaByPath(sort[0]);
if (critSort == null)
{
critSort = crit.CreateCriteria(sort[0]);
}
sortField = sort[1];
}
critSort.AddOrder(new Order(sortField, gridState.SortAscending));
if (!gridState.MarkedAll)
{
crit.Add(Expression.In("ID", gridState.Items));
}
return(crit.List <CatalogPage>());
}
public IDictionary <string, IList <Entity_Student> > filteredStudentList(MyCriteria notifyCriteria)
{
Utility.logFile(Constant.METHOD_ENTER + Utility.getCurrentMethodName(1) + "(NotificationManagerImpl)", null, Constant.LOGTYPE_INFO);
DetachedCriteria mainCriteria = DetachedCriteria.For <Entity_Student>("student");
mainCriteria.CreateAlias("scoreObj", "score");
Conjunction conjunction = Restrictions.Conjunction();
conjunction.Add(Restrictions.Eq("student.myConfigObj.currentBatch", notifyCriteria.batch));
conjunction.Add(Restrictions.Eq("student.myConfigObj.currentDegree", notifyCriteria.degree));
conjunction.Add(Restrictions.Ge("score.X", notifyCriteria.X));
conjunction.Add(Restrictions.Ge("score.cgpa", notifyCriteria.cgpa));
conjunction.Add(Restrictions.Le("score.arrears", notifyCriteria.arrears));
conjunction.Add(Restrictions.In("student.branch", notifyCriteria.branch));
if (notifyCriteria.isDiplomaAllowed)
{
Disjunction disjunction = Restrictions.Disjunction();
disjunction.Add(Restrictions.Ge("score.XII", notifyCriteria.XII));
disjunction.Add(Restrictions.Ge("score. ", notifyCriteria.XII));
conjunction.Add(disjunction);
}
else
{
conjunction.Add(Restrictions.Ge("score.XII", notifyCriteria.XII));
}
mainCriteria.Add(conjunction);
if (!notifyCriteria.isPlaced)
{
DetachedCriteria subCriteria = DetachedCriteria.For <Entity_PlacementDetails>("placedObj");
subCriteria.Add(Restrictions.EqProperty("placedObj.studentId", "student.studentId"));
subCriteria.SetProjection(Projections.Distinct(Projections.Property("placedObj.studentId")));
mainCriteria.Add(Subqueries.NotExists(subCriteria));
}
IList list = persistence.findByCriteria(mainCriteria);
if (list != null && list.Count > 0)
{
IDictionary <string, IList <Entity_Student> > eligibleStudentMap = prepareStudentList(list.Cast <Entity_Student>().ToList());
return(eligibleStudentMap);
}
else
{
return(null);
}
}
public IList <OutfitUpdater> GetOnly(params OutfitUpdaterStatus[] status)
{
ICriteria crit = Session.CreateCriteria(typeof(OutfitUpdater));
Disjunction d = new Disjunction();
foreach (OutfitUpdaterStatus ous in status)
{
d.Add(Expression.Eq("Status", ous));
}
crit.Add(d);
// Fetch everything we can to avoid select on the loops.
crit.SetFetchMode("Silouhette", FetchMode.Join);
crit.SetFetchMode("Silouhette.Structure", FetchMode.Join);
crit.SetFetchMode("Silouhette.Shape", FetchMode.Join);
crit.SetFetchMode("ColorFamily", FetchMode.Join);
crit.SetFetchMode("ColorFamily.AnalogousFamily", FetchMode.Join);
crit.SetFetchMode("ColorFamily.AnalogousFamily2", FetchMode.Join);
crit.SetFetchMode("ColorFamily.ComplimentaryFamily", FetchMode.Join);
crit.SetFetchMode("Pattern", FetchMode.Join);
return(crit.List <OutfitUpdater>());
}
/// <summary>
/// Gets the authorization strategy's NHibernate filter definitions and a functional delegate for determining when to apply them.
/// </summary>
/// <returns>A read-only list of filter application details to be applied to the NHibernate configuration and mappings.</returns>
public IReadOnlyList <FilterApplicationDetails> GetFilters()
{
var filters = new List <FilterApplicationDetails>
{
new FilterApplicationDetails(
"Namespace",
@"(Namespace IS NOT NULL AND Namespace LIKE :Namespace)",
@"({currentAlias}.Namespace IS NOT NULL AND {currentAlias}.Namespace LIKE :Namespace)",
(c, w, p, jt) =>
{
// Ensure the Namespace parameter is represented as an object array
var namespacePrefixes = p["Namespace"] as object[] ?? new [] { p["Namespace"] };
// Combine the namespace filters using OR (only one must match to grant authorization)
var namespacesDisjunction = new Disjunction();
foreach (var namespacePrefix in namespacePrefixes)
{
namespacesDisjunction.Add(Restrictions.Like("Namespace", namespacePrefix));
}
// Add the final namespaces criteria to the supplied WHERE clause (junction)
w.Add(
new AndExpression(
Restrictions.IsNotNull("Namespace"),
namespacesDisjunction));
},
(t, p) => !DescriptorEntitySpecification.IsEdFiDescriptorEntity(t) && p.HasPropertyNamed("Namespace")),
}.AsReadOnly();
return(filters);
}
public IList GetAuthConfigByOperationJobID(string sOperationJobID, string sRootMenuCode)
{
IList lstAuthConfig = null;
Menus oRootMenus = GetMenus(sRootMenuCode);
ObjectQuery oq = new ObjectQuery();
if (!string.IsNullOrEmpty(sOperationJobID))
{
List <string> roleIdLst = GetRoleIdByJobId(sOperationJobID);
if (roleIdLst == null || roleIdLst.Count == 0)
{
return(new ArrayList());
}
Disjunction dis = Expression.Disjunction();
foreach (string id in roleIdLst)
{
dis.Add(Expression.Eq("Roles.Id", id));
}
oq.AddCriterion(dis);
}
string IdCode = oRootMenus == null ? "%" : oRootMenus.Id + "%";
oq.AddCriterion(Expression.Like("Menus.IdCode", IdCode));
oq.AddOrder(Order.Asc("Menus.Level"));
oq.AddOrder(Order.Asc("Menus.Serial"));
lstAuthConfig = GetAuthConfig(oq);
return(lstAuthConfig);
}
protected void btnDelete_Click(object sender, EventArgs e)
{
try
{
string[] idlst = txtIdListHidden.Value.Split(new char[] { '|' });
ObjectQuery oq = new ObjectQuery();
Disjunction dis = new Disjunction();
foreach (string id in idlst)
{
dis.Add(Expression.Eq("Id", id));
}
oq.AddCriterion(dis);
IList <PaymentOrderDetial> list = model.QueryDetial(oq);
if (model.Delete(list as IList))
{
UtilClass.MessageBox(this, "删除成功！");
GridViewSource1.GetData();
SumMoney();
Clear();
}
else
{
UtilClass.MessageBox(this, "删除失败！");
}
}
catch (Exception)
{
UtilClass.MessageBox(this, "操作失误，请重试！");
}
}
public IList <HandHistory> GetGames(IEnumerable <long> gameNumbers, short pokersiteId)
{
var handHistoryParserFactory = ServiceLocator.Current.GetInstance <IHandHistoryParserFactory>();
var handHistoryParser = handHistoryParserFactory.GetFullHandHistoryParser((EnumPokerSites)pokersiteId);
using (var session = ModelEntities.OpenSession())
{
List <HandHistory> historyList = new List <HandHistory>();
Disjunction restriction = Restrictions.Disjunction();
restriction.Add(Restrictions.Conjunction()
.Add(Restrictions.On <Handhistory>(x => x.Gamenumber).IsIn(gameNumbers.ToList()))
.Add(Restrictions.Where <Handhistory>(x => x.PokersiteId == pokersiteId)));
var list = session.QueryOver <Handhistory>()
.Where(restriction)
.List();
foreach (var history in list)
{
var result = handHistoryParser.ParseFullHandHistory(history.HandhistoryVal);
if (result == null)
{
continue;
}
historyList.Add(result);
}
return(historyList);
}
}
protected override Expression VisitTypeIs(TypeBinaryExpression expr)
{
var visitor = new MemberNameVisitor(rootCriteria);
visitor.Visit(expr);
string memberName = visitor.MemberName + ".class";
var metaData = session.SessionFactory.GetClassMetadata(expr.TypeOperand);
if (metaData.HasSubclasses)
{
//make sure to include any subtypes
var disjunction = new Disjunction();
foreach (string entityName in ((IEntityPersister)metaData).EntityMetamodel.SubclassEntityNames)
{
var metadata = session.SessionFactory.GetClassMetadata(entityName);
disjunction.Add(Property.ForName(memberName).Eq(metadata.GetMappedClass(EntityMode.Poco)));
}
visitor.CurrentCriteria.Add(disjunction);
}
else
{
visitor.CurrentCriteria.Add(Property.ForName(memberName).Eq(expr.TypeOperand));
}
return(expr);
}
public List <Entity_Student> loadStudentDetailsBySearchKey(string searchKey)
{
Utility.logFile(Constant.METHOD_ENTER + Utility.getCurrentMethodName(1) + "(StudentManagerImpl)", null, Constant.LOGTYPE_INFO);
DetachedCriteria criteria = DetachedCriteria.For <Entity_Student>();
criteria.CreateAlias("placedDetailsObj", "list", NHibernate.SqlCommand.JoinType.LeftOuterJoin);
criteria.Add(Restrictions.Eq("myConfigObj.currentBatch", Common.loggedUser.myConfigObj.currentBatch));
criteria.Add(Restrictions.Eq("myConfigObj.currentDegree", Common.loggedUser.myConfigObj.currentDegree));
Disjunction disjunction = Restrictions.Disjunction();
disjunction.Add(Restrictions.InsensitiveLike("collegeId", searchKey, MatchMode.Exact));
criteria.Add(disjunction);
criteria.AddOrder(Order.Asc("collegeId"));
IList resultList = persistence.findByCriteria(criteria);
if (resultList != null && resultList.Count > 0)
{
return(resultList.Cast <Entity_Student>().Distinct().ToList());
}
else
{
return(null);
}
}
/// <summary>
/// Возвращает все блоки, у которых заголовок содержит строку или код начинается на строку.
/// </summary>
public static Func <string, IEnumerable <IcdBlock> > BlockStartingWith(ISession session)
{
return((str) =>
{
using (var tr = session.BeginTransaction())
{
var q = session.QueryOver <IcdBlock>();
var disjunction = new Disjunction();
disjunction.Add(Restrictions.On <IcdBlock>(d => d.Title).IsInsensitiveLike(str, MatchMode.Anywhere));
disjunction.Add(Restrictions.On <IcdBlock>(d => d.Code).IsInsensitiveLike(str, MatchMode.Start));
return q.Where(disjunction).List();
}
});
}
public bool UpdatePlayer(PlayerPatchDto dto, Guid id)
{
var player = Session.Get <PlayerModel>(id);
if (player == null)
{
return(false);
}
var groupDisjunction = new Disjunction();
foreach (var groupName in dto.GroupNames)
{
groupDisjunction.Add(Restrictions.InsensitiveLike(Projections.Property <GroupModel>(p => p.Players), dto.GroupNames));
}
var groups = Session.QueryOver <GroupModel>()
.Where(groupDisjunction).Future().ToList();
using (var transaction = Session.BeginTransaction())
{
player.FirstName = dto.FirstName;
player.LastName = dto.LastName;
player.Email = dto.Email;
player.Rating = dto.Rating;
player.IsActive = dto.IsActive;
player.Groups = groups;
Session.Update(player);
transaction.Commit();
}
return(true);
}
private ICriteria ListCriteria(string text, Distributor distributor, QuoteStatus?status, Guid?userId)
{
ICriteria crit = GetCriteria();
//check quote permissions
ExecutePermissionValidator epv = new ExecutePermissionValidator();
epv.ClassType = typeof(Quote);
epv.KeyIdentifier = Config.SeeQuotes;
if (PermissionManager.Check(epv) == false)
{
IList quoteIds = PermissionManager.GetPermissionIdentifiers(typeof(Quote), PermissionAction.Create);
int[] intQuoteIds = new int[quoteIds.Count];
for (int i = 0; i < quoteIds.Count; i++)
{
intQuoteIds[i] = Convert.ToInt32(quoteIds[i]);
}
crit.Add(Expression.In("ID", intQuoteIds));
}
if (!string.IsNullOrEmpty(text))
{
Disjunction d = new Disjunction();
d.Add(Restrictions.InsensitiveLike("Description", text, MatchMode.Anywhere));
d.Add(Restrictions.InsensitiveLike("Observations", text, MatchMode.Anywhere));
d.Add(Expression.InsensitiveLike("Number", text, MatchMode.Anywhere));
crit.Add(d);
}
if (distributor != null)
{
crit.Add(Expression.Eq("Distributor", distributor));
}
if (status != null)
{
crit.Add(Expression.Eq("Status", status));
}
if (userId.HasValue)
{
crit.Add(Expression.Eq("TimeStamp.ModifiedBy", userId));
}
return(crit);
}
/// <summary>
/// </summary>
/// <param name="owner"></param>
/// <param name="relative"></param>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public IList <PersonalMessage> GetChat(User owner, User relative, DateTime?lastGetLastTime, int pageIndex,
int pageSize)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
if (relative == null)
{
throw new ArgumentNullException("relative");
}
IProjection receiverProperty = ReceiverProperty;
IProjection publisherProperty = PublisherProperty;
IProjection deleteProperty = CreateDeleteStatus;
var receive = new Disjunction();
receive.Add(
(new Conjunction())
.Add(Restrictions.Eq(receiverProperty, owner))
.Add(Restrictions.Not(Restrictions.Eq(deleteProperty, PersonalMessageStatus.Receiver)))
);
receive.Add(Restrictions.Eq(receiverProperty, relative));
var publisher = new Disjunction();
publisher.Add(
(new Conjunction()).Add(Restrictions.Eq(publisherProperty, owner))
.Add(Restrictions.Not(Restrictions.Eq(deleteProperty, PersonalMessageStatus.Publisher)))
);
publisher.Add(Restrictions.Eq(publisherProperty, relative));
DetachedCriteria deach = CreateDetachedCriteria()
.Add(receive)
.Add(publisher);
if (lastGetLastTime != null)
{
deach.Add(Restrictions.Gt(CreateTimeProperty, lastGetLastTime.Value));
}
return
(deach.SetMaxResults(pageSize).SetFirstResult(pageIndex * pageSize)
.AddOrder(Order.Desc(CreateTimeProperty))
.GetExecutableCriteria(CurrentSession).List <PersonalMessage>());
}
public int GetActiveProducts(int week, int year)
{
ICriteria crit = GetCriteria();
int weekDif = (week - 53);
if (weekDif <= 0)
{
Disjunction dis = new Disjunction();
dis.Add(new AndExpression(new BetweenExpression("Week", 53 + weekDif, 53), new EqExpression("Year", year - 1)));
dis.Add(new AndExpression(new BetweenExpression("Week", 1, week), new EqExpression("Year", year)));
crit.Add(dis);
}
else
{
crit.Add(new AndExpression(new BetweenExpression("Week", weekDif, week), new EqExpression("Year", year)));
}
crit.SetProjection(Projections.ProjectionList()
.Add(Projections.Sum("Sale"))
.Add(Projections.GroupProperty("ProductID"))
);
crit.SetResultTransformer(new AliasToBeanConstructorResultTransformer(typeof(TransactionHistoryWeekly).GetConstructors()[1]));
List <TransactionHistoryWeekly> templist = crit.List <TransactionHistoryWeekly>() as List <TransactionHistoryWeekly>;
List <TransactionHistoryWeekly> countprod = templist.FindAll(delegate(TransactionHistoryWeekly record)
{
if (record.Sale > 0)
{
return(true);
}
else
{
return(false);
}
});
return(countprod.Count);
}
private void BuildQueryFrom(Query query, ICriteria criteria)
{
IList <ICriterion> criterions = new List <ICriterion>();
if (query.Criteria != null)
{
foreach (Criterion c in query.Criteria)
{
//处理查询属性中还有.的情况，在这种情况下，表示查询条件并非本对象的直接属性，而是
//相关对象的属性，如使用包装所属产品的属性查询对应的包装时，则查询属性为package.Product.OriginalId="A0040"
int lastPositionOfDot = c.PropertyName.LastIndexOf(".");
if (lastPositionOfDot > 0)
{
TranslateCascadeToNHCriterion(c, criteria);
}
else
{
ICriterion criterion;
if (IndirectProperties.Contains(c.PropertyName.ToLower()))
{
criterion = GenerateSqlCriterion(c);
}
else
{
criterion = TranslateToNHCriterion(c);
}
criterions.Add(criterion);
}
}
if (query.QueryOperator == QueryOperator.And)
{
Conjunction andSubQuery = Expression.Conjunction();
foreach (ICriterion criterion in criterions)
{
andSubQuery.Add(criterion);
}
criteria.Add(andSubQuery);
}
else
{
Disjunction orSubQuery = Expression.Disjunction();
foreach (ICriterion criterion in criterions)
{
orSubQuery.Add(criterion);
}
criteria.Add(orSubQuery);
}
foreach (Query sub in query.SubQueries)
{
BuildQueryFrom(sub, criteria);
}
}
}
/// <summary>
/// 获取用户
/// </summary>
/// <param name="loginIds">登录Id</param>
/// <returns>用户对象集合</returns>
public IList <User> GetUsers(string[] loginIds)
{
Disjunction disJunction = Restrictions.Disjunction();
foreach (string loginid in loginIds)
{
disJunction.Add(Restrictions.Eq("LoginId", loginid).IgnoreCase());
}
return(CreateDetachedCriteria().Add(disJunction).GetExecutableCriteria(CurrentSession).List <User>());
}
private ICriteria GetProviderListCriteria(string description, Country country, ProviderStatus?status, Incoterm?saleCondition)
{
ICriteria crit = GetCriteria();
if (!string.IsNullOrEmpty(description))
{
Disjunction d = new Disjunction();
d.Add(Restrictions.InsensitiveLike("Description", description, MatchMode.Anywhere));
d.Add(Restrictions.InsensitiveLike("Name", description, MatchMode.Anywhere));
d.Add(Expression.InsensitiveLike("Code", description, MatchMode.Anywhere));
crit.Add(d);
}
if (country != null)
{
ICriteria critCountry = crit.CreateCriteria("Country");
critCountry.Add(Restrictions.Eq("ID", country.ID));
}
ExecutePermissionValidator epv = new ExecutePermissionValidator();
epv.ClassType = typeof(Provider);
epv.KeyIdentifier = Config.ProviderInactiveStatus;
if (PermissionManager.Check(epv) == false)
{
crit.Add(Expression.Eq("ProviderStatus", ProviderStatus.Active));
}
else
if (status != null)
{
crit.Add(Restrictions.Eq("ProviderStatus", status));
}
if (saleCondition != null)
{
crit.Add(Expression.Eq("SaleConditions", saleCondition));
}
return(crit);
}