public RelatedQueryModel(IRelated related, IQuery query) : this(related) { Skip = query.Skip; Take = query.Take; SearchTerm = query.SearchTerm; CollectionAlias = query.CollectionAlias; }
public RelatedQueryModel(IRelated related, IView view) : this(related) { Skip = view.Skip; Take = view.Take; SearchTerm = view.SearchTerm; CollectionAlias = view.CollectionAlias; }
public RelatedQueryModel(IRelated related) { Related = new EntityDescriptorModel { RepositoryAlias = related.RepositoryAlias, Id = related.Entity.Id ! }; }
public RelatedQueryModel(IRelated related) { Related = new EntityDescriptorModel { RepositoryAlias = related.RepositoryAlias, Id = related.Entity.Id !, ParentPath = related.Parent?.GetParentPath()?.ToPathString() }; }
public RelateModel(IRelated related, string id) { Id = id; Related = new EntityDescriptorModel { RepositoryAlias = related.RepositoryAlias, Id = related.Entity.Id ! }; }
public override async Task AddAsync(IRelated related, string id) { if (related.Entity is PersonCmsModel person && int.TryParse(person.Id, out var personId) && int.TryParse(id, out var countryId)) { _dbContext.PersonCountry.Add(new PersonCountry { CountryId = countryId, PersonId = personId }); await _dbContext.SaveChangesAsync(); }
public override Task RemoveAsync(IRelated related, string id) { if (!_relations.ContainsKey(id)) { _relations.Add(id, new List <string>()); } _relations[id].Remove(related.Entity.Id !); _mediator.NotifyEvent(this, new MessageEventArgs(MessageType.Success, "Entity removed.")); return(Task.CompletedTask); }
public override async Task <IEnumerable <TEntity>?> GetAllNonRelatedAsync(IRelated related, IQuery <TEntity> query) { var results = await _apiRepositoryHelper.DoRequestAsync <EntitiesModel <TEntity> >(_apiRepositoryHelper.CreateRequest(HttpMethod.Post, "all/nonrelated", new RelatedQueryModel(related, query))); if (results == default) { return(Enumerable.Empty <TEntity>()); } query.HasMoreData(results.MoreDataAvailable); return(results.Entities.Select(x => x.Entity)); }
public override async Task <IEnumerable <TEntity>?> GetAllRelatedAsync(IRelated related, IQuery <TDatabaseEntity> query) { var results = await DoRequestAsync <EntitiesModel <TEntity> >(CreateRequest(HttpMethod.Post, "all/related", new RelatedQueryModel(related, query))); if (results == default) { return(Enumerable.Empty <TEntity>()); } query.HasMoreData(results.MoreDataAvailable); return(results.Entities); }
public override Task <IEnumerable <TEntity>?> GetAllRelatedAsync(IRelated related, IQuery <TEntity> query) { var ids = _relations.Where(x => x.Value.Contains(related.Entity.Id !)).Select(x => x.Key); // relations only work on the root collection (for simplicity) return(Task.FromResult(GetListForParent(default).Where(x => ids.Contains(x.Id !))) !);
/// <summary> /// This method gets all entities that match the given query instruction (paging / search) but are not related to the given entity. /// /// This query is based on the TDatabaseEntity, and not TEntity to allow for mapping. /// </summary> /// <param name="relatedEntity"></param> /// <param name="query"></param> /// <returns></returns> public virtual Task <IEnumerable <TEntity>?> GetAllNonRelatedAsync(IRelated related, IQuery <TDatabaseEntity> query) => throw new NotImplementedException($"In order to use many-to-many list editors, implement {nameof(GetAllNonRelatedAsync)} on the {GetType()}.");
async Task IRepository.RemoveAsync(IRelated related, string id) { await RemoveAsync(related, id); }
async Task IRepository.AddAsync(IRelated related, string id) { await AddAsync(related, id); }
async Task <IEnumerable <IEntity> > IRepository.GetAllRelatedAsync(IRelated related, IQuery query) => (await GetAllRelatedAsync(related, TypedQuery <TEntity> .Convert(query)))?.Cast <IEntity>() ?? Enumerable.Empty <IEntity>();
public override Task AddAsync(IRelated related, string id) => DoRequestAsync(CreateRequest(HttpMethod.Post, $"relate", new RelateModel(related, id)));
public WordVM(WordInfo wordInfo, IKanjiProperties lang, IKanaProperties kanaProperties, IRelated related) { var s = wordInfo.RawWord; StringForm = s; codePoints.AddRange(s.AsCodePoints().Select(rawCp => { var cp = CodePoint.FromInt(rawCp); var vm = new CodePointVM( cp, related.FindRelated(cp).SelectMany(g => g), cp is Kanji k ? lang.LookupRadicalsByKanji(k).ValueOr(Enumerable.Empty <CodePoint>()) : Enumerable.Empty <CodePoint>(), cp is Kana kana ? kanaProperties.LookupRomaji(kana.ToString()) : null); return(vm); })); WordInfo = wordInfo; }
public override async Task AddAsync(IRelated related, string id) { await base.AddAsync(related, id); await UpdateStorageAsync(); }
public override async Task <IEnumerable <TEntity>?> GetAllRelatedAsync(IRelated related, IView <TEntity> view) { await _initializationTask; return(await base.GetAllRelatedAsync(related, view)); }
public RelatedViewContext(IRelated related, string?collectionAlias, IParent?parent) : base(collectionAlias, parent) { Related = related ?? throw new ArgumentNullException(nameof(related)); }
public override async Task <IEnumerable <CountryCmsModel>?> GetAllNonRelatedAsync(IRelated related, IQuery <Country> query) { if (related.Entity is PersonCmsModel person) { return(await GetRelatedToGivenPersonAsync(query, person, false)); } throw new InvalidOperationException(); }
public override Task <IEnumerable <TEntity>?> GetAllNonRelatedAsync(IRelated related, IView <TEntity> query) { var ids = _relations.Where(x => x.Value.Contains(related.Entity.Id !)).Select(x => x.Key); return(Task.FromResult(GetListForParent(related.Parent).Where(x => !ids.Contains(x.Id !))) !); }
/// <summary> /// This methods removes an releated entity from the entity that corresponds with the given id. /// This method is used when a many-to-many relation between two entities is removed. /// </summary> /// <param name="related"></param> /// <param name="id"></param> /// <returns></returns> public virtual Task RemoveAsync(IRelated related, string id) => throw new NotImplementedException($"In order to use many-to-many list editors, implement {nameof(RemoveAsync)} on the {GetType()}.");
async Task <IEnumerable <IEntity> > IRepository.GetAllNonRelatedAsync(IRelated related, IQuery query) { return((await GetAllNonRelatedAsync(related, TypedQuery <TDatabaseEntity> .Convert(query)))?.Cast <IEntity>() ?? Enumerable.Empty <IEntity>()); }
public override Task RemoveAsync(IRelated related, string id) => DoRequestAsync(CreateRequest(HttpMethod.Delete, $"relate", new RelateModel(related, id)));
public override async Task <IEnumerable <TEntity>?> GetAllRelatedAsync(IRelated related, IQuery <TEntity> query) { await _initializationTask; return(await base.GetAllRelatedAsync(related, query)); }
public override Task RemoveAsync(IRelated related, string id) => _apiRepositoryHelper.DoRequestAsync(_apiRepositoryHelper.CreateRequest(HttpMethod.Delete, $"relate", new RelateModel(related, id)));
public override async Task AddAsync(IRelated related, string id) { await base.AddAsync(related, id); UpdateJson(); }