public virtual ListWithTotalCountResult <MetadataResource> GetMetadataByAuthor(int authorId, int start, int count)
{
Resource resourceAlias = null;
Project projectAlias = null;
ProjectOriginalAuthor projectOriginalAuthorAlias = null;
User userAlias = null;
var query = GetSession().QueryOver <MetadataResource>()
.JoinAlias(x => x.Resource, () => resourceAlias)
.JoinAlias(() => resourceAlias.Project, () => projectAlias)
.JoinAlias(() => projectAlias.Authors, () => projectOriginalAuthorAlias)
.JoinAlias(() => projectAlias.CreatedByUser, () => userAlias) // fetch user
.Where(x => x.Id == resourceAlias.LatestVersion.Id && !resourceAlias.IsRemoved && projectOriginalAuthorAlias.OriginalAuthor.Id == authorId && projectAlias.IsRemoved == false)
.OrderBy(x => x.Title).Asc
.Take(count)
.Skip(start);
var countFuture = query.ToRowCountQuery()
.FutureValue <int>();
var metadata = query.Future()
.ToList();
var projectIds = metadata.Select(x => x.Resource.Project.Id).ToList();
FetchAuthorsAndResponsibles(projectIds);
return(new ListWithTotalCountResult <MetadataResource>
{
List = metadata,
Count = countFuture.Value,
});
}
private void UpdateAuthors(Project project)
{
if (project.Authors == null)
{
project.Authors = new List <ProjectOriginalAuthor>();
}
var dbAuthors = project.Authors.Select(x => x.OriginalAuthor).ToList();
var newAuthors =
m_importedRecord.ImportedProject.Authors.Select(x => new OriginalAuthor {
FirstName = x.FirstName, LastName = x.LastName
})
.ToList();
var comparer = new AuthorNameEqualityComparer();
var authorsToAdd = newAuthors.Except(dbAuthors, comparer).ToList();
var authorsToRemove = dbAuthors.Except(newAuthors, comparer).ToList();
if (authorsToAdd.Count == 0 && authorsToRemove.Count == 0)
{
return;
}
foreach (var author in authorsToRemove)
{
var projectAuthor = project.Authors.Single(x => x.OriginalAuthor.Id == author.Id);
m_projectRepository.Delete(projectAuthor);
}
for (var i = 0; i < newAuthors.Count; i++)
{
var newAuthor = newAuthors[i];
if (authorsToAdd.Contains(newAuthor, comparer))
{
var dbAuthor = GetOrCreateAuthor(newAuthor.FirstName, newAuthor.LastName);
var newProjectAuthor = new ProjectOriginalAuthor
{
OriginalAuthor = dbAuthor,
Project = m_projectRepository.Load <Project>(m_projectId),
Sequence = i + 1
};
m_projectRepository.Create(newProjectAuthor);
}
else
{
var projectAuthor = project.Authors.Single(x =>
x.OriginalAuthor.FirstName == newAuthor.FirstName && x.OriginalAuthor.LastName == newAuthor.LastName);
projectAuthor.Sequence = i + 1;
m_projectRepository.Update(projectAuthor);
}
}
}
public virtual IList <MetadataResource> GetMetadataByProjectIds(IList <long> projectIds, bool fetchAuthors, bool fetchResponsiblePersons, bool fetchBookTypes)
{
Resource resourceAlias = null;
Project projectAlias = null;
ProjectOriginalAuthor projectOriginalAuthorAlias = null;
ProjectResponsiblePerson projectResponsiblePersonAlias = null;
var metadataListFuture = GetSession().QueryOver <MetadataResource>()
.JoinAlias(x => x.Resource, () => resourceAlias)
.JoinAlias(() => resourceAlias.Project, () => projectAlias)
.WhereRestrictionOn(() => projectAlias.Id).IsInG(projectIds)
.Fetch(SelectMode.Fetch, x => x.Resource)
.Fetch(SelectMode.Fetch, x => x.Resource.Project)
.And(x => x.Id == resourceAlias.LatestVersion.Id && !resourceAlias.IsRemoved && projectAlias.IsRemoved == false)
.Future();
if (fetchAuthors)
{
GetSession().QueryOver <Project>()
.WhereRestrictionOn(x => x.Id).IsInG(projectIds)
.JoinAlias(x => x.Authors, () => projectOriginalAuthorAlias, JoinType.LeftOuterJoin)
.Fetch(SelectMode.Fetch, x => x.Authors)
.Fetch(SelectMode.Fetch, x => x.Authors[0].OriginalAuthor)
.OrderBy(() => projectOriginalAuthorAlias.Sequence).Asc
.Future();
}
if (fetchResponsiblePersons)
{
GetSession().QueryOver <Project>()
.JoinAlias(x => x.ResponsiblePersons, () => projectResponsiblePersonAlias, JoinType.LeftOuterJoin)
.WhereRestrictionOn(x => x.Id).IsInG(projectIds)
.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();
}
if (fetchBookTypes)
{
GetSession().QueryOver <Project>()
.WhereRestrictionOn(x => x.Id).IsInG(projectIds)
.Fetch(SelectMode.Fetch, x => x.LatestPublishedSnapshot)
.Fetch(SelectMode.Fetch, x => x.LatestPublishedSnapshot.BookTypes)
.Future();
}
return(metadataListFuture.ToList());
}
public void UpdateAuthors(long projectId, BookData bookData)
{
var dbProjectAuthors = m_projectRepository.GetProjectOriginalAuthorList(projectId, true);
var dbAuthors = dbProjectAuthors.Select(x => x.OriginalAuthor).ToList();
var newAuthors = bookData.Authors?.Select(x => PersonHelper.ConvertToOriginalAuthor(x.Name)).ToList() ?? new List <OriginalAuthor>();
var comparer = new AuthorNameEqualityComparer();
var authorsToAdd = newAuthors.Except(dbAuthors, comparer).ToList();
var authorsToRemove = dbAuthors.Except(newAuthors, comparer).ToList();
if (authorsToAdd.Count == 0 && authorsToRemove.Count == 0)
{
return;
}
foreach (var author in authorsToRemove)
{
var projectAuthor = dbProjectAuthors.Single(x => x.OriginalAuthor.Id == author.Id);
m_projectRepository.Delete(projectAuthor);
}
for (int i = 0; i < newAuthors.Count; i++)
{
var newAuthor = newAuthors[i];
if (authorsToAdd.Contains(newAuthor, comparer))
{
var dbAuthor = GetOrCreateAuthor(newAuthor.FirstName, newAuthor.LastName);
var newProjectAuthor = new ProjectOriginalAuthor
{
OriginalAuthor = dbAuthor,
Project = m_projectRepository.Load <Project>(projectId),
Sequence = i + 1
};
m_projectRepository.Create(newProjectAuthor);
}
else
{
var projectAuthor = dbProjectAuthors.Single(x => x.OriginalAuthor.FirstName == newAuthor.FirstName && x.OriginalAuthor.LastName == newAuthor.LastName);
projectAuthor.Sequence = i + 1;
m_projectRepository.Update(projectAuthor);
}
}
}
public Project GetAdditionalProjectMetadata(long projectId, bool includeAuthors, bool includeResponsibles, bool includeKind, bool includeGenre)
{
var session = GetSession();
if (includeAuthors)
{
ProjectOriginalAuthor projectAuthorAlias = null;
OriginalAuthor authorAlias = null;
session.QueryOver <Project>()
.JoinAlias(x => x.Authors, () => projectAuthorAlias, JoinType.LeftOuterJoin)
.JoinAlias(() => projectAuthorAlias.OriginalAuthor, () => authorAlias, JoinType.LeftOuterJoin)
.Where(x => x.Id == projectId)
.OrderBy(() => projectAuthorAlias.Sequence).Asc
.Fetch(x => x.Authors).Eager
.FutureValue();
}
if (includeResponsibles)
{
session.QueryOver <Project>()
.Where(x => x.Id == projectId)
.Fetch(x => x.ResponsiblePersons).Eager
.FutureValue();
}
if (includeKind)
{
session.QueryOver <Project>()
.Where(x => x.Id == projectId)
.Fetch(x => x.LiteraryKinds).Eager
.FutureValue();
}
if (includeGenre)
{
session.QueryOver <Project>()
.Where(x => x.Id == projectId)
.Fetch(x => x.LiteraryGenres).Eager
.FutureValue();
}
return(session.QueryOver <Project>()
.Where(x => x.Id == projectId)
.FutureValue().Value);
}
public IList <OriginalAuthor> GetAuthorAutocomplete(string queryString, BookTypeEnum?bookTypeEnum, int count)
{
OriginalAuthor authorAlias = null;
queryString = EscapeQuery(queryString);
queryString = queryString.Replace(" ", $"{WildcardAny} ");
var query = GetSession().QueryOver(() => authorAlias)
.Where(Restrictions.Or(
Restrictions.Like(Projections.SqlFunction("concat", NHibernateUtil.String, Projections.Property(() => authorAlias.LastName),
Projections.Constant(" "), Projections.Property(() => authorAlias.FirstName)), queryString, MatchMode.Start),
Restrictions.Like(Projections.Property(() => authorAlias.FirstName), queryString, MatchMode.Start)
))
.OrderBy(x => x.LastName).Asc
.ThenBy(x => x.FirstName).Asc;
if (bookTypeEnum != null)
{
ProjectOriginalAuthor projectOriginalAuthorAlias = null;
Project projectAlias = null;
Snapshot snapshotAlias = null;
BookType bookTypeAlias = null;
query.JoinAlias(x => x.Projects, () => projectOriginalAuthorAlias)
.JoinAlias(() => projectOriginalAuthorAlias.Project, () => projectAlias)
.JoinAlias(() => projectAlias.LatestPublishedSnapshot, () => snapshotAlias)
.JoinAlias(() => snapshotAlias.BookTypes, () => bookTypeAlias)
.Where(() => bookTypeAlias.Type == bookTypeEnum.Value && projectAlias.IsRemoved == false)
.Select(Projections.Distinct(Projections.ProjectionList()
.Add(Projections.Property <OriginalAuthor>(x => x.Id).WithAlias(() => authorAlias.Id))
.Add(Projections.Property <OriginalAuthor>(x => x.FirstName).WithAlias(() => authorAlias.FirstName))
.Add(Projections.Property <OriginalAuthor>(x => x.LastName).WithAlias(() => authorAlias.LastName))
))
.TransformUsing(Transformers.AliasToBean <OriginalAuthor>());
}
return(query
.Take(count)
.List());
}
protected override void ExecuteWorkImplementation()
{
var dbProjectAuthorList = m_metadataRepository.GetProjectOriginalAuthorList(m_projectId);
var project = m_metadataRepository.Load <Project>(m_projectId);
var itemsToDelete = new List <ProjectOriginalAuthor>();
foreach (var projectAuthor in dbProjectAuthorList)
{
if (!m_authorIdList.Contains(projectAuthor.OriginalAuthor.Id))
{
itemsToDelete.Add(projectAuthor);
}
}
m_metadataRepository.DeleteAll(itemsToDelete);
var order = 1;
foreach (var newAuthorId in m_authorIdList)
{
var projectAuthor = dbProjectAuthorList.SingleOrDefault(x => x.OriginalAuthor.Id == newAuthorId);
if (projectAuthor == null)
{
projectAuthor = new ProjectOriginalAuthor
{
Project = project,
OriginalAuthor = m_metadataRepository.Load <OriginalAuthor>(newAuthorId),
Sequence = order++
};
m_metadataRepository.Create(projectAuthor);
}
else
{
projectAuthor.Sequence = order++;
m_metadataRepository.Update(projectAuthor);
}
}
}
public virtual IList <Project> FetchAuthorsAndResponsibles(IList <long> projectIds)
{
ProjectOriginalAuthor projectOriginalAuthorAlias = null;
ProjectResponsiblePerson projectResponsiblePersonAlias = null;
GetSession().QueryOver <Project>()
.WhereRestrictionOn(x => x.Id).IsInG(projectIds)
.JoinAlias(x => x.Authors, () => projectOriginalAuthorAlias, JoinType.LeftOuterJoin)
.Fetch(SelectMode.Fetch, x => x.Authors)
.Fetch(SelectMode.Fetch, x => x.Authors[0].OriginalAuthor)
.OrderBy(x => x.Id).Asc
.ThenBy(() => projectOriginalAuthorAlias.Sequence).Asc
.Future();
return(GetSession().QueryOver <Project>()
.WhereRestrictionOn(x => x.Id).IsInG(projectIds)
.JoinAlias(x => x.ResponsiblePersons, () => projectResponsiblePersonAlias, 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(x => x.Id).Asc
.ThenBy(() => projectResponsiblePersonAlias.Sequence).Asc
.Future().ToList());
}
public virtual Project GetAdditionalProjectMetadata(long projectId, bool includeAuthors, bool includeResponsibles, bool includeKind, bool includeGenre, bool includeOriginal, bool includeKeyword, bool includeCategory)
{
var session = GetSession();
if (includeAuthors)
{
ProjectOriginalAuthor projectAuthorAlias = null;
OriginalAuthor authorAlias = null;
session.QueryOver <Project>()
.JoinAlias(x => x.Authors, () => projectAuthorAlias, JoinType.LeftOuterJoin)
.JoinAlias(() => projectAuthorAlias.OriginalAuthor, () => authorAlias, JoinType.LeftOuterJoin)
.Where(x => x.Id == projectId)
.OrderBy(() => projectAuthorAlias.Sequence).Asc
.Fetch(SelectMode.Fetch, x => x.Authors)
.FutureValue();
}
if (includeResponsibles)
{
ProjectResponsiblePerson projectResponsiblePersonAlias = null;
session.QueryOver <Project>()
.JoinAlias(x => x.ResponsiblePersons, () => projectResponsiblePersonAlias, JoinType.LeftOuterJoin)
.Where(x => x.Id == projectId)
.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
.FutureValue();
}
if (includeKind)
{
session.QueryOver <Project>()
.Where(x => x.Id == projectId)
.Fetch(SelectMode.Fetch, x => x.LiteraryKinds)
.FutureValue();
}
if (includeGenre)
{
session.QueryOver <Project>()
.Where(x => x.Id == projectId)
.Fetch(SelectMode.Fetch, x => x.LiteraryGenres)
.FutureValue();
}
if (includeOriginal)
{
session.QueryOver <Project>()
.Where(x => x.Id == projectId)
.Fetch(SelectMode.Fetch, x => x.LiteraryOriginals)
.FutureValue();
}
if (includeKeyword)
{
session.QueryOver <Project>()
.Where(x => x.Id == projectId)
.Fetch(SelectMode.Fetch, x => x.Keywords)
.FutureValue();
}
if (includeCategory)
{
session.QueryOver <Project>()
.Where(x => x.Id == projectId)
.Fetch(SelectMode.Fetch, x => x.Categories)
.FutureValue();
}
return(session.QueryOver <Project>()
.Where(x => x.Id == projectId && x.IsRemoved == false)
.FutureValue().Value);
}
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);
}
