public List <PageResultContextContract> SearchHitsWithPageContext(long projectId, SearchHitsRequestContract request)
{
m_authorizationManager.AuthorizeBook(projectId, PermissionFlag.ShowPublished);
var fulltextConditions = ExtractFulltextConditions(request.ConditionConjunction);
if (fulltextConditions.Count == 0)
{
throw new MainServiceException(MainServiceErrorCode.NoSupportedSearch,
"No supported search criteria was specified"
);
}
var projectIdentification = m_bookRepository.InvokeUnitOfWork(x => x.GetProjectIdentification(projectId));
var fulltextStorage = m_fulltextStorageProvider.GetFulltextStorage(projectIdentification.ProjectType);
var start = PagingHelper.GetStart(request.Start);
var count = PagingHelper.GetCount(request.Count);
var fulltextResult = fulltextStorage.SearchHitsWithPageContext(start, count, request.ContextLength, fulltextConditions, projectIdentification);
switch (fulltextResult.SearchResultType)
{
case PageSearchResultType.TextId:
return(ConvertSearchResultsByStandardId(fulltextResult.ResultList));
case PageSearchResultType.TextExternalId:
return(ConvertSearchResultsByExternalId(projectId, fulltextResult.ResultList));
default:
throw new ArgumentOutOfRangeException();
}
}
public PagedResultList <RoleContract> GetRoleList(int?start, int?count, string filterByName)
{
var startValue = PagingHelper.GetStart(start);
var countValue = PagingHelper.GetCount(count);
var client = m_communicationProvider.GetAuthRoleApiClient();
var authResult = client.GetRoleListAsync(startValue, countValue, filterByName).GetAwaiter().GetResult();
var resultList = new List <RoleContract>();
foreach (var authRoleContract in authResult.Items)
{
var synchronizeRoleWork = new SynchronizeRoleWork(m_permissionRepository, m_communicationProvider, authRoleContract);
synchronizeRoleWork.Execute();
var resultRoleContract = m_mapper.Map <RoleContract>(authRoleContract);
resultRoleContract.Id = synchronizeRoleWork.LocalId;
resultList.Add(resultRoleContract);
}
return(new PagedResultList <RoleContract>
{
List = resultList,
TotalCount = authResult.ItemsCount,
});
}
public PagedResultList <SnapshotAggregatedInfoContract> GetPublishedSnapshotWithAggregatedInfo(long projectId, int?start, int?count, string filterByComment)
{
var startValue = PagingHelper.GetStart(start);
var countValue = PagingHelper.GetCount(count);
var publishedSnapshots = m_snapshotRepository.InvokeUnitOfWork(x => x.GetPublishedSnapshots(projectId, startValue, countValue, filterByComment));
var snapshotInfo = m_snapshotRepository.InvokeUnitOfWork(x => x.GetSnapshotsResourcesCount(publishedSnapshots.List.Select(s => s.Id).ToArray()));
var snapshotContracts = m_mapper.Map <List <SnapshotAggregatedInfoContract> >(publishedSnapshots.List);
foreach (var snapshotContract in snapshotContracts)
{
var dbSnapshot = publishedSnapshots.List.FirstOrDefault(x => x.Id == snapshotContract.Id);
if (dbSnapshot != null)
{
snapshotContract.Author = m_userDetailManager.GetUserFullName(dbSnapshot.CreatedByUser);
snapshotContract.ResourcesInfo = new List <SnapshotResourcesInfoContract>();
foreach (var aggregatedInfo in snapshotInfo.Where(x => x.Id == snapshotContract.Id))
{
snapshotContract.ResourcesInfo.Add(new SnapshotResourcesInfoContract
{
ResourceType = m_mapper.Map <ResourceTypeEnumContract>(aggregatedInfo.Type),
PublishedCount = aggregatedInfo.ResourcesCount
});
}
}
}
return(new PagedResultList <SnapshotAggregatedInfoContract>
{
List = snapshotContracts,
TotalCount = publishedSnapshots.Count
});
}
public PagedResultList <FeedbackContract> GetFeedbackList(int?start, int?count, FeedbackSortEnumContract sort,
SortDirectionEnumContract sortDirection, IList <FeedbackCategoryEnumContract> filterCategories, PortalTypeContract portalTypeContract)
{
var startValue = PagingHelper.GetStart(start);
var countValue = PagingHelper.GetCount(count);
var sortValue = m_mapper.Map <FeedbackSortEnum>(sort);
var filterCategoryValues = m_mapper.Map <List <FeedbackCategoryEnum> >(filterCategories);
var portalType = m_mapper.Map <PortalTypeEnum>(portalTypeContract);
var result = m_portalRepository.InvokeUnitOfWork(repository =>
{
var dbFeedbacks = repository.GetFeedbackList(startValue, countValue, sortValue, sortDirection, filterCategoryValues, portalType);
var headwordFeedbackIds = dbFeedbacks.List.Where(x => x.FeedbackType == FeedbackType.Headword)
.Select(x => x.Id);
repository.FetchHeadwordFeedbacks(headwordFeedbackIds);
return(dbFeedbacks);
});
return(new PagedResultList <FeedbackContract>
{
List = m_userDetailManager.AddUserDetails(m_mapper.Map <List <FeedbackContract> >(result.List)),
TotalCount = result.Count,
});
}
public PagedResultList <ProjectDetailContract> GetProjectsByAuthor(int authorId, int?start, int?count)
{
var startValue = PagingHelper.GetStart(start);
var countValue = PagingHelper.GetCount(count);
var dbMetadataList = m_metadataRepository.InvokeUnitOfWork(x => x.GetMetadataByAuthor(authorId, startValue, countValue));
var result = MapPagedProjectsToContractList(dbMetadataList);
return(result);
}
public List <FilteringExpressionSetContract> GetFilteringExpressionSetList([FromQuery] int?start, [FromQuery] int?count)
{
var startValue = PagingHelper.GetStart(start);
var countValue = PagingHelper.GetCount(count);
var result = m_filteringExpressionSetManager.GetFilteringExpressionSetList(startValue, countValue);
SetTotalCountHeader(result.TotalCount);
return(result.List);
}
public List <ExternalRepositoryContract> GetExternalRepositoryList([FromQuery] int?start, [FromQuery] int?count)
{
var startValue = PagingHelper.GetStart(start);
var countValue = PagingHelper.GetCount(count);
var result = m_externalRepositoryManager.GetExternalRepositoryList(startValue, countValue);
SetTotalCountHeader(result.TotalCount);
return(result.List);
}
public PagedResultList <KeywordContract> GetKeywordList(int?start, int?count)
{
var startValue = PagingHelper.GetStart(start);
var countValue = PagingHelper.GetCount(count);
var dbResult = m_catalogValueRepository.InvokeUnitOfWork(x => x.GetKeywordList(startValue, countValue));
return(new PagedResultList <KeywordContract>
{
List = m_mapper.Map <List <KeywordContract> >(dbResult.List),
TotalCount = dbResult.Count,
});
}
public List <BookWithCategoriesContract> GetBooksByTypeForUser(BookTypeEnumContract bookType, int start, int count)
{
count = PagingHelper.GetCount(count);
var projectType = m_portalTypeProvider.GetDefaultProjectType();
var projectTypeEnum = m_mapper.Map <ProjectTypeEnum>(projectType);
var bookTypeEnum = m_mapper.Map <BookTypeEnum>(bookType);
var user = m_authenticationManager.GetCurrentUser(true);
var dbMetadataList = m_metadataRepository.InvokeUnitOfWork(x => x.GetMetadataByBookTypeWithCategories(bookTypeEnum, user.Id, projectTypeEnum, start, count));
var resultList = m_mapper.Map <List <BookWithCategoriesContract> >(dbMetadataList);
return(resultList);
}
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 PagedResultList <OriginalAuthorContract> GetOriginalAuthorList(int?start, int?count)
{
var startValue = PagingHelper.GetStart(start);
var countValue = PagingHelper.GetCount(count);
var dbResult = m_personRepository.InvokeUnitOfWork(x => x.GetOriginalAuthorList(startValue, countValue));
var resultList = m_mapper.Map <List <OriginalAuthorContract> >(dbResult.List);
return(new PagedResultList <OriginalAuthorContract>
{
List = resultList,
TotalCount = dbResult.Count
});
}
public PagedResultList <FavoriteBaseInfoContract> GetFavoriteItems(int?start, int?count, long?labelId, FavoriteTypeEnumContract?filterByType, string filterByTitle, FavoriteSortEnumContract sort)
{
var user = TryGetUser();
var startValue = PagingHelper.GetStart(start);
var countValue = PagingHelper.GetCount(count);
var typeFilter = m_mapper.Map <FavoriteTypeEnum?>(filterByType);
var dbResult = m_favoritesRepository.InvokeUnitOfWork(x => x.GetFavoriteItems(labelId, typeFilter, filterByTitle, sort, startValue, countValue, user.Id));
return(new PagedResultList <FavoriteBaseInfoContract>
{
List = m_mapper.Map <List <FavoriteBaseInfoContract> >(dbResult.List),
TotalCount = dbResult.Count
});
}
public PagedResultList <FavoriteQueryContract> GetFavoriteQueries(int?start, int?count, long?labelId, BookTypeEnumContract bookType, QueryTypeEnumContract queryType, string filterByTitle)
{
var user = TryGetUser();
var startValue = PagingHelper.GetStart(start);
var countValue = PagingHelper.GetCount(count);
var bookTypeEnum = m_mapper.Map <BookTypeEnum>(bookType);
var queryTypeEnum = m_mapper.Map <QueryTypeEnum>(queryType);
var dbResult = m_favoritesRepository.InvokeUnitOfWork(x => x.GetFavoriteQueries(labelId, bookTypeEnum, queryTypeEnum, filterByTitle, startValue, countValue, user.Id));
return(new PagedResultList <FavoriteQueryContract>
{
List = m_mapper.Map <List <FavoriteQueryContract> >(dbResult.List),
TotalCount = dbResult.Count,
});
}
public PagedResultList <NewsSyndicationItemContract> GetNewsSyndicationItems(int?start, int?count, NewsTypeEnumContract?itemType, PortalTypeContract portalTypeContract)
{
var startValue = PagingHelper.GetStart(start);
var countValue = PagingHelper.GetCount(count);
var syndicationItemType = m_mapper.Map <SyndicationItemType?>(itemType);
var portalType = m_mapper.Map <PortalTypeEnum>(portalTypeContract);
var result = m_portalRepository.InvokeUnitOfWork(x =>
x.GetNewsSyndicationItems(startValue, countValue, syndicationItemType, portalType));
return(new PagedResultList <NewsSyndicationItemContract>
{
List = m_userDetailManager.AddUserDetails(m_mapper.Map <List <NewsSyndicationItemContract> >(result.List)),
TotalCount = result.Count
});
}
public PagedResultList <UserContract> GetUsersByGroup(int groupId, int?start, int?count, string filterByName)
{
// Method required for Role management (select role, load users)
var role = m_permissionRepository.InvokeUnitOfWork(x => x.FindById <UserGroup>(groupId));
if (role is RoleUserGroup roleUserGroup)
{
// If UserGroup has relation to Roles on Auth service, use user list from Auth service (the main data source)
var client = m_communicationProvider.GetAuthRoleApiClient();
var result = client.GetUserListByRoleAsync(roleUserGroup.ExternalId, start, count, filterByName).GetAwaiter().GetResult();
var users = m_mapper.Map <List <UserContract> >(result.Items);
m_userDetailManager.AddIdForExternalUsers(users);
return(new PagedResultList <UserContract>
{
List = users,
TotalCount = result.ItemsCount
});
}
else
{
// If UserGroup has no relation to Auth service (permissions to books), use local user list
var startValue = PagingHelper.GetStart(start);
var countValue = PagingHelper.GetCount(count);
var dbUsers = m_userRepository.InvokeUnitOfWork(x => x.GetUsersByGroup(groupId, startValue, countValue, filterByName));
var resultList = new List <UserContract>();
foreach (var dbUser in dbUsers.List)
{
var resultUser = m_mapper.Map <UserContract>(dbUser);
resultUser.FirstName = dbUser.ExtFirstName;
resultUser.LastName = dbUser.ExtLastName;
resultUser.UserName = dbUser.ExtUsername;
resultList.Add(resultUser);
}
return(new PagedResultList <UserContract>
{
List = resultList,
TotalCount = dbUsers.Count,
});
}
}
public PagedResultList <SpecialPermissionContract> GetPermissions(int?start, int?count, string filterByName)
{
var startValue = PagingHelper.GetStart(start);
var countValue = PagingHelper.GetCount(count);
var client = m_communicationProvider.GetAuthPermissionApiClient();
var result = client.GetPermissionListAsync(startValue, countValue, filterByName).GetAwaiter()
.GetResult();
var permissionContracts = m_mapper.Map <List <SpecialPermissionContract> >(result.Items);
return(new PagedResultList <SpecialPermissionContract>
{
List = permissionContracts,
TotalCount = result.ItemsCount
});
}
public PagedResultList <UserDetailContract> GetUserList(int?start, int?count, string filterByName)
{
var startValue = PagingHelper.GetStart(start);
var countValue = PagingHelper.GetCount(count);
var client = m_communicationProvider.GetAuthUserApiClient();
var result = client.GetUserListAsync(startValue, countValue, filterByName).GetAwaiter().GetResult();
var userDetailContracts = m_mapper.Map <List <UserDetailContract> >(result.Items);
m_userDetailManager.AddIdForExternalUsers(userDetailContracts);
return(new PagedResultList <UserDetailContract>
{
List = userDetailContracts,
TotalCount = result.ItemsCount,
});
}
public PagedResultList <UserGroupContract> GetUserGroupsByProject(long projectId, int?start, int?count, string filterByName)
{
var startValue = PagingHelper.GetStart(start);
var countValue = PagingHelper.GetCount(count);
var result = m_permissionRepository.InvokeUnitOfWork(x => x.FindGroupsByBook(projectId, startValue, countValue, filterByName, true));
if (result == null)
{
return(null);
}
var resultRoles = new List <UserGroupContract>();
foreach (var group in result.List)
{
if (group is RoleUserGroup roleUserGroup)
{
var work = new SynchronizeRoleWork(m_permissionRepository, m_communicationProvider, roleUserGroup.ExternalId);
work.Execute();
var authRoleContract = work.GetRoleContract();
var roleContract = m_mapper.Map <UserGroupContract>(authRoleContract);
roleContract.Id = group.Id;
resultRoles.Add(roleContract);
}
else
{
var roleContract = m_mapper.Map <UserGroupContract>(group);
resultRoles.Add(roleContract);
}
}
return(new PagedResultList <UserGroupContract>
{
List = resultRoles,
TotalCount = result.Count,
});
}
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);
}
}
