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 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 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);
}
}
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 <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 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 <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 <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 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 <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 <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 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 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 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 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);
}
}
public PagedResultList <ProjectDetailContract> GetProjectList(int?start, int?count, ProjectTypeContract?projectType,
ProjectOwnerTypeContract projectOwnerType, string filterByName, bool fetchPageCount, bool fetchAuthors,
bool fetchResponsiblePersons, bool fetchLatestChangedResource, bool fetchPermissions)
{
var startValue = PagingHelper.GetStart(start);
var countValue = PagingHelper.GetCountForProject(count);
var projectTypeEnum = m_mapper.Map <ProjectTypeEnum?>(projectType);
var userId = m_authenticationManager.GetCurrentUserId();
var work = new GetProjectListWork(m_projectRepository, m_metadataRepository, startValue, countValue, projectTypeEnum,
projectOwnerType, userId, filterByName, fetchPageCount, fetchAuthors, fetchResponsiblePersons, fetchLatestChangedResource, fetchPermissions);
var resultEntities = work.Execute();
var metadataList = work.GetMetadataResources();
var pageCountList = work.GetPageCountList();
var latestChangesList = work.GetLatestChangedResources();
var userPermissionDict = work.GetUserPermission();
var resultList = m_mapper.Map <List <ProjectDetailContract> >(resultEntities);
foreach (var projectContract in resultList)
{
var metadataResource = metadataList.FirstOrDefault(x => x.Resource.Project.Id == projectContract.Id);
var pageCountResult = pageCountList.FirstOrDefault(x => x.ProjectId == projectContract.Id);
var latestChangeResult = latestChangesList.FirstOrDefault(x => x.ProjectId == projectContract.Id);
var metadataContract = m_mapper.Map <ProjectMetadataContract>(metadataResource);
projectContract.LatestMetadata = metadataContract;
projectContract.PageCount = pageCountResult?.PageCount;
projectContract.CreatedByUser = m_userDetailManager.GetUserContractForUser(projectContract.CreatedByUser);
if (fetchAuthors && metadataResource != null)
{
projectContract.Authors = m_mapper.Map <List <OriginalAuthorContract> >(metadataResource.Resource.Project.Authors);
}
if (fetchResponsiblePersons && metadataResource != null)
{
projectContract.ResponsiblePersons =
m_mapper.Map <List <ProjectResponsiblePersonContract> >(metadataResource.Resource.Project.ResponsiblePersons);
}
if (fetchLatestChangedResource && latestChangeResult != null)
{
projectContract.LatestChangeTime = latestChangeResult.CreateTime;
projectContract.EditedByUser = m_userDetailManager.GetUserContract(latestChangeResult.CreatedByUserId);
}
if (fetchPermissions)
{
userPermissionDict.TryGetValue(projectContract.Id, out var permissions);
projectContract.CurrentUserPermissions = m_projectPermissionConverter.GetAggregatedPermissions(permissions);
}
}
return(new PagedResultList <ProjectDetailContract>
{
List = resultList,
TotalCount = work.GetResultCount()
});
}