public virtual ListWithTotalCountResult <MetadataResource> GetMetadataByResponsiblePerson(int responsiblePersonId, int start, int count)
{
Resource resourceAlias = null;
Project projectAlias = null;
ProjectResponsiblePerson projectResponsiblePersonAlias = null;
User userAlias = null;
var query = GetSession().QueryOver <MetadataResource>()
.JoinAlias(x => x.Resource, () => resourceAlias)
.JoinAlias(() => resourceAlias.Project, () => projectAlias)
.JoinAlias(() => projectAlias.ResponsiblePersons, () => projectResponsiblePersonAlias)
.JoinAlias(() => projectAlias.CreatedByUser, () => userAlias) // fetch user
.Where(x => x.Id == resourceAlias.LatestVersion.Id && !resourceAlias.IsRemoved && projectResponsiblePersonAlias.ResponsiblePerson.Id == responsiblePersonId && 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,
});
}
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 UpdateResponsiblePersonList(long projectId, BookData bookData)
{
if (bookData.Responsibles == null)
{
return;
}
var project = m_projectRepository.Load <Project>(projectId);
var dbResponsibles = m_projectRepository.GetProjectResponsibleList(projectId);
var updatedResponsibles = new List <ProjectResponsiblePerson>();
var comparer = new ProjectResponsibleNameEqualityComparer();
for (var i = 0; i < bookData.Responsibles.Count; i++)
{
var responsiblePerson = bookData.Responsibles[i];
var dbResponsiblePerson = GetOrCreateResponsiblePerson(responsiblePerson.NameText);
var dbResponsibleTypes = GetOrCreateResponsibleType(responsiblePerson.TypeText);
foreach (var dbResponsibleType in dbResponsibleTypes)
{
var newProjectResponsible = new ProjectResponsiblePerson
{
Project = project,
ResponsiblePerson = dbResponsiblePerson,
ResponsibleType = dbResponsibleType,
Sequence = i + 1,
};
if (!dbResponsibles.Contains(newProjectResponsible, comparer))
{
m_projectRepository.Create(newProjectResponsible);
}
else
{
var dbResponsible = dbResponsibles.Single(x => comparer.Equals(x, newProjectResponsible));
dbResponsible.Sequence = i + 1;
m_projectRepository.Update(dbResponsible);
updatedResponsibles.Add(dbResponsible);
}
}
}
var responsiblesToRemove = dbResponsibles.Except(updatedResponsibles);
m_projectRepository.DeleteAll(responsiblesToRemove);
}
protected override void ExecuteWorkImplementation()
{
var dbProjectResponsibles = m_projectRepository.GetProjectResponsibleList(m_projectId);
var project = m_projectRepository.Load <Project>(m_projectId);
var newDbProjectResponsibles = new List <ProjectResponsiblePerson>();
for (var i = 0; i < m_projectResponsiblePersonIdList.Count; i++)
{
var projectPerson = m_projectResponsiblePersonIdList[i];
var responsiblePerson = m_projectRepository.Load <ResponsiblePerson>(projectPerson.ResponsiblePersonId);
var responsibleType = m_projectRepository.Load <ResponsibleType>(projectPerson.ResponsibleTypeId);
var newProjectResponsible = new ProjectResponsiblePerson
{
Project = project,
ResponsiblePerson = responsiblePerson,
ResponsibleType = responsibleType,
Sequence = i + 1,
};
newDbProjectResponsibles.Add(newProjectResponsible);
}
// Delete responsibles
foreach (var dbProjectResponsible in dbProjectResponsibles)
{
if (!newDbProjectResponsibles.Contains(dbProjectResponsible))
{
m_projectRepository.Delete(dbProjectResponsible);
}
}
// Create or update new responsibles
foreach (var newDbProjectResponsible in newDbProjectResponsibles)
{
if (!dbProjectResponsibles.Contains(newDbProjectResponsible))
{
m_projectRepository.Create(newDbProjectResponsible);
}
else
{
var dbProjectResponsible = dbProjectResponsibles.Single(x => x.Equals(newDbProjectResponsible));
dbProjectResponsible.Sequence = newDbProjectResponsible.Sequence;
m_projectRepository.Update(dbProjectResponsible);
}
}
}
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);
}
