public void Delete(DateTimeSearch request)
{
var matches = Get(request) as List <DateTimeDto>;
if (true != matches?.Any())
{
throw new HttpError(HttpStatusCode.NotFound, "No matches for request");
}
matches.ForEach(match =>
{
Delete(match);
});
}
private IQueryable <DocEntityDateTime> _ExecSearch(DateTimeSearch request, DocQuery query)
{
request = InitSearch <DateTimeDto, DateTimeSearch>(request);
IQueryable <DocEntityDateTime> entities = null;
query.Run(session =>
{
entities = query.SelectAll <DocEntityDateTime>();
if (!DocTools.IsNullOrEmpty(request.FullTextSearch))
{
var fts = new DateTimeFullTextSearch(request);
entities = GetFullTextSearch <DocEntityDateTime, DateTimeFullTextSearch>(fts, entities);
}
if (null != request.Ids && request.Ids.Any())
{
entities = entities.Where(en => en.Id.In(request.Ids));
}
if (!DocTools.IsNullOrEmpty(request.Updated))
{
entities = entities.Where(e => null != e.Updated && e.Updated.Value.Date == request.Updated.Value.Date);
}
if (!DocTools.IsNullOrEmpty(request.UpdatedBefore))
{
entities = entities.Where(e => null != e.Updated && e.Updated <= request.UpdatedBefore);
}
if (!DocTools.IsNullOrEmpty(request.UpdatedAfter))
{
entities = entities.Where(e => null != e.Updated && e.Updated >= request.UpdatedAfter);
}
if (!DocTools.IsNullOrEmpty(request.Created))
{
entities = entities.Where(e => null != e.Created && e.Created.Value.Date == request.Created.Value.Date);
}
if (!DocTools.IsNullOrEmpty(request.CreatedBefore))
{
entities = entities.Where(e => null != e.Created && e.Created <= request.CreatedBefore);
}
if (!DocTools.IsNullOrEmpty(request.CreatedAfter))
{
entities = entities.Where(e => null != e.Created && e.Created >= request.CreatedAfter);
}
if (true == request.Archived?.Any() && currentUser.HasProperty(DocConstantModelName.DATETIME, nameof(Reference.Archived), DocConstantPermission.VIEW))
{
entities = entities.Where(en => en.Archived.In(request.Archived));
}
else
{
entities = entities.Where(en => !en.Archived);
}
if (true == request.Locked?.Any())
{
entities = entities.Where(en => en.Locked.In(request.Locked));
}
if (request.DateDay.HasValue)
{
entities = entities.Where(en => request.DateDay.Value == en.DateDay);
}
if (request.DateMonth.HasValue)
{
entities = entities.Where(en => request.DateMonth.Value == en.DateMonth);
}
if (!DocTools.IsNullOrEmpty(request.DateTime))
{
entities = entities.Where(en => null != en.DateTime && request.DateTime.Value.Date == en.DateTime.Value.Date);
}
if (!DocTools.IsNullOrEmpty(request.DateTimeBefore))
{
entities = entities.Where(en => en.DateTime <= request.DateTimeBefore);
}
if (!DocTools.IsNullOrEmpty(request.DateTimeAfter))
{
entities = entities.Where(en => en.DateTime >= request.DateTimeAfter);
}
if (request.DateYear.HasValue)
{
entities = entities.Where(en => request.DateYear.Value == en.DateYear);
}
entities = ApplyFilters <DocEntityDateTime, DateTimeSearch>(request, entities);
if (request.Skip > 0)
{
entities = entities.Skip(request.Skip.Value);
}
if (request.Take > 0)
{
entities = entities.Take(request.Take.Value);
}
if (true == request?.OrderBy?.Any())
{
entities = entities.OrderBy(request.OrderBy);
}
if (true == request?.OrderByDesc?.Any())
{
entities = entities.OrderByDescending(request.OrderByDesc);
}
});
return(entities);
}
public object Post(DateTimeSearch request) => Get(request);
public object Get(DateTimeSearch request) => GetSearchResultWithCache <DateTimeDto, DocEntityDateTime, DateTimeSearch>(DocConstantModelName.DATETIME, request, _ExecSearch);
public static Expression BuildDateTimeSearch <TEntity>(Expression target, ParameterExpression parameter, Expression <Func <TEntity, DateTime?> > getter, DateTimeSearch search)
{
if (search == null)
{
return(target);
}
Expression property = PropertyExpression(parameter, getter);
Expression value = null;
Expression compare = null;
switch (search.ComparePart)
{
case DateTimeSearchCompare.Date:
MethodInfo truncateTime = typeof(EntityFunctions).GetMethod("TruncateTime", new Type[] { typeof(DateTime?) });
value = Expression.Property(Expression.Call(truncateTime, Expression.Constant(search.DateTime, typeof(DateTime?))), "Value");
property = Expression.Property(Expression.Call(truncateTime, property), "Value");
break;
case DateTimeSearchCompare.DateTime:
value = Expression.Constant(search.DateTime);
break;
}
Func <Expression, Expression, Expression> compareFunction = null;
if (search.Type == (DateTimeSearchType.Before | DateTimeSearchType.Exactly))
{
compareFunction = Expression.LessThanOrEqual;
}
else if (search.Type == (DateTimeSearchType.Before | DateTimeSearchType.After))
{
compareFunction = Expression.NotEqual;
}
else if (search.Type == (DateTimeSearchType.After | DateTimeSearchType.Exactly))
{
compareFunction = Expression.GreaterThanOrEqual;
}
else if (search.Type == DateTimeSearchType.Before)
{
compareFunction = Expression.LessThan;
}
else if (search.Type == DateTimeSearchType.After)
{
compareFunction = Expression.GreaterThan;
}
else if (search.Type == DateTimeSearchType.Exactly)
{
compareFunction = Expression.Equal;
}
if (compareFunction == null)
{
throw new NotSupportedException("Not supported date time compare combination.");
}
compare = compareFunction(property, value);
return(MergeExpression(target, compare));
}
