public IList <long> CreateFavoriteQuery(BookTypeEnumContract bookType, QueryTypeEnumContract queryType, string query, string title, IList <long> labelIds)
{
var now = DateTime.UtcNow;
var user = TryGetUser();
var labels = GetFavoriteLabelsAndCheckAuthorization(labelIds, user.Id);
var labelsDictionary = labels.ToDictionary(x => x.Id);
var itemsToSave = new List <FavoriteQuery>();
var bookTypeEnum = Mapper.Map <BookTypeEnum>(bookType);
var queryTypeEnum = Mapper.Map <QueryTypeEnum>(queryType);
var bookTypeEntity = m_bookVersionRepository.GetBookType(bookTypeEnum);
foreach (var labelId in labelIds)
{
var label = labelsDictionary[labelId];
label.LastUseTime = now;
var favoriteItem = new FavoriteQuery
{
BookType = bookTypeEntity,
Query = query,
QueryType = queryTypeEnum,
CreateTime = now,
User = user,
FavoriteLabel = label,
Title = title,
};
itemsToSave.Add(favoriteItem);
}
var result = m_favoritesRepository.CreateAll(itemsToSave);
return(result.Cast <long>().ToList());
}
public ActionResult GetFavoriteLabelsWithBooksAndCategories(BookTypeEnumContract bookType)
{
var client = GetFavoriteClient();
var result = client.GetFavoriteLabelsWithBooksAndCategories(bookType, GetDefaultProjectType());
return(Json(result));
}
public static string GetCategoryName(BookTypeEnumContract bookType)
{
switch (bookType)
{
case BookTypeEnumContract.Edition:
return("Edice");
case BookTypeEnumContract.Dictionary:
return("Slovníky");
case BookTypeEnumContract.Grammar:
return("Digitalizované mluvnice");
case BookTypeEnumContract.ProfessionalLiterature:
return("Odborná literatura");
case BookTypeEnumContract.TextBank:
return("Textová banka");
case BookTypeEnumContract.BibliographicalItem:
return("Bibliografie");
case BookTypeEnumContract.CardFile:
return("Kartotéky");
case BookTypeEnumContract.AudioBook:
return("Audio knihy");
default:
return(null);
}
}
public ActionResult GetFavoriteQueriesCount(long?labelId, BookTypeEnumContract bookType, QueryTypeEnumContract queryType, string filterByTitle)
{
using (var client = GetMainServiceClient())
{
var result = client.GetFavoriteQueriesCount(labelId, bookType, queryType, filterByTitle);
return(Json(result));
}
}
public ActionResult GetFavoriteLabelsWithBooksAndCategories(BookTypeEnumContract bookType)
{
using (var client = GetMainServiceClient())
{
var result = client.GetFavoriteLabelsWithBooksAndCategories(bookType);
return(Json(result));
}
}
public ActionResult GetFavoriteQueriesCount(long?labelId, BookTypeEnumContract bookType, QueryTypeEnumContract queryType,
string filterByTitle)
{
var client = GetFavoriteClient();
var result = client.GetFavoriteQueries(0, 0, labelId, bookType, queryType, filterByTitle);
return(Json(result.TotalCount));
}
public ActionResult GetFavoriteQueries(long?labelId, BookTypeEnumContract bookType, QueryTypeEnumContract queryType,
string filterByTitle, int start, int count)
{
var client = GetFavoriteClient();
var result = client.GetFavoriteQueries(start, count, labelId, bookType, queryType, filterByTitle);
return(Json(result.List));
}
private ActionResult RedirectToFavoriteQuery(BookTypeEnumContract bookType, QueryTypeEnumContract queryType, string query)
{
string area = null;
string action = null;
switch (bookType)
{
case BookTypeEnumContract.AudioBook:
area = "AudioBooks";
break;
case BookTypeEnumContract.BibliographicalItem:
area = "Bibliographies";
break;
case BookTypeEnumContract.CardFile:
area = "CardFiles";
break;
case BookTypeEnumContract.Dictionary:
area = "Dictionaries";
break;
case BookTypeEnumContract.Edition:
area = "Editions";
break;
case BookTypeEnumContract.Grammar:
area = "OldGrammar";
break;
case BookTypeEnumContract.ProfessionalLiterature:
area = "ProfessionalLiterature";
break;
case BookTypeEnumContract.TextBank:
area = "BohemianTextBank";
break;
}
switch (queryType)
{
case QueryTypeEnumContract.Search:
action = "Search";
break;
case QueryTypeEnumContract.List:
action = "List";
break;
case QueryTypeEnumContract.Reader:
return(View("AmbiguousFavoriteRedirect"));
}
return(RedirectToAction(action, area, new { area = area, search = query }));
}
public int GetFavoriteQueriesCount(long?labelId, BookTypeEnumContract bookType, QueryTypeEnumContract queryType, string filterByTitle)
{
var user = TryGetUser();
var bookTypeEnum = Mapper.Map <BookTypeEnum>(bookType);
var queryTypeEnum = Mapper.Map <QueryTypeEnum>(queryType);
var resultCount = m_favoritesRepository.GetFavoriteQueriesCount(labelId, bookTypeEnum, queryTypeEnum, filterByTitle, user.Id);
return(resultCount);
}
public IList <FavoriteQueryContract> GetFavoriteQueries(long?labelId, BookTypeEnumContract bookType, QueryTypeEnumContract queryType, string filterByTitle, int start, int count)
{
var user = TryGetUser();
var bookTypeEnum = Mapper.Map <BookTypeEnum>(bookType);
var queryTypeEnum = Mapper.Map <QueryTypeEnum>(queryType);
var dbResult = m_favoritesRepository.GetFavoriteQueries(labelId, bookTypeEnum, queryTypeEnum, filterByTitle, start, count, user.Id);
return(Mapper.Map <IList <FavoriteQueryContract> >(dbResult));
}
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 IList <string> GetTypeaheadAuthorsByBookType(string query, BookTypeEnumContract bookTypeContract)
{
var bookType = Mapper.Map <BookTypeEnum>(bookTypeContract);
if (string.IsNullOrWhiteSpace(query))
{
return(m_bookRepository.GetLastAuthorsByBookType(PrefetchRecordCount, bookType));
}
query = PrepareQuery(query);
return(m_bookRepository.GetTypeaheadAuthorsByBookType(query, bookType, PrefetchRecordCount));
}
public HeadwordListContract GetHeadwordList(IList <int> selectedCategoryIds, IList <long> selectedBookIds, int start, int count,
BookTypeEnumContract bookType)
{
var bookIds = GetCompleteBookIdList(selectedCategoryIds, selectedBookIds, Mapper.Map <BookTypeEnum>(bookType));
m_authorizationManager.FilterBookIdList(ref bookIds); //TODO HACK when all filtered, statement below returns all
var databaseResult = bookIds == null
? m_bookVersionRepository.GetHeadwordList(start, count)
: m_bookVersionRepository.GetHeadwordList(start, count, bookIds);
var result = ConvertHeadwordSearchToContract(databaseResult);
return(result);
}
public BookTypeSearchResultContract GetBooksWithCategoriesByBookType(BookTypeEnumContract bookType)
{
var type = Mapper.Map <BookTypeEnum>(bookType);
var books = m_bookRepository.FindBookVersionsByTypeWithCategories(type);
m_authorizationManager.FilterBookVersionsByCurrentUser(ref books);
var categories = m_categoryRepository.FindCategoriesByBookType(type);
return(new BookTypeSearchResultContract
{
BookType = bookType,
Books = Mapper.Map <IList <BookContractWithCategories> >(books),
Categories = Mapper.Map <IList <CategoryContract> >(categories)
});
}
public IList <string> GetTypeaheadTermsByBookType(string query, BookTypeEnumContract bookTypeContract, IList <int> selectedCategoryIds,
IList <long> selectedBookIds)
{
var bookType = Mapper.Map <BookTypeEnum>(bookTypeContract);
var bookIdList = GetCompleteBookIdList(selectedCategoryIds, selectedBookIds, bookType);
m_authorizationManager.FilterBookIdList(ref bookIdList);
if (string.IsNullOrWhiteSpace(query))
{
return(m_bookRepository.GetTermsByBookType(PrefetchRecordCount, bookType, bookIdList));
}
query = PrepareQuery(query);
return(m_bookRepository.GetTermsByBookType(query, bookType, bookIdList, PrefetchRecordCount));
}
public long GetHeadwordRowNumberById(IList <int> selectedCategoryIds, IList <long> selectedBookIds, string headwordBookId, string headwordEntryXmlId,
BookTypeEnumContract bookType)
{
var bookIds = GetCompleteBookIdList(selectedCategoryIds, selectedBookIds, Mapper.Map <BookTypeEnum>(bookType));
m_authorizationManager.FilterBookIdList(ref bookIds); //TODO HACK when all filtered, statement below returns all
var resultRowNumber = m_bookVersionRepository.GetHeadwordRowNumberById(bookIds, headwordBookId, headwordEntryXmlId);
if (resultRowNumber == 0)
{
throw new ArgumentException("Headword not found.");
}
return(resultRowNumber);
}
public List <BookWithCategoriesContract> GetBooksByType(BookTypeEnumContract bookTypeEnum, int start, int count)
{
try
{
var result = m_client.Get <List <BookWithCategoriesContract> >($"book/type/{bookTypeEnum}?start={start}&count={count}");
return(result);
}
catch (HttpRequestException e)
{
if (m_logger.IsErrorEnabled())
{
m_logger.LogError("{0} failed with {1}", m_client.GetCurrentMethod(), e);
}
throw;
}
}
public string GetBookPageByXmlId(string bookGuid, string pageXmlId, OutputFormatEnumContract resultFormat,
BookTypeEnumContract bookTypeContract)
{
if (m_log.IsDebugEnabled)
{
m_log.DebugFormat("Start MainService (BookManager) get page xmlId '{0}' of book '{1}'", pageXmlId,
bookGuid);
}
m_authorizationManager.AuthorizeBook(bookGuid);
OutputFormat outputFormat;
if (!Enum.TryParse(resultFormat.ToString(), true, out outputFormat))
{
throw new ArgumentException(string.Format("Result format : '{0}' unknown", resultFormat));
}
BookTypeEnum bookType;
if (!Enum.TryParse(bookTypeContract.ToString(), true, out bookType))
{
throw new ArgumentException(string.Format("Book type : '{0}' unknown", bookTypeContract));
}
var bookVersion = m_bookRepository.GetLastVersionForBookWithType(bookGuid);
var transformation = m_bookRepository.FindTransformation(bookVersion, outputFormat, bookType);
var transformationName = transformation.Name;
var transformationLevel = (ResourceLevelEnumContract)transformation.ResourceLevel;
var pageText = m_searchServiceClient.GetBookPageByXmlId(bookGuid, bookVersion.VersionId, pageXmlId,
transformationName, resultFormat, transformationLevel);
if (m_log.IsDebugEnabled)
{
m_log.DebugFormat("End MainService (BookManager) get page xmlId '{0}' of book '{1}'", pageXmlId,
bookGuid);
}
return(pageText);
}
public string GetBookPageByXmlId(string bookGuid, string pageXmlId, OutputFormatEnumContract resultFormat, BookTypeEnumContract bookTypeContract)
{
return(m_bookManager.GetBookPageByXmlId(bookGuid, pageXmlId, resultFormat, bookTypeContract));
}
public string GetDictionaryEntryByXmlId(string bookGuid, string xmlEntryId, OutputFormatEnumContract resultFormat, BookTypeEnumContract bookType)
{
return(m_bookManager.GetDictionaryEntryByXmlId(bookGuid, xmlEntryId, resultFormat, bookType));
}
public string GetDictionaryEntryFromSearch(IEnumerable <SearchCriteriaContract> searchCriterias, string bookGuid, string xmlEntryId,
OutputFormatEnumContract resultFormat, BookTypeEnumContract bookType)
{
return(m_searchManager.GetDictionaryEntryFromSearch(searchCriterias, bookGuid, xmlEntryId, resultFormat, bookType));
}
public IList <FavoriteQueryContract> GetFavoriteQueries(long?labelId, BookTypeEnumContract bookType, QueryTypeEnumContract queryType, string filterByTitle, int start, int count)
{
return(m_favoriteManager.GetFavoriteQueries(labelId, bookType, queryType, filterByTitle, start, count));
}
public string GetDictionaryEntryFromSearch(IEnumerable <SearchCriteriaContract> searchCriterias, string bookGuid, string xmlEntryId,
OutputFormatEnumContract resultFormat, BookTypeEnumContract bookTypeContract)
{
var criterias = searchCriterias.ToList();
m_authorizationManager.AuthorizeCriteria(criterias);
OutputFormat outputFormat;
if (!Enum.TryParse(resultFormat.ToString(), true, out outputFormat))
{
throw new ArgumentException(string.Format("Result format : '{0}' unknown", resultFormat));
}
var bookType = Mapper.Map <BookTypeEnum>(bookTypeContract);
var bookVersion = m_bookRepository.GetLastVersionForBookWithType(bookGuid);
var transformation = m_bookRepository.FindTransformation(bookVersion, outputFormat, bookType);
var transformationName = transformation.Name;
var transformationLevel = (ResourceLevelEnumContract)transformation.ResourceLevel;
var dictionaryEntryText = m_searchServiceClient.GetDictionaryEntryFromSearch(criterias,
bookGuid, bookVersion.VersionId, xmlEntryId, transformationName, resultFormat, transformationLevel);
return(dictionaryEntryText);
}
public int GetFavoriteQueriesCount(long?labelId, BookTypeEnumContract bookType, QueryTypeEnumContract queryType, string filterByTitle)
{
return(m_favoriteManager.GetFavoriteQueriesCount(labelId, bookType, queryType, filterByTitle));
}
public long GetHeadwordRowNumber(IList <int> selectedCategoryIds, IList <long> selectedBookIds, string query, BookTypeEnumContract bookType)
{
var bookIds = GetCompleteBookIdList(selectedCategoryIds, selectedBookIds, Mapper.Map <BookTypeEnum>(bookType));
m_authorizationManager.FilterBookIdList(ref bookIds); //TODO HACK when all filtered, statement below returns all
query = EscapeQuery(query);
var bookHeadword = m_bookVersionRepository.FindFirstHeadword(bookIds, query);
return(m_bookVersionRepository.GetHeadwordRowNumberById(bookIds, bookHeadword.BookVersion.Book.Guid,
bookHeadword.XmlEntryId));
}
public IList <FavoriteLabelWithBooksAndCategories> GetFavoriteLabelsWithBooksAndCategories(BookTypeEnumContract bookType)
{
return(m_favoriteManager.GetFavoriteLabelsWithBooksAndCategories(bookType));
}
public int GetHeadwordCount(IList <int> selectedCategoryIds, IList <long> selectedBookIds, BookTypeEnumContract bookType)
{
var bookIds = GetCompleteBookIdList(selectedCategoryIds, selectedBookIds, Mapper.Map <BookTypeEnum>(bookType));
m_authorizationManager.FilterBookIdList(ref bookIds); //TODO HACK when all filtered, statement below returns all
return(bookIds == null
? m_bookVersionRepository.GetHeadwordCount()
: m_bookVersionRepository.GetHeadwordCount(bookIds));
}
public IList <long> CreateFavoriteQuery(BookTypeEnumContract bookType, QueryTypeEnumContract queryType, string query, string title, IList <long> labelIds)
{
return(m_favoriteManager.CreateFavoriteQuery(bookType, queryType, query, title, labelIds));
}
public BookTypeSearchResultContract GetBooksWithCategoriesByBookType(BookTypeEnumContract bookType)
{
return(m_searchManager.GetBooksWithCategoriesByBookType(bookType));
}
public List <FavoriteLabelWithBooksAndCategories> GetFavoriteLabelsWithBooksAndCategories(BookTypeEnumContract bookType, ProjectTypeContract?projectType)
{
try
{
var url = UrlQueryBuilder.Create("favorite/label/with-books-and-categories")
.AddParameter("bookType", bookType)
.AddParameter("projectType", projectType)
.ToResult();
var result = m_client.Get <List <FavoriteLabelWithBooksAndCategories> >(url);
return(result);
}
catch (HttpRequestException e)
{
if (m_logger.IsErrorEnabled())
{
m_logger.LogError("{0} failed with {1}", m_client.GetCurrentMethod(), e);
}
throw;
}
}
