private static void AddKeywords(IList <Keyword> keywords, EfContainer container, BiblioDbContext context) { // collect the keywords to be assigned, adding the missing ones List <EfKeywordContainer> requested = new List <EfKeywordContainer>(); foreach (Keyword keyword in keywords) { // find the keyword by its content, as we have no ID EfKeyword efk = context.Keywords.FirstOrDefault(k => k.Value == keyword.Value && k.Language == keyword.Language); // if not found, add it if (efk == null) { efk = new EfKeyword { Language = keyword.Language, Value = keyword.Value, Valuex = StandardFilter.Apply(keyword.Value, true) }; context.Keywords.Add(efk); } requested.Add(new EfKeywordContainer { Keyword = efk, Container = container }); } // remove all the keywords which are no more requested if (container.KeywordContainers != null) { foreach (EfKeywordContainer kc in container.KeywordContainers) { if (requested.All(r => r.KeywordId != kc.KeywordId)) { context.KeywordContainers.Remove(kc); } } } else { container.KeywordContainers = new List <EfKeywordContainer>(); } // add all those which are not yet present foreach (EfKeywordContainer kc in requested) { if (container.KeywordContainers.All( r => r.KeywordId != kc.KeywordId)) { container.KeywordContainers.Add(kc); } } }
/// <summary> /// Deletes the container. /// </summary> /// <param name="id">The identifier.</param> public void DeleteContainer(Guid id) { using (var db = GetContext()) { EfContainer container = db.Containers.Find(id); if (container != null) { db.Containers.Remove(container); db.SaveChanges(); } } }
/// <summary> /// Gets the work information corresponding to the specified container /// entity. /// </summary> /// <param name="ef">The entity or null.</param> /// <param name="context">The context.</param> /// <returns>The object or null.</returns> /// <exception cref="ArgumentNullException">context</exception> public static WorkInfo GetWorkInfo(EfContainer ef, BiblioDbContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (ef == null) { return(null); } WorkInfo info = new WorkInfo { IsContainer = true, Id = ef.Id, Key = ef.Key, Type = ef.Type?.Name, Title = ef.Title, Language = ef.Language, Edition = ef.Edition, YearPub = ef.YearPub, PlacePub = ef.PlacePub, Number = ef.Number }; // authors if (ef.AuthorContainers?.Count > 0) { info.Authors = (from aw in ef.AuthorContainers select new WorkAuthor { Id = aw.AuthorId, First = aw.Author?.First, Last = aw.Author?.Last, Role = aw.Role, Ordinal = aw.Ordinal }).ToList(); } // keywords if (ef.KeywordContainers?.Count > 0) { info.Keywords = (from kw in ef.KeywordContainers select new Keyword { Language = kw.Keyword?.Language, Value = kw.Keyword?.Value }).ToList(); } return(info); }
/// <summary> /// Adds or updates the specified container. /// Container type, authors, and keywords are stored too. /// As for authors, you can specify only the author's ID to assign /// the work to an existing author; otherwise, the author will be /// either added or updated as required. Keywords are added or /// updated as required. Type is added if not found, even this should /// not happen, as types are a predefined set. /// If new, <paramref name="container"/> ID gets updated; the key is /// always updated. /// </summary> /// <param name="container">The container.</param> /// <exception cref="ArgumentNullException">container</exception> public void AddContainer(Container container) { if (container == null) { throw new ArgumentNullException(nameof(container)); } using (var db = GetContext()) { EfContainer ef = EfHelper.GetEfContainer(container, db); db.SaveChanges(); container.Id = ef.Id; container.Key = ef.Key; } }
/// <summary> /// Gets the container by its ID. /// </summary> /// <param name="id">The container's identifier.</param> /// <returns> /// Container, or null if not found /// </returns> public Container GetContainer(Guid id) { using (var db = GetContext()) { EfContainer container = db.Containers .AsNoTracking() .Include(w => w.Type) .Include(w => w.AuthorContainers) .ThenInclude(aw => aw.Author) .Include(w => w.KeywordContainers) .ThenInclude(kw => kw.Keyword) .FirstOrDefault(w => w.Id == id); return(EfHelper.GetContainer(container)); } }
private static void AddAuthors(IList <WorkAuthor> authors, EfContainer container, BiblioDbContext context) { // collect the authors to be assigned, adding the missing ones List <EfAuthorContainer> requested = new List <EfAuthorContainer>(); foreach (WorkAuthor author in authors) { EfAuthor efa = GetEfAuthorFor(author, context); if (efa == null) { continue; } requested.Add(new EfAuthorContainer { Author = efa, Container = container }); } // for // remove all the no more requested authors if (container.AuthorContainers != null) { foreach (EfAuthorContainer ac in container.AuthorContainers) { if (requested.All(r => r.AuthorId != ac.AuthorId)) { context.AuthorContainers.Remove(ac); } } } else { container.AuthorContainers = new List <EfAuthorContainer>(); } // add all those which are not yet present foreach (EfAuthorContainer ac in requested) { if (container.AuthorContainers.All( r => r.AuthorId != ac.AuthorId)) { container.AuthorContainers.Add(ac); } } }
/// <summary> /// Gets the container object corresponding to the specified container /// entity. /// </summary> /// <param name="ef">The entity or null.</param> /// <returns>The container or null.</returns> public static Container GetContainer(EfContainer ef) { if (ef == null) { return(null); } Container container = new Container { Id = ef.Id, Key = ef.Key, Type = ef.Type?.Id, Title = ef.Title, Language = ef.Language, Edition = ef.Edition, Publisher = ef.Publisher, YearPub = ef.YearPub, PlacePub = ef.PlacePub, Location = ef.Location, AccessDate = ef.AccessDate, Note = ef.Note, Number = ef.Number }; // authors if (ef.AuthorContainers?.Count > 0) { container.Authors.AddRange(from ac in ef.AuthorContainers select new WorkAuthor { Last = ac.Author.Last, First = ac.Author.First, Role = ac.Role, Ordinal = ac.Ordinal }); } // keywords if (ef.KeywordContainers?.Count > 0) { container.Keywords.AddRange(from ak in ef.KeywordContainers select GetKeyword(ak.Keyword)); } return(container); }
/// <summary> /// Gets the container entity corresponding to the specified container. /// </summary> /// <param name="container">The container or null.</param> /// <param name="context">The context.</param> /// <returns>The entity or null.</returns> /// <exception cref="ArgumentNullException">context</exception> public static EfContainer GetEfContainer(Container container, BiblioDbContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (container == null) { return(null); } // get the container unless it's new EfContainer ef = container.Id != Guid.Empty ? context.Containers .Include(c => c.AuthorContainers) .Include(c => c.KeywordContainers) .FirstOrDefault(c => c.Id == container.Id) : null; // if new or not found, add it with a new ID if (ef == null) { if (container.Title == null) { return(null); } ef = new EfContainer(); context.Containers.Add(ef); } // update the container unless empty if (container.Title != null) { ef.Type = GetOrCreateWorkType(container.Type, null, context); ef.Title = container.Title; ef.Titlex = StandardFilter.Apply(container.Title, true); ef.Language = container.Language; ef.Edition = container.Edition; ef.Publisher = container.Publisher; ef.YearPub = container.YearPub; ef.PlacePub = container.PlacePub; ef.Location = container.Location; ef.AccessDate = container.AccessDate; ef.Number = container.Number; ef.Note = container.Note; // authors if (container.Authors?.Count > 0) { AddAuthors(container.Authors, ef, context); } // keywords if (container.Keywords?.Count > 0) { AddKeywords(container.Keywords, ef, context); } // key ef.Key = WorkKeyBuilder.PickKey(ef.Key, container); // add key suffix if required and possible if (ef.Key?.StartsWith(WorkKeyBuilder.MAN_KEY_PREFIX) != true) { char c = GetSuffixForKey(ef.Key, context); if (c != '\0') { ef.Key += c; } } } return(ef); }