public async Task <ItemDataModel> GetItemAsync(string siteId, string id, bool loadChilds = false,
bool hasTracking = false, bool sortAscending = true)
{
string module = null;
if (string.IsNullOrEmpty(siteId))
{
module = "Site";
siteId = id;
}
var key =
JsonConvert.SerializeObject(new GetItem()
{
SiteId = siteId,
Id = id,
LoadChilds = loadChilds,
SortAscending = sortAscending
});
var item = await _cacheRepository.UseCacheAsync <Item>(key, "ItemRepository.GetItem", siteId, async() =>
{
var builder = Builders <Item> .Filter;
var filter = builder.Empty;
if (!string.IsNullOrEmpty(module))
{
filter = builder.Eq(x => x.Module, module) & builder.Eq(x => x.Guid, new Guid(id));
}
else
{
filter = builder.Eq(x => x.Guid, new Guid(id)) & builder.Eq(x => x.SiteId, siteId);
}
return(await _collection.Find(filter).FirstOrDefaultAsync());
});
if (item == null)
{
return(null);
}
var itemDataModel = MapItemDataModel(item, hasTracking);
if (loadChilds)
{
var itemFilter = new ItemFilters
{
HasTracking = hasTracking,
ParentId = item.Id,
SortAscending = sortAscending
};
var items = await GetItemsAsync(item.SiteId, itemFilter);
foreach (var dataModel in items)
{
dataModel.Parent = itemDataModel;
}
}
return(itemDataModel);
}
public IList <ItemDataModel> GetItems(string siteId, ItemFilters itemFilters)
{
var parentId = itemFilters.ParentId;
var module = itemFilters.Module;
var hasTracking = itemFilters.HasTracking;
var sortAscending = itemFilters.SortAscending;
List <Item> items;
if (!string.IsNullOrEmpty(module))
{
items =
MemoryDatabase.Database
.Where(
d =>
d.SiteId == siteId && d.ParentId == parentId && d.Module == module)
.OrderBy(d => d.Index)
.ToList();
}
else if (!string.IsNullOrEmpty(parentId))
{
items =
MemoryDatabase.Database
.Where(d => d.SiteId == siteId && d.ParentId == parentId)
.OrderBy(d => d.Index)
.ToList();
}
else
{
items =
MemoryDatabase.Database
.Where(d => d.SiteId == siteId)
.OrderBy(d => d.Index)
.ToList();
}
var result = new List <ItemDataModel>();
foreach (var item in items)
{
var itemDataModel = MapItemDataModel(item, hasTracking);
result.Add(itemDataModel);
}
return(result);
}
public Task <IList <ItemDataModel> > GetItemsAsync(string siteId, ItemFilters itemFilters)
{
throw new NotImplementedException();
}
public async Task <IList <ItemDataModel> > GetItemsAsync(string siteId, ItemFilters itemFilters)
{
var getItem = new GetItems()
{
ItemFilters = itemFilters, SiteId = siteId
};
var key = JsonConvert.SerializeObject(getItem);
var items = await _cacheRepository.UseCacheAsync <List <Item> >(key, "ItemRepository.GetItems", siteId, async() =>
{
var builder = Builders <Item> .Filter;
var filter = builder.Empty;
if (!string.IsNullOrEmpty(siteId))
{
filter = filter & builder.Eq(p => p.SiteId, siteId);
}
if (!string.IsNullOrEmpty(itemFilters.ParentId))
{
filter = filter & builder.Eq(p => p.ParentId, itemFilters.ParentId);
}
if (itemFilters.ExcludedModules != null)
{
foreach (var excludedModule in itemFilters.ExcludedModules)
{
filter = filter & builder.Ne(p => p.Module, excludedModule);
}
}
if (itemFilters.Tags != null && itemFilters.Tags.Count > 0)
{
filter = filter & builder.AnyIn("Tags", itemFilters.Tags.ToArray());
}
if (!string.IsNullOrEmpty(itemFilters.Module))
{
filter = filter & builder.Eq(p => p.Module, itemFilters.Module);
}
else if (string.IsNullOrEmpty(itemFilters.ParentId))
{
filter = filter & builder.Eq(p => p.ParentId, itemFilters.ParentId);
}
if (!string.IsNullOrEmpty(itemFilters.PropertyName))
{
filter = filter & builder.Eq(p => p.PropertyName, itemFilters.PropertyName);
}
if (itemFilters.IsTemporary.HasValue)
{
filter = filter & builder.Eq(p => p.IsTemporary, itemFilters.IsTemporary.Value);
}
if (itemFilters.States != null && itemFilters.States.Count > 0)
{
var builderState = builder.Exists(p => p.State, false);
foreach (var itemFiltersState in itemFilters.States)
{
builderState = builderState | builder.Eq(p => p.State, itemFiltersState);
}
filter = filter & builderState;
}
if (itemFilters.IndexLte.HasValue)
{
filter = filter & builder.Lte(p => p.Index, itemFilters.IndexLte.Value);
}
if (itemFilters.IndexGte.HasValue)
{
filter = filter & builder.Gte(p => p.Index, itemFilters.IndexGte.Value);
}
if (itemFilters.IndexLt.HasValue)
{
filter = filter & builder.Lt(p => p.Index, itemFilters.IndexLt.Value);
}
if (itemFilters.IndexGt.HasValue)
{
filter = filter & builder.Gt(p => p.Index, itemFilters.IndexGt.Value);
}
var cursor = _collection.Find(filter);
if (itemFilters.Limit.HasValue)
{
cursor.Limit(itemFilters.Limit.Value);
}
cursor.Sort(SetOrder(itemFilters.SortAscending));
return(await cursor.ToListAsync());
}
);
var result = new List <ItemDataModel>();
foreach (var item in items)
{
var itemDataModel = MapItemDataModel(item, itemFilters.HasTracking);
result.Add(itemDataModel);
}
return(result);
}
