public DomainCriteria AddCriteria()
{
DomainCriteria criteria = new DomainCriteria();
this.Items.Add(criteria);
return(criteria);
}
public async Task <TAggregate> LoadAsync <TAggregate, TIdentity>(TIdentity id, CancellationToken cancellationToken)
where TAggregate : class, IAggregateRoot <TIdentity>
where TIdentity : IIdentity
{
TAggregate aggregate = default;
var criteria = new DomainCriteria();
criteria.SafeAnd(new EqualityFilter("Id", id));
IPersistence aggregatePersistence = _persistenceFactory.GetPersistence <TAggregate>();
aggregate = await aggregatePersistence.Get <TAggregate, DomainCriteria>(criteria, CancellationToken.None);
if (aggregate.IsNull())
{
aggregate = await _aggregateFactory.CreateNewAggregateAsync <TAggregate, TIdentity>(id).ConfigureAwait(false);
aggregate.Persistence = aggregatePersistence;
return(aggregate);
}
else
{
aggregate.Persistence = aggregatePersistence;
return(aggregate.AsExisting() as TAggregate);
}
}
public static void SafeAnd(this DomainCriteria value, BaseFilter filter)
{
if (filter.IsNotNull())
{
value.Filter &= filter;
}
}
public static void SafeAnd(this DomainCriteria value, EqualityFilter filter)
{
if (filter.IsNotNull())
{
if (filter.Value.IsNotNull())
{
if (filter.Value is string && filter.Value.AsString().IsNullOrEmpty())
{
return;
}
value.Filter &= filter;
}
}
}
public static string BuildQueryClause(this DomainCriteria value)
{
var query = "{0};{1}".FormatInvariantCulture(BuildFilter(value.Filter), BuildAggregations(value)).Trim(';');
if (value.MaximumResult.IsNotNull())
{
query += ";TOP({0})".FormatInvariantCulture(value.MaximumResult);
}
if (value.SortOrder.IsNotNull())
{
query += ";OrderBy({0},{1})".FormatInvariantCulture(value.SortOrder.PropertyName, value.SortOrder.SortOrderType.ToString());
}
return(query);
}
private static string BuildAggregations(DomainCriteria domainCriteria)
{
var aggregations = string.Empty;
if (domainCriteria.Aggregations.Count > 0)
{
aggregations = "AGGREGATES: ";
foreach (var item in domainCriteria.Aggregations)
{
aggregations += "{0}({1}),".FormatInvariantCulture(item.AggregateType.ToString(), item.PropertyName);
}
}
return(aggregations.TrimEnd(','));
}
private static Expression AddOrder <TDomain>(Expression filterExpression,
DomainCriteria domainCriteria,
IQueryable <TDomain> queryableData,
ParameterExpression parameter) where TDomain : class
{
if (domainCriteria.SortOrder.IsNotNull())
{
Expression propertyToOrderByExpression = Expression.Convert(Expression.Property(parameter, domainCriteria.SortOrder.PropertyName), typeof(object));
switch (domainCriteria.SortOrder.SortOrderType)
{
case SortOrderType.Ascending:
{
var orderByExpression = Expression.Lambda(propertyToOrderByExpression, parameter);
return(Expression.Call(
typeof(Queryable),
"OrderBy",
new Type[] { queryableData.ElementType, orderByExpression.ReturnType },
filterExpression,
Expression.Quote(orderByExpression)));
}
case SortOrderType.Descending:
{
var orderByExpression = Expression.Lambda(propertyToOrderByExpression, parameter);
return(Expression.Call(
typeof(Queryable),
"OrderByDescending",
new Type[] { queryableData.ElementType, orderByExpression.ReturnType },
filterExpression,
Expression.Quote(orderByExpression)));
}
}
}
return(filterExpression);
}
public async Task<ServiceResult<string>> GetAllDomain(PagingParameterModel pagingParameter)
{
try
{
var allDomains = _domatelContext.Domains.OrderByDescending(s=>s.StartDate)
.Skip((pagingParameter.PageNumber - 1) * pagingParameter.PageSize)
.Take(pagingParameter.PageSize)
.ToList();
List<DomainCriteria> domainlist = new List<DomainCriteria>();
foreach (var domain in allDomains)
{
DomainCriteria domaincriteria = new DomainCriteria();
domaincriteria.Id = domain.Id;
domaincriteria.Url = domain.Url;
domaincriteria.HaveContent = domain.HaveContent;
domaincriteria.BasePrice = domain.BasePrice;
domainlist.Add(domaincriteria);
}
return new ServiceResult<string>
{
Data = JsonConvert.SerializeObject(domainlist),
Message = string.Empty,
Status = (int)Configuration.ServiceResultStatus.Success
};
}
catch (Exception e)
{
return new ServiceResult<string>
{
Message = e.Message,
Status = (int)Configuration.ServiceResultStatus.Error
};
}
}
protected void AddCriteria(DomainCriteria criteria)
{
this.StackLayout.Children.Add(new DomainCriteriaCell(criteria));
}
public void AddItem(object sender, EventArgs e)
{
DomainCriteria criteria = viewModel.AddCriteria();
this.AddCriteria(criteria);
}
public static void RequiredAnd(this DomainCriteria value, EqualityFilter filter)
{
Invariant.IsFalse(filter.IsNull() || filter.Value.IsNull() || (filter.Value is string && filter.Value.AsString().IsNullOrEmpty()), () => "'{0}' filter is required".FormatInvariantCulture(filter.Property));
value.SafeAnd(filter);
}
public DomainCriteriaCell(DomainCriteria criteria)
{
InitializeComponent();
this.BindingContext = DomainCriteria = criteria;
}
