public void UpdateLiteraryOriginals(long projectId, BookData bookData)
        {
            if (bookData.LiteraryOriginals == null)
            {
                return;
            }

            var dbOriginalList = m_catalogValueRepository.GetLiteraryOriginalList();
            var project        = m_metadataRepository.GetAdditionalProjectMetadata(projectId, false, false, false, false, true, false, false);

            foreach (var newOriginalName in bookData.LiteraryOriginals)
            {
                var dbOriginal = dbOriginalList.FirstOrDefault(x => x.Name == newOriginalName);

                // Create new Literary Original
                if (dbOriginal == null)
                {
                    dbOriginal = new LiteraryOriginal
                    {
                        Name = newOriginalName
                    };
                    m_catalogValueRepository.Create(dbOriginal);
                    dbOriginalList.Add(dbOriginal);
                }

                // Assign Literary Original to project
                if (project.LiteraryOriginals.All(x => x.Id != dbOriginal.Id))
                {
                    project.LiteraryOriginals.Add(dbOriginal);
                }
            }
            m_catalogValueRepository.Update(project);
        }
Exemplo n.º 2
0
        private void UpdateLiteraryOriginals(Project project)
        {
            if (project.LiteraryOriginals == null)
            {
                project.LiteraryOriginals = new List <LiteraryOriginal>();
            }
            else
            {
                project.LiteraryOriginals.Clear();
            }

            var dbOriginalList = m_catalogValueRepository.GetLiteraryOriginalList();

            foreach (var newOriginalName in m_importedRecord.ImportedProject.LiteraryOriginals)
            {
                var dbOriginal = dbOriginalList.FirstOrDefault(x => x.Name == newOriginalName);

                // Create new Literary Original
                if (dbOriginal == null)
                {
                    dbOriginal = new LiteraryOriginal
                    {
                        Name = newOriginalName
                    };
                    m_catalogValueRepository.Create(dbOriginal);
                    dbOriginalList.Add(dbOriginal);
                }

                // Assign Literary Original to project
                if (project.LiteraryOriginals.All(x => x.Id != dbOriginal.Id))
                {
                    project.LiteraryOriginals.Add(dbOriginal);
                }
            }
        }
Exemplo n.º 3
0
        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);
            }
        }