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();
}
