public static IModelQuery <T> Where <T>(this IModelQuery <T> query, Expression <Func <T, bool> > expression)
where T : class
{
var newClient = ((ModelQuery <T>)query).Client.Filter(expression);
return(new ModelQuery <T>(newClient));
}
public static IModelQuery <T> Take <T>(this IModelQuery <T> query, int count)
where T : class
{
var newClient = ((ModelQuery <T>)query).Client.Top(count);
return(new ModelQuery <T>(newClient));
}
public FileController(
IFileStorage fileStorage,
IModelQuery <FileInfoRecord> query,
IUnitOfWork unitOfWork,
IContentTypeProvider contentTypeProvider)
{
_fileStorage = fileStorage;
_query = query;
_unitOfWork = unitOfWork;
_contentTypeProvider = contentTypeProvider;
}
public GenericODataEntityController(
IUnitOfWork unitOfWork,
IModelQueryBuilder modelQueryBuilder,
ICreateTrigger <T> createTrigger = null,
IUpdateTrigger <T> updateTrigger = null,
IDeleteTrigger <T> deleteTrigger = null)
{
_unitOfWork = unitOfWork;
_query = modelQueryBuilder.Build <T>();
_createTrigger = createTrigger;
_updateTrigger = updateTrigger;
_deleteTrigger = deleteTrigger;
}
private static GroupContainer FromQuery(IModelQuery <TimeEntryModel> query)
{
var groups = new GroupContainer();
try {
// Find unique time entries and add them to the list
foreach (var entry in query)
{
if (groups.Contains(entry))
{
continue;
}
groups.Add(entry);
}
groups.Sort();
} catch (Exception exc) {
var log = ServiceContainer.Resolve <Logger> ();
log.Error(Tag, exc, "Failed to compose recent time entries");
}
return(groups);
}
public static IReadOnlyLogbook Build <TModel>(this IModelQuery <TModel> modelQuery, out TModel model) where TModel : class, IModel, new()
{
model = null;
ILogbook logs = Logger.NewLogbook();
if (modelQuery.Fields.Build <TModel>(out IEnumerable <Field> fields))
{
IReadOnlyDictionary <Field, object> valueMap = modelQuery.ValueMap;
IReadOnlyDictionary <Field, ReadOnlyLogbookPredicate <object> > predicateMap = modelQuery.PredicateMap;
foreach (Field field in fields)
{
bool valueFound = valueMap.TryGetValue(field, out object value);
bool predicateFound = predicateMap.TryGetValue(field, out ReadOnlyLogbookPredicate <object> predicate);
if (valueFound && predicateFound && predicate != null)
{
logs.AddRange(predicate.Invoke(value));
}
}
if (logs.Safely)
{
model = new TModel();
Type modelType = typeof(TModel);
IEnumerable <Field> modelFields = Field.Parse <TModel>();
foreach (Field modelField in modelFields)
{
PropertyInfo propertyField = modelType.GetProperty(modelField.Name);
propertyField.SetValue(model, valueMap[modelField]);
}
}
}
return(logs);
}
public virtual long FindModelCountByQueryCriteria(IModelQuery query)
{
return(modelDataManager.FindModelCountByQueryCriteria(query));
}
public virtual IList <IModel> FindModelsByQueryCriteria(IModelQuery query, Page page)
{
return(modelDataManager.FindModelsByQueryCriteria(query, page));
}
protected virtual void EnsureCacheTimeQuery()
{
if (CacheTimeQuery == null) CacheTimeQuery = new ShortTime(ServerTimeSpan, ClientTimeSpan);
}
private void ResetCacheTimeQuery()
{
CacheTimeQuery = new ShortTime(ServerTimeSpan, ClientTimeSpan);
}
public virtual IList <IModel> FindModelsByQueryCriteria(IModelQuery query, Page page)
{
return(DbSqlSession.SelectList <ModelEntityImpl, IModel>("selectModelsByQueryCriteria", query, page));
}
protected void ResetCacheTimeQuery()
{
CacheTimeQuery = new ShortTime(ServerTimeSpan, ClientTimeSpan);
}
public GenericODataViewController(IModelQueryBuilder modelQueryBuilder)
{
_query = modelQueryBuilder.Build <T>();
_keyPropertyName = DatabaseHelper.GetKeyProperty <T>().Name;
}
public static async Task <T> FirstOrDefaultAsync <T>(this IModelQuery <T> query, Expression <Func <T, bool> > expression)
{
return(await((ModelQuery <T>)query).Queryable.FirstOrDefaultAsync(expression));
}
public virtual long FindModelCountByQueryCriteria(IModelQuery query)
{
return(DbSqlSession.SelectOne <ModelEntityImpl, long?>("selectModelCountByQueryCriteria", query).GetValueOrDefault());
}
public ModelQueryView(IModelQuery <T> query, int batchSize)
{
this.query = query;
this.batchSize = batchSize;
Reload();
}
public static IModelQuery <TimeEntryModel> ForCurrentUser(this IModelQuery <TimeEntryModel> q)
{
var authManager = ServiceContainer.Resolve <AuthManager> ();
return(q.Where((entry) => entry.UserId == authManager.UserId));
}
public static IModelQuery <T> NotDeleted <T> (this IModelQuery <T> q)
where T : Model, new()
{
return(q.Where((entry) => entry.DeletedAt == null));
}
protected void ResetCacheTimeQuery()
{
CacheTimeQuery = new ShortTime( ServerTimeSpan, ClientTimeSpan );
}
public static Task <T> FirstOrDefaultAsync <T>(this IModelQuery <T> query, Expression <Func <T, bool> > expression)
where T : class
{
return(((ModelQuery <T>)query).Client.Filter(expression).FindEntryAsync());
}
