protected override void ProcessElement(BookVersion bookVersion, XmlReader xmlReader)
{
var responsible = new Responsible();
while (xmlReader.Read())
{
if (xmlReader.NodeType == XmlNodeType.Element && xmlReader.IsStartElement() &&
xmlReader.LocalName.Equals("resp"))
{
xmlReader.Read(); //read text value
var responsibleTypeText = xmlReader.Value;
var responsibleTypeType = ParseEnum <ResponsibleTypeEnum>(responsibleTypeText);
var tmpResponsibleType = new ResponsibleType
{
Text = responsibleTypeText,
Type = responsibleTypeType
};
m_bookVersionRepository.CreateResponsibleTypeIfNotExist(tmpResponsibleType);
responsible.ResponsibleType = m_bookVersionRepository.FindResponsibleType(responsibleTypeText, responsibleTypeType);
}
if (xmlReader.NodeType == XmlNodeType.Element && xmlReader.IsStartElement() &&
xmlReader.LocalName.Equals("name"))
{
responsible.Text = GetInnerContentAsString(xmlReader);
}
}
responsible = m_bookVersionRepository.FindResponsible(responsible.Text, responsible.ResponsibleType) ??
responsible;
bookVersion.Responsibles.Add(responsible);
}
private List <ResponsibleType> GetOrCreateResponsibleType(string text)
{
var resultList = new List <ResponsibleType>();
var typeTexts = text.Split(',');
foreach (var typeText in typeTexts)
{
var trimmedTypeText = typeText.Trim();
var responsibleType = m_personRepository.GetResponsibleTypeByName(trimmedTypeText);
if (responsibleType != null)
{
resultList.Add(responsibleType);
continue;
}
ResponsibleTypeEnum typeEnum;
Enum.TryParse(trimmedTypeText, true, out typeEnum);
responsibleType = new ResponsibleType
{
Text = trimmedTypeText,
Type = typeEnum
};
m_projectRepository.Create(responsibleType);
resultList.Add(responsibleType);
}
return(resultList);
}
protected override int ExecuteWorkImplementation()
{
var typeEnum = Mapper.Map <ResponsibleTypeEnum>(m_data.Type);
var responsibleType = new ResponsibleType
{
Text = m_data.Text,
Type = typeEnum
};
return((int)m_personRepository.Create(responsibleType));
}
public virtual void CreateResponsibleTypeIfNotExist(ResponsibleType responsibleType)
{
using (var session = GetSession())
{
var tmpResponsibleType = FindResponsibleType(responsibleType.Text, responsibleType.Type);
if (tmpResponsibleType == null)
{
session.Save(responsibleType);
}
}
}
public virtual Responsible FindResponsible(string text, ResponsibleType respType)
{
using (var session = GetSession())
{
var responsibleType = FindResponsibleType(respType.Text, respType.Type) ?? respType;
return
(session.QueryOver <Responsible>()
.Where(
responsible =>
responsible.Text == text && responsible.ResponsibleType.Id == responsibleType.Id)
.SingleOrDefault <Responsible>());
}
}
public virtual MetadataResource GetMetadataWithDetail(long projectId)
{
Resource resourceAlias = null;
Project projectAlias = null;
Snapshot snapshotAlias = null;
BookType bookTypeAlias = null;
ProjectOriginalAuthor projectOriginalAuthorAlias = null;
OriginalAuthor originalAuthorAlias = null;
ProjectResponsiblePerson projectResponsiblePersonAlias = null;
ResponsiblePerson responsiblePersonAlias = null;
ResponsibleType responsibleTypeAlias = null;
var session = GetSession();
var result = session.QueryOver <MetadataResource>()
.JoinAlias(x => x.Resource, () => resourceAlias)
.JoinAlias(() => resourceAlias.Project, () => projectAlias)
.JoinAlias(() => projectAlias.LatestPublishedSnapshot, () => snapshotAlias, JoinType.LeftOuterJoin)
.JoinAlias(() => snapshotAlias.DefaultBookType, () => bookTypeAlias, JoinType.LeftOuterJoin)
.Where(x => x.Id == resourceAlias.LatestVersion.Id && !resourceAlias.IsRemoved && resourceAlias.Project.Id == projectId && projectAlias.IsRemoved == false)
.FutureValue();
session.QueryOver <Project>()
.Where(x => x.Id == projectId)
.Fetch(SelectMode.Fetch, x => x.Keywords)
.Future();
session.QueryOver <Project>()
.Where(x => x.Id == projectId)
.Fetch(SelectMode.Fetch, x => x.LiteraryGenres)
.Future();
session.QueryOver <Project>()
.Where(x => x.Id == projectId)
.Fetch(SelectMode.Fetch, x => x.LiteraryKinds)
.Future();
session.QueryOver <Project>()
.Where(x => x.Id == projectId)
.Fetch(SelectMode.Fetch, x => x.LiteraryOriginals)
.Future();
session.QueryOver <Project>()
.Where(x => x.Id == projectId)
.JoinAlias(x => x.Authors, () => projectOriginalAuthorAlias, JoinType.LeftOuterJoin)
.JoinAlias(() => projectOriginalAuthorAlias.OriginalAuthor, () => originalAuthorAlias, JoinType.LeftOuterJoin)
.Fetch(SelectMode.Fetch, x => x.Authors)
.Fetch(SelectMode.Fetch, x => x.Authors[0].OriginalAuthor)
.OrderBy(() => projectOriginalAuthorAlias.Sequence).Asc
.Future();
session.QueryOver <Project>()
.Where(x => x.Id == projectId)
.JoinAlias(x => x.ResponsiblePersons, () => projectResponsiblePersonAlias, JoinType.LeftOuterJoin)
.JoinAlias(() => projectResponsiblePersonAlias.ResponsiblePerson, () => responsiblePersonAlias, JoinType.LeftOuterJoin)
.JoinAlias(() => projectResponsiblePersonAlias.ResponsibleType, () => responsibleTypeAlias, JoinType.LeftOuterJoin)
.Fetch(SelectMode.Fetch, x => x.ResponsiblePersons)
.Fetch(SelectMode.Fetch, x => x.ResponsiblePersons[0].ResponsiblePerson)
.Fetch(SelectMode.Fetch, x => x.ResponsiblePersons[0].ResponsibleType)
.OrderBy(() => projectResponsiblePersonAlias.Sequence).Asc
.Future();
return(result.Value);
}
public virtual BookVersion GetBookVersionDetailByBookId(long bookId)
{
using (var session = GetSession())
{
Book bookAlias = null;
BookVersion bookVersionAlias = null;
Responsible responsibleAlias = null;
ResponsibleType responsibleTypeAlias = null;
LiteraryOriginal literaryOriginalAlias = null;
LiteraryKind literaryKindAlias = null;
LiteraryGenre genreAlias = null;
var query = session.QueryOver(() => bookVersionAlias)
.JoinAlias(x => x.Book, () => bookAlias)
.Where(() => bookAlias.LastVersion.Id == bookVersionAlias.Id)
.And(x => bookAlias.Id == bookId);
var futureResult = query
.Fetch(x => x.Book).Eager
.Fetch(x => x.Publisher).Eager
.Fetch(x => x.DefaultBookType).Eager
.FutureValue <BookVersion>();
session.QueryOver(() => bookVersionAlias)
.JoinAlias(x => x.Book, () => bookAlias)
.Where(() => bookAlias.LastVersion.Id == bookVersionAlias.Id)
.And(x => bookAlias.Id == bookId)
.Fetch(x => x.ManuscriptDescriptions).Eager
.FutureValue <BookVersion>();
session.QueryOver(() => bookVersionAlias)
.JoinAlias(x => x.Book, () => bookAlias)
.Where(() => bookAlias.LastVersion.Id == bookVersionAlias.Id)
.And(x => bookAlias.Id == bookId)
.Fetch(x => x.Authors).Eager
.FutureValue <BookVersion>();
session.QueryOver(() => bookVersionAlias)
.JoinAlias(x => x.Book, () => bookAlias)
.Where(() => bookAlias.LastVersion.Id == bookVersionAlias.Id)
.And(x => bookAlias.Id == bookId)
.Fetch(x => x.Keywords).Eager
.FutureValue <BookVersion>();
session.QueryOver(() => bookVersionAlias)
.JoinAlias(x => x.Book, () => bookAlias)
.Where(() => bookAlias.LastVersion.Id == bookVersionAlias.Id)
.And(x => bookAlias.Id == bookId)
.Fetch(x => x.FullBookRecordings).Eager
.FutureValue <BookVersion>();
session.QueryOver(() => bookVersionAlias)
.JoinAlias(x => x.Book, () => bookAlias)
.Where(() => bookAlias.LastVersion.Id == bookVersionAlias.Id)
.And(x => bookAlias.Id == bookId)
.Left.JoinAlias(() => bookVersionAlias.Responsibles, () => responsibleAlias)
.Left.JoinAlias(() => responsibleAlias.ResponsibleType, () => responsibleTypeAlias)
.FutureValue <BookVersion>();
session.QueryOver(() => bookVersionAlias)
.JoinAlias(x => x.Book, () => bookAlias)
.Where(() => bookAlias.LastVersion.Id == bookVersionAlias.Id)
.And(x => bookAlias.Id == bookId)
.Left.JoinAlias(() => bookVersionAlias.LiteraryOriginals, () => literaryOriginalAlias)
.Fetch(x => x.LiteraryOriginals).Eager
.FutureValue <BookVersion>();
session.QueryOver(() => bookVersionAlias)
.JoinAlias(x => x.Book, () => bookAlias)
.Where(() => bookAlias.LastVersion.Id == bookVersionAlias.Id)
.And(x => bookAlias.Id == bookId)
.Left.JoinAlias(() => bookVersionAlias.LiteraryKinds, () => literaryKindAlias)
.Fetch(x => x.LiteraryKinds).Eager
.FutureValue <BookVersion>();
session.QueryOver(() => bookVersionAlias)
.JoinAlias(x => x.Book, () => bookAlias)
.Where(() => bookAlias.LastVersion.Id == bookVersionAlias.Id)
.And(x => bookAlias.Id == bookId)
.Left.JoinAlias(() => bookVersionAlias.LiteraryGenres, () => genreAlias)
.Fetch(x => x.LiteraryGenres).Eager
.FutureValue <BookVersion>();
var result = futureResult.Value;
return(result);
}
}
