public virtual IList <HeadwordSearchResult> GetHeadwordListBySearchCriteria(IEnumerable <string> selectedGuidList,
HeadwordCriteriaQueryCreator creator, int start, int count)
{
using (var session = GetSession())
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
BookHeadword bookHeadwordAlias = null;
HeadwordSearchResult resultAlias = null;
var result = session.QueryOver(() => bookAlias)
.JoinQueryOver(x => x.LastVersion, () => bookVersionAlias)
.JoinQueryOver(x => x.BookHeadwords, () => bookHeadwordAlias)
.Select(Projections.Distinct(Projections.ProjectionList()
.Add(Projections.Property(() => bookAlias.Guid).WithAlias(() => resultAlias.BookGuid))
.Add(Projections.Property(() => bookVersionAlias.VersionId).WithAlias(() => resultAlias.BookVersionId))
.Add(Projections.Property(() => bookVersionAlias.Title).WithAlias(() => resultAlias.BookTitle))
.Add(Projections.Property(() => bookVersionAlias.Acronym).WithAlias(() => resultAlias.BookAcronym))
.Add(Projections.Property(() => bookVersionAlias.SourceAbbreviation).WithAlias(() => resultAlias.SourceAbbreviation))
.Add(Projections.Property(() => bookHeadwordAlias.DefaultHeadword).WithAlias(() => resultAlias.Headword))
.Add(Projections.Property(() => bookHeadwordAlias.SortOrder).WithAlias(() => resultAlias.SortOrder))
.Add(Projections.Property(() => bookHeadwordAlias.XmlEntryId).WithAlias(() => resultAlias.XmlEntryId))
.Add(Projections.Property(() => bookHeadwordAlias.Image).WithAlias(() => resultAlias.Image))))
.WhereRestrictionOn(() => bookAlias.Guid).IsInG(selectedGuidList)
.And(creator.GetCondition())
.OrderBy(x => x.SortOrder).Asc
.TransformUsing(Transformers.AliasToBean <HeadwordSearchResult>())
.Skip(start)
.Take(count)
.List <HeadwordSearchResult>();
return(result);
}
}
public virtual int GetHeadwordCountBySearchCriteria(IEnumerable <string> selectedGuidList,
HeadwordCriteriaQueryCreator creator)
{
Book bookAlias = null;
BookHeadword bookHeadwordAlias = null;
HeadwordCountResult headwordCountAlias = null;
using (var session = GetSession())
{
var resultList = session.QueryOver(() => bookAlias)
.JoinQueryOver(x => x.LastVersion)
.JoinQueryOver(x => x.BookHeadwords, () => bookHeadwordAlias)
.Select(Projections.ProjectionList()
.Add(
Projections.CountDistinct(() => bookHeadwordAlias.XmlEntryId)
.WithAlias(() => headwordCountAlias.HeadwordCount))
.Add(Projections.Group(() => bookAlias.Id).WithAlias(() => headwordCountAlias.BookId))
)
.WhereRestrictionOn(() => bookAlias.Guid).IsInG(selectedGuidList)
.And(creator.GetCondition())
.TransformUsing(Transformers.AliasToBean <HeadwordCountResult>())
.List <HeadwordCountResult>();
return((int)resultList.Sum(x => x.HeadwordCount));
}
}
public int SearchHeadwordByCriteriaResultsCount(IEnumerable <SearchCriteriaContract> searchCriterias,
DictionarySearchTarget searchTarget)
{
var criterias = searchCriterias.ToList();
m_authorizationManager.AuthorizeCriteria(criterias);
var filteredCriterias = FilterSearchCriterias(criterias);
var nonMetadataCriterias = filteredCriterias.NonMetadataCriterias;
var creator = new SearchCriteriaQueryCreator(filteredCriterias.ConjunctionQuery, filteredCriterias.MetadataParameters);
// Only SQL search
if (searchTarget == DictionarySearchTarget.Headword)
{
var query = GetSingleHeadwordQuery(filteredCriterias.MetadataCriterias);
if (query == null)
{
return(0);
}
creator.SetHeadwordQueryParameter(query);
var resultCount = m_bookVersionRepository.GetSearchHeadwordCount(creator);
return(resultCount);
}
// Advanced search
var databaseSearchResult = m_bookVersionRepository.SearchByCriteriaQuery(creator);
if (databaseSearchResult.Count == 0)
{
return(0);
}
if (nonMetadataCriterias.All(x => x.Key == CriteriaKey.Result))
{
// Search only in SQL
var headwordQueryCreator = new HeadwordCriteriaQueryCreator();
headwordQueryCreator.AddCriteria(filteredCriterias.MetadataCriterias);
var bookGuidList = databaseSearchResult.Select(x => x.Guid);
var resultCount = m_bookVersionRepository.GetHeadwordCountBySearchCriteria(bookGuidList, headwordQueryCreator);
return(resultCount);
}
// Fulltext search
var resultContract = new ResultRestrictionCriteriaContract
{
ResultBooks = databaseSearchResult
};
var headwordContracts = filteredCriterias.MetadataCriterias.Where(x => x.Key == CriteriaKey.Headword);
nonMetadataCriterias.Add(resultContract);
nonMetadataCriterias.AddRange(headwordContracts);
return(m_searchServiceClient.ListSearchDictionariesResultsCount(nonMetadataCriterias));
}
public HeadwordListContract SearchHeadwordByCriteria(IEnumerable <SearchCriteriaContract> searchCriterias, DictionarySearchTarget searchTarget)
{
var criterias = searchCriterias.ToList();
m_authorizationManager.AuthorizeCriteria(criterias);
var filteredCriterias = FilterSearchCriterias(criterias);
var resultCriteria = filteredCriterias.ResultCriteria;
var creator = new SearchCriteriaQueryCreator(filteredCriterias.ConjunctionQuery, filteredCriterias.MetadataParameters);
// Only SQL search
if (searchTarget == DictionarySearchTarget.Headword)
{
if (resultCriteria.Start == null || resultCriteria.Count == null)
{
return(null);
}
var query = GetSingleHeadwordQuery(filteredCriterias.MetadataCriterias);
if (query == null)
{
return(new HeadwordListContract());
}
creator.SetHeadwordQueryParameter(query);
var databaseHeadwords = m_bookVersionRepository.SearchHeadwordByCriteria(creator, resultCriteria.Start.Value, resultCriteria.Count.Value);
return(ConvertHeadwordSearchToContract(databaseHeadwords));
}
// Advanced search
var databaseSearchResult = m_bookVersionRepository.SearchByCriteriaQuery(creator);
if (databaseSearchResult.Count == 0)
{
return new HeadwordListContract
{
BookList = new Dictionary <string, DictionaryContract>(),
HeadwordList = new List <HeadwordContract>()
}
}
;
if (filteredCriterias.NonMetadataCriterias.All(x => x.Key == CriteriaKey.Result))
{
// Search only in SQL
if (resultCriteria.Start == null || resultCriteria.Count == null)
{
return(null);
}
var headwordQueryCreator = new HeadwordCriteriaQueryCreator();
headwordQueryCreator.AddCriteria(filteredCriterias.MetadataCriterias);
var bookGuidList = databaseSearchResult.Select(x => x.Guid);
var resultHeadwords = m_bookVersionRepository.GetHeadwordListBySearchCriteria(bookGuidList, headwordQueryCreator,
resultCriteria.Start.Value, resultCriteria.Count.Value);
return(ConvertHeadwordSearchToContract(resultHeadwords));
}
// Fulltext search
var resultRestrictionContract = new ResultRestrictionCriteriaContract
{
ResultBooks = databaseSearchResult
};
var headwordContracts = filteredCriterias.MetadataCriterias.Where(x => x.Key == CriteriaKey.Headword);
var nonMetadataCriterias = filteredCriterias.NonMetadataCriterias;
nonMetadataCriterias.Add(resultRestrictionContract);
nonMetadataCriterias.AddRange(headwordContracts);
var resultContract = m_searchServiceClient.ListSearchDictionariesResults(nonMetadataCriterias);
// fill book info
var bookInfoList = m_bookVersionRepository.GetBookVersionsByGuid(resultContract.BookList.Keys.ToList());
var bookInfoContracts = Mapper.Map <IList <DictionaryContract> >(bookInfoList);
var bookDictionary = bookInfoContracts.ToDictionary(x => x.BookXmlId, x => x);
resultContract.BookList = bookDictionary;
return(resultContract);
}
