public virtual BookPage GetPageByXmlId(string bookXmlId, string pageXmlId)
{
using (var session = GetSession())
{
BookPage page = null;
BookVersion version = null;
var resultPage = session.QueryOver(() => page)
.JoinQueryOver(x => x.BookVersion, () => version)
.JoinQueryOver(x => x.Book)
.Where(
book => book.Guid == bookXmlId && version.Id == book.LastVersion.Id && page.XmlId == pageXmlId)
.SingleOrDefault <BookPage>();
return(resultPage);
}
}
public virtual BookHeadword GetFirstHeadwordInfo(string bookXmlId, string entryXmlId, string bookVersionXmlId)
{
using (var session = GetSession())
{
BookVersion bookVersionAlias = null;
Book bookAlias = null;
var result = session.QueryOver <BookHeadword>()
.JoinAlias(x => x.BookVersion, () => bookVersionAlias)
.JoinAlias(() => bookVersionAlias.Book, () => bookAlias)
.Where(x => x.XmlEntryId == entryXmlId && bookAlias.Guid == bookXmlId)
.And(() => bookVersionAlias.VersionId == bookVersionXmlId)
.Take(1)
.SingleOrDefault <BookHeadword>();
return(result);
}
}
public virtual BookPage FindBookPageByXmlIdAndPosition(string bookXmlId, int position)
{
using (var session = GetSession())
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
var bookPage =
session.QueryOver <BookPage>()
.JoinAlias(page => page.BookVersion, () => bookVersionAlias)
.JoinAlias(() => bookVersionAlias.Book, () => bookAlias)
.Where(
page =>
bookAlias.Guid == bookXmlId && bookAlias.LastVersion.Id == bookVersionAlias.Id &&
page.Position == position)
.SingleOrDefault <BookPage>();
return(bookPage);
}
}
public virtual BookPage FindBookPageByXmlId(string bookXmlId, string xmlId)
{
using (var session = GetSession())
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
var bookPage =
session.QueryOver <BookPage>()
.JoinAlias(x => x.BookVersion, () => bookVersionAlias)
.JoinAlias(() => bookVersionAlias.Book, () => bookAlias)
.Where(
x =>
bookAlias.Guid == bookXmlId && bookAlias.LastVersion.Id == bookVersionAlias.Id &&
x.XmlId == xmlId)
.SingleOrDefault <BookPage>();
return(bookPage);
}
}
public virtual int CountBookImageByXmlId(string bookXmlId, string versionId)
{
using (var session = GetSession())
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
var bookImages =
session.QueryOver <BookPage>()
.JoinAlias(bookPage => bookPage.BookVersion, () => bookVersionAlias)
.JoinAlias(() => bookVersionAlias.Book, () => bookAlias)
.Where(
bookPage =>
bookAlias.Guid == bookXmlId && bookVersionAlias.VersionId == versionId &&
bookPage.Image != null)
.RowCount();
return(bookImages);
}
}
public void GroupBy()
{
var book1 = new Book();
DataStore.Insert(book1);
var book1Version1 = new BookVersion {
BookId = book1.Id
};
DataStore.Insert(book1Version1);
var book2 = new Book();
DataStore.Insert(book2);
var book2Version1 = new BookVersion {
BookId = book2.Id
};
DataStore.Insert(book2Version1);
var book2Version2 = new BookVersion {
BookId = book2.Id
};
DataStore.Insert(book2Version2);
var bookId = DataStore.GetColumn <BookVersion>(BookVersion.BookIdColName);
var bookUsage = DataStore.Select <BookVersion>()
.GroupBy(bookId)
.OrderBy(bookId)
.Count(bookId)
.ToList();
Assert.AreEqual(2, bookUsage.Count);
Assert.AreEqual(2, bookUsage[0].ColumnValues.Count);
Assert.AreEqual(1, bookUsage[0].ColumnValues["count"]);
Assert.AreEqual(book1.Id, bookUsage[0].ColumnValues[bookId.AliasFiledName]);
Assert.AreEqual(2, bookUsage[1].ColumnValues.Count);
Assert.AreEqual(2, bookUsage[1].ColumnValues["count"]);
Assert.AreEqual(book2.Id, bookUsage[1].ColumnValues[bookId.AliasFiledName]);
}
public BookVersion GetXmlMetadata(Stream xlmData)
{
var bookVersion = new BookVersion();
using (var xmlReader = new XmlTextReader(xlmData)
{
WhitespaceHandling = WhitespaceHandling.None
})
{
while (xmlReader.Read())
{
if (xmlReader.NodeType == XmlNodeType.Element && xmlReader.IsStartElement() &&
xmlReader.LocalName.Equals(m_documentProcessor.XmlRootName))
{
m_documentProcessor.Process(bookVersion, xmlReader);
}
}
}
return(bookVersion);
}
public virtual IList <Term> GetTermsOnPage(string bookXmlId, string pageXmlId)
{
using (var session = GetSession())
{
Term term = null;
BookPage page = null;
BookVersion version = null;
var terms = session.QueryOver(() => term)
.JoinQueryOver(x => term.ReferencedFrom, () => page)
.JoinQueryOver(x => page.BookVersion, () => version)
.JoinQueryOver(x => version.Book)
.Where(
book => book.Guid == bookXmlId && version.Id == book.LastVersion.Id && page.XmlId == pageXmlId)
.OrderBy(() => term.Position).Asc
.List <Term>();
return(terms);
}
}
protected override void ProcessElement(BookVersion bookVersion, Track track, XmlReader xmlReader)
{
if (track.Recordings == null)
{
track.Recordings = new List <TrackRecording>();
}
var fileName = xmlReader.GetAttribute("url");
track.Recordings.Add(
new TrackRecording
{
Track = track,
FileName = fileName,
AudioType = ParseAudioType(fileName),
MimeType = xmlReader.GetAttribute("mimeType"),
Length = TimeSpan.Parse(xmlReader.GetAttribute("length"))
});
}
public virtual IList <FavoriteBook> GetFavoriteBooksWithLabel(BookTypeEnum bookType, int userId)
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
Category categoryAlias = null;
BookType bookTypeAlias = null;
using (var session = GetSession())
{
return(session.QueryOver <FavoriteBook>()
.JoinAlias(x => x.Book, () => bookAlias)
.JoinAlias(() => bookAlias.LastVersion, () => bookVersionAlias)
.JoinAlias(() => bookVersionAlias.Categories, () => categoryAlias)
.JoinAlias(() => categoryAlias.BookType, () => bookTypeAlias)
.Where(x => x.User.Id == userId && bookTypeAlias.Type == bookType)
.Fetch(x => x.FavoriteLabel).Eager
.OrderBy(x => x.Title).Asc
.List());
}
}
public virtual IList <string> GetLastAuthorsByBookType(int recordCount, BookTypeEnum bookType)
{
using (var session = GetSession())
{
BookVersion bookVersionAlias = null;
Author authorAlias = null;
Category categoryAlias = null;
BookType bookTypeAlias = null;
return(session.QueryOver <Book>()
.JoinQueryOver(x => x.LastVersion, () => bookVersionAlias)
.JoinQueryOver(x => bookVersionAlias.Authors, () => authorAlias)
.JoinQueryOver(x => bookVersionAlias.Categories, () => categoryAlias)
.JoinQueryOver(x => categoryAlias.BookType, () => bookTypeAlias)
.Select(Projections.Distinct(Projections.Property(() => authorAlias.Name)))
.Where(x => bookTypeAlias.Type == bookType)
.Take(recordCount)
.List <string>());
}
}
protected override void ProcessAttributes(BookVersion bookVersion, XmlReader xmlReader)
{
string bookGuid = xmlReader.GetAttribute("n");
Book book = m_bookRepository.FindBookByGuid(bookGuid) ?? new Book {
Guid = bookGuid
};
//string docType = xmlReader.GetAttribute("doctype");
//BookTypeEnum bookTypeEnum;
//Enum.TryParse(docType, true, out bookTypeEnum);
//var bookType = m_bookRepository.FindBookType(bookTypeEnum) ?? new BookType {Type = bookTypeEnum};
//book.BookType = bookType;
bookVersion.Book = book;
book.LastVersion = bookVersion;
string versionId = xmlReader.GetAttribute("versionId");
bookVersion.VersionId = versionId;
}
public virtual IList <BookVersion> FindBookVersionsByTypeWithAuthors(BookTypeEnum bookType)
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
BookType bookTypeAlias = null;
Category categoryAlias = null;
using (var session = GetSession())
{
var result = session.QueryOver(() => bookVersionAlias)
.JoinAlias(() => bookVersionAlias.Categories, () => categoryAlias)
.JoinAlias(() => categoryAlias.BookType, () => bookTypeAlias)
.JoinAlias(() => bookVersionAlias.Book, () => bookAlias)
.Where(() => bookTypeAlias.Type == bookType && bookVersionAlias.Id == bookAlias.LastVersion.Id)
.Fetch(x => x.Authors).Eager
.OrderBy(() => bookVersionAlias.Title).Asc
.TransformUsing(Transformers.DistinctRootEntity)
.List();
return(result);
}
}
public virtual IList <BookContentItem> GetRootBookContentItemsWithPagesAndAncestors(string bookXmlId)
{
using (var session = GetSession())
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
var bookContentItems =
session.QueryOver <BookContentItem>()
.JoinAlias(x => x.BookVersion, () => bookVersionAlias)
.JoinAlias(() => bookVersionAlias.Book, () => bookAlias)
.Fetch(x => x.Page).Eager
.Fetch(x => x.ChildContentItems).Eager
.Where(x => bookAlias.Guid == bookXmlId && bookAlias.LastVersion.Id == bookVersionAlias.Id)
.TransformUsing(Transformers.DistinctRootEntity)
.List <BookContentItem>()
.Where(x => x.ParentBookContentItem == null)
.ToList();
return(bookContentItems);
}
}
public void SelectLeftJoin_OneToManyRelation_NullRelationShouldBeNull()
{
var book1 = new Book();
DataStore.Insert(book1);
var book1Version1 = new BookVersion { BookId = book1.Id };
DataStore.Insert(book1Version1);
var book2Version1 = new BookVersion();
DataStore.Insert(book2Version1);
var bookVersionList = DataStore.Select<BookVersion>()
.LeftJoin<BookVersion, Book>()
.GetValues()
.ToList();
Assert.AreEqual(2, bookVersionList.Count);
Assert.AreEqual(book1.Id, bookVersionList[0].BookId);
Assert.IsNotNull(bookVersionList[0].Book);
Assert.AreEqual(null, bookVersionList[1].BookId);
Assert.IsNull(bookVersionList[1].Book);
}
public virtual IList <BookVersion> FindChildBookVersionsInCategory(int categoryId)
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
BookType bookTypeAlias = null;
Category categoryAlias = null;
using (var session = GetSession())
{
var bookVersions =
session.QueryOver(() => bookVersionAlias)
.JoinAlias(() => bookVersionAlias.Categories, () => categoryAlias)
.JoinAlias(() => categoryAlias.BookType, () => bookTypeAlias)
.JoinAlias(() => bookVersionAlias.Book, () => bookAlias)
.Where(() => categoryAlias.Id == categoryId && bookVersionAlias.Id == bookAlias.LastVersion.Id)
.OrderBy(() => bookVersionAlias.Title).Asc
.TransformUsing(Transformers.DistinctRootEntity)
.List <BookVersion>();
return(bookVersions);
}
}
public virtual IList <BookVersion> SearchByTitleAndBookType(string text, BookTypeEnum bookType)
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
BookType bookTypeAlias = null;
Category categoryAlias = null;
using (var session = GetSession())
{
var bookVersions =
session.QueryOver(() => bookVersionAlias)
.JoinAlias(() => bookVersionAlias.Categories, () => categoryAlias, JoinType.InnerJoin)
.JoinAlias(() => categoryAlias.BookType, () => bookTypeAlias, JoinType.InnerJoin)
.JoinAlias(() => bookVersionAlias.Book, () => bookAlias, JoinType.InnerJoin)
.Where(() => bookTypeAlias.Type == bookType && bookVersionAlias.Id == bookAlias.LastVersion.Id)
.AndRestrictionOn(() => bookVersionAlias.Title).IsLike(text, MatchMode.Anywhere)
.Fetch(x => x.Authors).Eager
.TransformUsing(Transformers.DistinctRootEntity)
.List <BookVersion>();
return(bookVersions);
}
}
public void SelectGroupBy_ShouldReturn_RightResult()
{
var book1 = new Book();
DataStore.Insert(book1);
var book1Version1 = new BookVersion {
BookId = book1.Id
};
DataStore.Insert(book1Version1);
var book2 = new Book();
DataStore.Insert(book2);
var book2Version1 = new BookVersion {
BookId = book2.Id
};
DataStore.Insert(book2Version1);
var book2Version2 = new BookVersion {
BookId = book2.Id
};
DataStore.Insert(book2Version2);
var bookId = DataStore.GetColumn <BookVersion>(BookVersion.BookIdColName);
var bookUsage = DataStore.Select <BookVersion>()
.GroupBy(bookId)
.OrderBy(bookId)
.Count(bookId)
.ToList();
Assert.AreEqual(2, bookUsage.Count);
Assert.AreEqual(book1.Id, bookUsage[0].Key[0]);
Assert.AreEqual(1, bookUsage[0].Value);
Assert.AreEqual(book2.Id, bookUsage[1].Key[0]);
Assert.AreEqual(2, bookUsage[1].Value);
}
public virtual IList <HeadwordSearchResult> GetHeadwordList(int start, int count,
IList <long> selectedBookIds = null)
{
using (var session = GetSession())
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
BookHeadword bookHeadwordAlias = null;
HeadwordSearchResult resultAlias = null;
var query = session.QueryOver(() => bookAlias)
.JoinQueryOver(x => x.LastVersion, () => bookVersionAlias)
.JoinQueryOver(x => x.BookHeadwords, () => bookHeadwordAlias);
if (selectedBookIds != null)
{
query.WhereRestrictionOn(() => bookAlias.Id).IsInG(selectedBookIds);
}
var result = query.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.XmlEntryId).WithAlias(() => resultAlias.XmlEntryId))
.Add(Projections.Property(() => bookHeadwordAlias.SortOrder).WithAlias(() => resultAlias.SortOrder))
.Add(Projections.Property(() => bookHeadwordAlias.Image).WithAlias(() => resultAlias.Image))))
.OrderBy(x => x.SortOrder).Asc
.TransformUsing(Transformers.AliasToBean <HeadwordSearchResult>())
.Skip(start)
.Take(count)
.List <HeadwordSearchResult>();
return(result);
}
}
public void SelectJoin_ManyToOneRelation_RelationShouldSharedSameObject()
{
var author = new Author();
DataStore.Insert(author);
var book = new Book { AuthorId = author.Id };
DataStore.Insert(book);
var bookVersion1 = new BookVersion { BookId = book.Id };
var bookVersion2 = new BookVersion { BookId = book.Id };
DataStore.Insert(bookVersion1);
DataStore.Insert(bookVersion2);
var bookVersionList = DataStore.Select<BookVersion>()
.Join<BookVersion, Book>()
.Join<Book, Author>()
.GetValues()
.ToList();
Assert.AreEqual(2, bookVersionList.Count);
Assert.IsNotNull(bookVersionList[0].Book);
Assert.AreSame(bookVersionList[0].Book, bookVersionList[1].Book);
Assert.IsNotNull(bookVersionList[0].Book.Author);
Assert.AreSame(bookVersionList[0].Book.Author, bookVersionList[1].Book.Author);
}
public virtual TrackRecording GetRecordingByTrackAndAudioType(long bookId, long trackPosition,
AudioType audioType)
{
using (var session = GetSession())
{
Track trackAlias = null;
BookVersion bookVersionAlias = null;
Book bookAlias = null;
var trackId = session.QueryOver(() => bookAlias)
.JoinQueryOver(x => x.LastVersion, () => bookVersionAlias)
.JoinQueryOver(x => x.Tracks, () => trackAlias)
.Where(x => trackAlias.Position == trackPosition && bookAlias.Id == bookId)
.Select(Projections.Property(() => trackAlias.Id))
.Take(1)
.SingleOrDefault <long>();
return(session.QueryOver <TrackRecording>()
.Where(x => x.Track.Id == trackId && x.AudioType == audioType)
.Take(1)
.SingleOrDefault <TrackRecording>());
}
}
protected override void ProcessAttributes(BookVersion bookVersion, XmlReader xmlReader)
{
var position = bookVersion.Accessories.Count + 1;
var typeString = xmlReader.GetAttribute("type");
var fileName = xmlReader.GetAttribute("name");
if (string.IsNullOrEmpty(typeString) && m_log.IsFatalEnabled)
{
m_log.ErrorFormat("Metadata_processor : Accessory in position {0} does not have type attribute", position);
}
var type = GetTypeByTypeString(typeString);
var accessory = new BookAccessory
{
FileName = fileName,
BookVersion = bookVersion,
Type = type
};
bookVersion.Accessories.Add(accessory);
}
public virtual IList <string> GetLastTypeaheadHeadwords(int recordCount, IList <long> selectedBookIds = null)
{
using (var session = GetSession())
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
BookHeadword bookHeadwordAlias = null;
var dbQuery = session.QueryOver(() => bookAlias)
.JoinQueryOver(x => x.LastVersion, () => bookVersionAlias)
.JoinQueryOver(x => x.BookHeadwords, () => bookHeadwordAlias)
.Select(Projections.Distinct(Projections.Property(() => bookHeadwordAlias.Headword)))
.Where(x => x.Visibility == VisibilityEnum.Public);
if (selectedBookIds != null)
{
dbQuery.AndRestrictionOn(() => bookAlias.Id).IsInG(selectedBookIds);
}
return(dbQuery
.Take(recordCount)
.List <string>());
}
}
protected override void ProcessElement(BookVersion bookVersion, Category parentCategory, XmlReader xmlReader)
{
string xmlId = xmlReader.GetAttribute("xml:id");
var category = m_categoryRepository.FindByXmlId(xmlId);
if (category == null)
{
category = new Category
{
XmlId = xmlId,
ParentCategory = parentCategory
};
if (parentCategory != null)
{
category.BookType = parentCategory.BookType;
category.Path = string.Format("{0}{1}/", parentCategory.Path, xmlId);
}
else
{
category.Path = string.Format("/{0}/", xmlId);
}
m_categoryRepository.SaveOrUpdate(category);
var newlyCreatedCategory = m_categoryRepository.FindByXmlId(category.XmlId);
var newAutoimportPermission = new AutoImportCategoryPermission
{
Category = newlyCreatedCategory,
AutoImportIsAllowed = true
};
m_permissionRepository.CreateSpecialPermission(newAutoimportPermission);
}
base.ProcessElement(bookVersion, category, xmlReader);
m_categoryRepository.SaveOrUpdate(category);
}
public virtual Transformation FindTransformation(BookVersion bookVersion, OutputFormat outputFormat, BookTypeEnum requestedBookType)
{
BookVersion bookVersionAlias = null;
BookType bookTypeAlias = null;
using (var session = GetSession())
{
var transformation = session.QueryOver <Transformation>()
.JoinAlias(t => t.BookVersions, () => bookVersionAlias)
.JoinAlias(t => t.BookType, () => bookTypeAlias)
.Where(t => t.OutputFormat == outputFormat && bookVersionAlias.Id == bookVersion.Id && bookTypeAlias.Type == requestedBookType)
.SingleOrDefault <Transformation>();
if (transformation == null)
{
transformation = session.QueryOver <Transformation>()
.JoinAlias(x => x.BookType, () => bookTypeAlias)
.Where(x => x.OutputFormat == outputFormat && x.IsDefaultForBookType && bookTypeAlias.Type == requestedBookType)
.SingleOrDefault <Transformation>();
}
return(transformation);
}
}
protected override void SaveInstance(ManuscriptDescription instance, BookVersion bookVersion)
{
bookVersion.ManuscriptDescriptions.Add(instance);
}
protected override ManuscriptDescription LoadInstance(BookVersion bookVersion)
{
return(new ManuscriptDescription());
}
protected virtual void ProcessAttributes(BookVersion bookVersion, XmlReader xmlReader)
{
}
protected virtual void PreprocessSetup(BookVersion bookVersion)
{
}
protected override void ProcessElement(BookVersion bookVersion, ManuscriptDescription msDesc, XmlReader xmlReader)
{
msDesc.Title = GetInnerContentAsString(xmlReader);
}
