public List <string> GetHeadwordAutocomplete(string query, ProjectTypeContract projectType, BookTypeEnumContract?bookType = null,
IList <int> selectedCategoryIds = null, IList <long> selectedProjectIds = null)
{
try
{
var url = UrlQueryBuilder.Create("headword/autocomplete")
.AddParameter("query", query)
.AddParameter("projectType", projectType)
.AddParameter("bookType", bookType)
.AddParameterList("selectedCategoryIds", selectedCategoryIds)
.AddParameterList("selectedProjectIds", selectedProjectIds)
.ToResult();
var result = m_client.Get <List <string> >(url);
return(result);
}
catch (HttpRequestException e)
{
if (m_logger.IsErrorEnabled())
{
m_logger.LogError("{0} failed with {1}", m_client.GetCurrentMethod(), e);
}
throw;
}
}
public ImportResultContract ProcessSession(string sessionId, long?projectId, int userId, string uploadMessage,
ProjectTypeContract projectType, FulltextStoreTypeContract storeType,
IList <PermissionFromAuthContract> autoImportPermissions)
{
if (!m_activeSessionManager.ContainsSessionId(sessionId))
{
return(new ImportResultContract {
Success = false
});
}
ResourceSessionDirector director = m_activeSessionManager.GetDirectorBySessionId(sessionId);
director.SetSessionInfoValue(SessionInfo.Message, uploadMessage);
director.SetSessionInfoValue(SessionInfo.CreateTime, DateTime.UtcNow);
director.SetSessionInfoValue(SessionInfo.ProjectId, projectId);
director.SetSessionInfoValue(SessionInfo.UserId, userId);
director.SetSessionInfoValue(SessionInfo.AutoImportPermissions, autoImportPermissions);
director.SetSessionInfoValue(SessionInfo.ProjectType, projectType);
director.SetSessionInfoValue(SessionInfo.StoreType, storeType);
bool result = m_resourceProcessorManager.ProcessSessionResources(director);
ImportResultContract importResult = new ImportResultContract(
director.GetSessionInfoValue <long>(SessionInfo.ProjectId),
result
);
m_activeSessionManager.FinalizeSession(sessionId);
return(importResult);
}
public CreateOrUpdateProjectBasicDataWork(ProjectRepository projectRepository, ResourceSessionDirector resourceDirector) : base(projectRepository)
{
m_projectRepository = projectRepository;
m_nullableProjectId = resourceDirector.GetSessionInfoValue <long?>(SessionInfo.ProjectId);
m_bookData = resourceDirector.GetSessionInfoValue <BookData>(SessionInfo.BookData);
m_userId = resourceDirector.GetSessionInfoValue <int>(SessionInfo.UserId);
m_projectType = resourceDirector.GetSessionInfoValue <ProjectTypeContract>(SessionInfo.ProjectType);
}
public string TranslatePortalShort(ProjectTypeContract projectType)
{
switch (projectType)
{
case ProjectTypeContract.Research:
return(m_localizationService.Translate("ResearchPortalShort", "BibliographyModule"));
case ProjectTypeContract.Community:
return(m_localizationService.Translate("CommunityPortalShort", "BibliographyModule"));
case ProjectTypeContract.Bibliography:
return(m_localizationService.Translate("BibliographicRecordsShort", "BibliographyModule"));
default:
return(projectType.ToString());
}
}
public long SearchByCriteriaCount(AdvancedSearchRequestContract request, ProjectTypeContract projectType)
{
m_authorizationManager.AddAuthorizationCriteria(request.ConditionConjunction);
var processedCriterias = m_metadataSearchCriteriaProcessor.ProcessSearchCriterias(request.ConditionConjunction);
var projectTypeEnums = new List <ProjectTypeEnum> {
m_mapper.Map <ProjectTypeEnum>(projectType)
};
if (request.Parameters != null && request.Parameters.IncludeAdditionalProjectTypes)
{
projectTypeEnums.AddRange(request.Parameters.AdditionalProjectTypes.Select(x => m_mapper.Map <ProjectTypeEnum>(x)));
}
var queryCreator = new SearchCriteriaQueryCreator(processedCriterias.ConjunctionQuery, processedCriterias.MetadataParameters, projectTypeEnums)
{
Sort = request.Sort,
SortDirection = request.SortDirection,
Start = PagingHelper.GetStart(request.Start),
Count = PagingHelper.GetCountForProject(request.Count)
};
if (processedCriterias.NonMetadataCriterias.Count > 0)
{
// Search in fulltext DB
// 1) search in metadata
var projectIdentificatorList = m_bookRepository.InvokeUnitOfWork(x => x.SearchProjectIdByCriteriaQuery(queryCreator));
if (projectIdentificatorList.Count == 0)
{
return(0);
}
// 2) search in fulltext
var fulltextStorage = m_fulltextStorageProvider.GetFulltextStorage(projectType);
var result = fulltextStorage.SearchByCriteriaCount(processedCriterias.NonMetadataCriterias, projectIdentificatorList);
return(result);
}
else
{
// Search in relational DB
var result = m_bookRepository.InvokeUnitOfWork(x => x.SearchByCriteriaQueryCount(queryCreator));
return(result);
}
}
public long SearchCorpusTotalResultCount(SearchRequestContractBase request, ProjectTypeContract projectType)
{
try
{
var result = m_client.Post <long>($"bookpagedcorpus/search-count?projectType={projectType}", request);
return(result);
}
catch (HttpRequestException e)
{
if (m_logger.IsErrorEnabled())
{
m_logger.LogError("{0} failed with {1}", m_client.GetCurrentMethod(), e);
}
throw;
}
}
public long SearchHeadwordCount(HeadwordSearchRequestContract request, ProjectTypeContract projectType)
{
try
{
var result = m_client.Post <long>($"headword/search-count?projectType={projectType}", request);
return(result);
}
catch (HttpRequestException e)
{
if (m_logger.IsErrorEnabled())
{
m_logger.LogError("{0} failed with {1}", m_client.GetCurrentMethod(), e);
}
throw;
}
}
public long SearchCorpusTotalResultCount(SearchRequestContractBase request, ProjectTypeContract projectType)
{
var processedCriterias = GetAuthorizatedProcessedCriterias(request.ConditionConjunction);
var nonMetadataCriterias = processedCriterias.NonMetadataCriterias;
var projectIdentificatorList = GetProjectIdentificatorList(processedCriterias.ConjunctionQuery, processedCriterias.MetadataParameters, projectType);
if (projectIdentificatorList.Count == 0)
{
return(0);
}
//Search in fulltext DB
var fulltextStorage = m_fulltextStorageProvider.GetFulltextStorage(projectType);
var resultCount = fulltextStorage.SearchCorpusTotalResultCount(nonMetadataCriterias, projectIdentificatorList);
return(resultCount);
}
public BookContract GetBookInfoByExternalId(string projectExternalId, ProjectTypeContract projectType)
{
// Authorize after getting projectId
var projectTypeEnum = m_mapper.Map <ProjectTypeEnum>(projectType);
var metadataResult = m_metadataRepository.InvokeUnitOfWork(x => x.GetLatestMetadataResourceByExternalId(projectExternalId, projectTypeEnum));
if (metadataResult == null)
{
return(null);
}
m_authorizationManager.AuthorizeBook(metadataResult.Resource.Project.Id, PermissionFlag.ShowPublished);
var result = m_mapper.Map <BookContract>(metadataResult);
return(result);
}
public List <string> GetHeadwordAutocomplete(string query, ProjectTypeContract projectType, BookTypeEnumContract?bookType,
IList <int> selectedCategoryIds,
IList <long> selectedProjectIds)
{
var userId = m_authorizationManager.GetCurrentUserId();
var bookTypeEnum = m_mapper.Map <BookTypeEnum?>(bookType);
var projectTypeEnum = m_mapper.Map <ProjectTypeEnum>(projectType);
var result = m_bookRepository.InvokeUnitOfWork(x =>
{
var allCategoryIds = selectedCategoryIds.Count > 0
? m_categoryRepository.GetAllSubcategoryIds(selectedCategoryIds)
: selectedCategoryIds;
return(x.GetHeadwordAutocomplete(query, projectTypeEnum, bookTypeEnum, allCategoryIds, selectedProjectIds,
DefaultValues.AutocompleteCount,
userId));
});
return(result.ToList());
}
public BookContract GetBookInfoByExternalId(string externalId, ProjectTypeContract projectType)
{
try
{
var url = UrlQueryBuilder.Create("book/info")
.AddParameter("externalId", externalId)
.AddParameter("projectType", projectType)
.ToResult();
var result = m_client.Get <BookContract>(url);
return(result);
}
catch (HttpRequestException e)
{
if (m_logger.IsErrorEnabled())
{
m_logger.LogError("{0} failed with {1}", m_client.GetCurrentMethod(), e);
}
throw;
}
}
public ImportResultContract ProcessSession(string sessionId, long?projectId, int userId, string uploadMessage,
ProjectTypeContract projectType, FulltextStoreTypeContract storeType, IList <PermissionFromAuthContract> autoImportPermissions)
{
try
{
return(Channel.ProcessSession(sessionId, projectId, userId, uploadMessage, projectType, storeType, autoImportPermissions));
}
catch (FaultException ex)
{
throw new FileProcessingImportFailedException("File processing failed. See inner exception.", ex);
}
catch (TimeoutException ex)
{
throw new FileProcessingException("Communication with FileProcessing service failed. See inner exception.", ex);
}
catch (CommunicationException ex)
{
throw new FileProcessingException(String.Format("Communication with FileProcessing service failed. See inner exception: {0}", ex.Message), ex);
}
catch (ObjectDisposedException ex)
{
throw new FileProcessingException("Communication with FileProcessing service failed. See inner exception.", ex);
}
}
public List <AudioBookSearchResultContract> SearchAudioByCriteria(SearchRequestContract request, ProjectTypeContract projectType)
{
m_authorizationManager.AddAuthorizationCriteria(request.ConditionConjunction);
var processedCriterias = m_metadataSearchCriteriaProcessor.ProcessSearchCriterias(request.ConditionConjunction);
var projectTypeEnum = m_mapper.Map <ProjectTypeEnum>(projectType);
var queryCreator = new SearchCriteriaQueryCreator(processedCriterias.ConjunctionQuery, processedCriterias.MetadataParameters, projectTypeEnum)
{
Sort = request.Sort,
SortDirection = request.SortDirection,
Start = PagingHelper.GetStart(request.Start),
Count = PagingHelper.GetCountForProject(request.Count)
};
// Search only in relational DB
var searchByCriteriaWork = new SearchAudioByCriteriaWork(m_metadataRepository, m_bookRepository, queryCreator);
var dbResult = searchByCriteriaWork.Execute();
//var resultList = MapToSearchResult(dbResult, searchByCriteriaWork.PageCounts);
var resultList = new List <AudioBookSearchResultContract>(dbResult.Count);
foreach (var dbMetadata in dbResult)
{
var resultItem = m_mapper.Map <AudioBookSearchResultContract>(dbMetadata);
resultList.Add(resultItem);
if (searchByCriteriaWork.FullBookRecordingsByProjectId.TryGetValue(dbMetadata.Resource.Project.Id, out var audioList))
{
resultItem.FullBookRecordings = m_mapper.Map <List <AudioContract> >(audioList);
}
else
{
resultItem.FullBookRecordings = new List <AudioContract>();
}
}
return(resultList);
}
public IFulltextStorage GetFulltextStorage(ProjectTypeContract projectType)
{
return(GetFulltextStorage((ProjectTypeEnum)projectType));
}
public CorpusSearchSnapshotsResultContract SearchCorpusGetSnapshotList(BookPagedCorpusSearchRequestContract request, ProjectTypeContract projectType)
{
try
{
var result = m_client.Post <CorpusSearchSnapshotsResultContract>($"bookpagedcorpus/search?projectType={projectType}", request);
return(result);
}
catch (HttpRequestException e)
{
if (m_logger.IsErrorEnabled())
{
m_logger.LogError("{0} failed with {1}", m_client.GetCurrentMethod(), e);
}
throw;
}
}
public long SearchHeadwordRowNumber(HeadwordRowNumberSearchRequestContract request, ProjectTypeContract projectType)
{
var userId = m_authorizationManager.GetCurrentUserId();
var projectTypeEnum = m_mapper.Map <ProjectTypeEnum>(projectType);
if (request.Category.BookType == null)
{
throw new MainServiceException(MainServiceErrorCode.NullBookTypeNotSupported, "Null value of BookType is not supported");
}
var searchHeadwordRowNumberWork =
new SearchHeadwordRowNumberWork(m_bookRepository, m_categoryRepository, request, userId, projectTypeEnum, m_mapper);
var result = searchHeadwordRowNumberWork.Execute();
return(result);
}
public List <AudioBookSearchResultContract> SearchAudioBook(SearchRequestContract request, ProjectTypeContract projectType)
{
try
{
var result = m_client.Post <List <AudioBookSearchResultContract> >($"audiobook/search?projectType={projectType}", request);
return(result);
}
catch (HttpRequestException e)
{
if (m_logger.IsErrorEnabled())
{
m_logger.LogError("{0} failed with {1}", m_client.GetCurrentMethod(), e);
}
throw;
}
}
public List <CorpusSearchResultContract> SearchCorpusByCriteria(CorpusSearchRequestContract request, ProjectTypeContract projectType)
{
var processedCriterias = GetAuthorizatedProcessedCriterias(request.ConditionConjunction);
var nonMetadataCriterias = processedCriterias.NonMetadataCriterias;
var projectIdentificatorList = GetProjectIdentificatorList(processedCriterias.ConjunctionQuery, processedCriterias.MetadataParameters, projectType);
if (projectIdentificatorList.Count == 0)
{
return(new List <CorpusSearchResultContract>());
}
// Search in fulltext DB
var fulltextStorage = m_fulltextStorageProvider.GetFulltextStorage(projectType);
var start = m_corpusSearchManager.GetCorpusStart(request.Start);
var count = m_corpusSearchManager.GetCorpusCount(request.Count);
var result = fulltextStorage.SearchCorpusByCriteria(start, count, request.ContextLength, request.Sort, request.SortDirection, nonMetadataCriterias, projectIdentificatorList);
var projectTypeEnum = m_mapper.Map <ProjectTypeEnum>(projectType);
switch (result.SearchResultType)
{
case FulltextSearchResultType.ProjectId:
return(m_corpusSearchManager.GetCorpusSearchResultByStandardIds(result.List));
case FulltextSearchResultType.ProjectExternalId:
return(m_corpusSearchManager.GetCorpusSearchResultByExternalIds(result.List, projectTypeEnum));
default:
throw new ArgumentOutOfRangeException();
}
}
private IList <ProjectIdentificationResult> GetProjectIdentificatorList(List <SearchCriteriaQuery> processedCriteriasConjunctionQuery, Dictionary <string, object> processedCriteriasMetadataParameters, ProjectTypeContract projectType)
{
var projectTypeEnum = m_mapper.Map <ProjectTypeEnum>(projectType);
var queryCreator = new SearchCriteriaQueryCreator(processedCriteriasConjunctionQuery, processedCriteriasMetadataParameters, projectTypeEnum);
var projectIdentificatorList = m_bookRepository.InvokeUnitOfWork(x => x.SearchProjectIdByCriteriaQuery(queryCreator));
return(projectIdentificatorList);
}
public CorpusSearchSnapshotsResultContract SearchCorpusGetSnapshotListByCriteria(BookPagedCorpusSearchRequestContract request,
ProjectTypeContract projectType)
{
var processedCriterias = GetAuthorizatedProcessedCriterias(request.ConditionConjunction);
var nonMetadataCriterias = processedCriterias.NonMetadataCriterias;
var projectIdentificatorList = GetProjectIdentificatorList(processedCriterias.ConjunctionQuery, processedCriterias.MetadataParameters, projectType);
if (projectIdentificatorList.Count == 0)
{
return(new CorpusSearchSnapshotsResultContract
{
TotalCount = 0,
SnapshotList = new List <CorpusSearchSnapshotContract>(),
});
}
// Search in fulltext DB
var fulltextStorage = m_fulltextStorageProvider.GetFulltextStorage(projectType);
var start = m_corpusSearchManager.GetCorpusStart(request.Start);
var count = m_corpusSearchManager.GetCorpusCount(request.Count);
var result = fulltextStorage.SearchCorpusGetSnapshotListByCriteria(start, count, request.Sort, request.SortDirection, nonMetadataCriterias, projectIdentificatorList, request.FetchNumberOfResults);
return(result);
}
public long SearchHeadwordByCriteriaCount(HeadwordSearchRequestContract request, ProjectTypeContract projectType)
{
m_authorizationManager.AddAuthorizationCriteria(request.ConditionConjunction);
var processedCriterias = m_metadataSearchCriteriaProcessor.ProcessSearchCriterias(request.ConditionConjunction);
var projectTypeEnum = m_mapper.Map <ProjectTypeEnum>(projectType);
var queryCreator = new SearchCriteriaQueryCreator(processedCriterias.ConjunctionQuery, processedCriterias.MetadataParameters, projectTypeEnum)
{
Start = PagingHelper.GetStart(request.Start),
Count = PagingHelper.GetCount(request.Count)
};
if (processedCriterias.NonMetadataCriterias.Count > 0)
{
// Search in fulltext DB
// 1) search in metadata
var projectIdentificatorList = m_bookRepository.InvokeUnitOfWork(x => x.SearchProjectIdByCriteriaQuery(queryCreator));
if (projectIdentificatorList.Count == 0)
{
return(0);
}
// 2) search in fulltext
var fulltextStorage = m_fulltextStorageProvider.GetFulltextStorage(projectType);
var result = fulltextStorage.SearchHeadwordByCriteriaCount(processedCriterias.NonMetadataCriterias, projectIdentificatorList);
return(result);
}
else
{
// Search in relational DB
var result = m_bookRepository.InvokeUnitOfWork(x => x.SearchHeadwordByCriteriaQueryCount(queryCreator));
return(result);
}
}
public List <HeadwordContract> SearchHeadwordByCriteria(HeadwordSearchRequestContract request, ProjectTypeContract projectType)
{
m_authorizationManager.AddAuthorizationCriteria(request.ConditionConjunction);
var processedCriterias = m_metadataSearchCriteriaProcessor.ProcessSearchCriterias(request.ConditionConjunction);
var nonMetadataCriterias = processedCriterias.NonMetadataCriterias;
var projectTypeEnum = m_mapper.Map <ProjectTypeEnum>(projectType);
var queryCreator = new SearchCriteriaQueryCreator(processedCriterias.ConjunctionQuery, processedCriterias.MetadataParameters, projectTypeEnum)
{
Start = PagingHelper.GetStart(request.Start),
Count = PagingHelper.GetCount(request.Count)
};
if (processedCriterias.NonMetadataCriterias.Count > 0)
{
// Search in fulltext DB
// 1) search in metadata
var projectIdentificatorList = m_bookRepository.InvokeUnitOfWork(x => x.SearchProjectIdByCriteriaQuery(queryCreator));
if (projectIdentificatorList.Count == 0)
{
return(new List <HeadwordContract>());
}
// 2) search in fulltext
var fulltextStorage = m_fulltextStorageProvider.GetFulltextStorage(projectType);
var fulltextSearchResultData = fulltextStorage.SearchHeadwordByCriteria(queryCreator.GetStart(), queryCreator.GetCount(), nonMetadataCriterias, projectIdentificatorList);
// 3) load paged result
switch (fulltextSearchResultData.SearchResultType)
{
case FulltextSearchResultType.ProjectId:
return(m_headwordSearchManager.GetHeadwordSearchResultByStandardIds(fulltextSearchResultData.List));
case FulltextSearchResultType.ProjectExternalId:
return(m_headwordSearchManager.GetHeadwordSearchResultByExternalIds(fulltextSearchResultData.List, projectTypeEnum));
default:
throw new ArgumentOutOfRangeException();
}
}
else
{
// Search in relational DB
var searchByCriteriaWork = new SearchHeadwordByCriteriaWork(m_resourceRepository, m_bookRepository, queryCreator);
var dbResult = searchByCriteriaWork.Execute();
var resultList = m_mapper.Map <List <HeadwordContract> >(dbResult);
return(resultList);
}
}
public ImportResultContract ProcessSession(string sessionId, long?projectId, int userId, string uploadMessage, ProjectTypeContract projectType, FulltextStoreTypeContract storeType, IList <PermissionFromAuthContract> autoImportPermissions)
{
return(m_sessionManager.ProcessSession(sessionId, projectId, userId, uploadMessage, projectType, storeType, autoImportPermissions));
}
public PagedResultList <ProjectDetailContract> GetProjectList(int start, int count, ProjectTypeContract projectType,
ProjectOwnerTypeContract projectOwnerType = ProjectOwnerTypeContract.AllProjects, string filterByName = null, bool fetchPageCount = false,
bool fetchLatestChangedResource = false, bool fetchPermissions = false)
{
try
{
var url = UrlQueryBuilder.Create("project")
.AddParameter("start", start)
.AddParameter("count", count)
.AddParameter("projectType", projectType)
.AddParameter("projectOwnerType", projectOwnerType)
.AddParameter("filterByName", filterByName)
.AddParameter("fetchPageCount", fetchPageCount)
.AddParameter("fetchLatestChangedResource", fetchLatestChangedResource)
.AddParameter("fetchPermissions", fetchPermissions)
.ToResult();
var result = m_client.GetPagedList <ProjectDetailContract>(url);
return(result);
}
catch (HttpRequestException e)
{
if (m_logger.IsErrorEnabled())
{
m_logger.LogError("{0} failed with {1}", m_client.GetCurrentMethod(), e);
}
throw;
}
}
public List <SearchResultContract> SearchByCriteria(AdvancedSearchRequestContract request, ProjectTypeContract projectType)
{
m_authorizationManager.AddAuthorizationCriteria(request.ConditionConjunction);
var processedCriterias = m_metadataSearchCriteriaProcessor.ProcessSearchCriterias(request.ConditionConjunction);
var nonMetadataCriterias = processedCriterias.NonMetadataCriterias;
var mainProjectTypeEnum = m_mapper.Map <ProjectTypeEnum>(projectType);
var projectTypeEnums = new List <ProjectTypeEnum> {
mainProjectTypeEnum
};
if (request.Parameters != null && request.Parameters.IncludeAdditionalProjectTypes)
{
projectTypeEnums.AddRange(request.Parameters.AdditionalProjectTypes.Select(x => m_mapper.Map <ProjectTypeEnum>(x)));
}
var queryCreator = new SearchCriteriaQueryCreator(processedCriterias.ConjunctionQuery, processedCriterias.MetadataParameters, projectTypeEnums)
{
Sort = request.Sort,
SortDirection = request.SortDirection,
Start = PagingHelper.GetStart(request.Start),
Count = PagingHelper.GetCountForProject(request.Count)
};
if (processedCriterias.NonMetadataCriterias.Count > 0)
{
// Search in fulltext DB
// 1) search in metadata
var projectIdentificatorList = m_bookRepository.InvokeUnitOfWork(x => x.SearchProjectIdByCriteriaQuery(queryCreator));
if (projectIdentificatorList.Count == 0)
{
return(new List <SearchResultContract>());
}
// 2) search in fulltext
var fulltextStorage = m_fulltextStorageProvider.GetFulltextStorage(projectType);
var fulltextSearchResultData = fulltextStorage.SearchProjectIdByCriteria(queryCreator.GetStart(), queryCreator.GetCount(), request.Sort, request.SortDirection, nonMetadataCriterias, projectIdentificatorList);
// 3) load paged result
var termCriteria = CreateTermConditionCreatorOrDefault(request, processedCriterias);
var searchByCriteriaFulltextResultWork = new SearchByCriteriaFulltextResultWork(m_metadataRepository, m_bookRepository, fulltextSearchResultData, termCriteria, mainProjectTypeEnum);
var dbResult = searchByCriteriaFulltextResultWork.Execute();
var resultList = MapToSearchResult(dbResult, searchByCriteriaFulltextResultWork.PageCounts, searchByCriteriaFulltextResultWork.TermHits);
return(resultList);
}
else
{
// Search in relational DB
var termCriteria = CreateTermConditionCreatorOrDefault(request, processedCriterias);
var searchByCriteriaWork = new SearchByCriteriaWork(m_metadataRepository, m_bookRepository, queryCreator, termCriteria);
var dbResult = searchByCriteriaWork.Execute();
var resultList = MapToSearchResult(dbResult, searchByCriteriaWork.PageCounts, searchByCriteriaWork.TermHits);
return(resultList);
}
}
