private IQueryable <Model.DynamicAvatarItem> ApplyFilters(AvatarFilter filter)
{
var items = DbSet.AsNoTracking()
.Where(_ => _.DynamicAvatarLayer.SiteId == filter.SiteId);
if (filter.Unlockable.HasValue)
{
items = items.Where(_ => _.Unlockable == filter.Unlockable.Value);
}
if (filter.LayerId.HasValue)
{
items = items.Where(_ => _.DynamicAvatarLayerId == filter.LayerId.Value);
}
if (filter.ItemIds?.Count > 0)
{
items = items.Where(_ => !filter.ItemIds.Contains(_.Id));
}
if (!string.IsNullOrEmpty(filter.Search))
{
items = items.Where(_ => _.Name.Contains(filter.Search));
}
return(items);
}
public async Task <IActionResult> Bundles(bool unlockable = true, int page = 1)
{
var filter = new AvatarFilter(page)
{
Unlockable = unlockable
};
var bundleList = await _avatarService.GetPaginatedBundleListAsync(filter);
var paginateModel = new PaginateViewModel()
{
ItemCount = bundleList.Count,
CurrentPage = page,
ItemsPerPage = filter.Take.Value
};
if (paginateModel.MaxPage > 0 && paginateModel.CurrentPage > paginateModel.MaxPage)
{
return(RedirectToRoute(
new
{
page = paginateModel.LastPage ?? 1
}));
}
var viewModel = new BundlesListViewModel()
{
Bundles = bundleList.Data,
PaginateModel = paginateModel,
Unlockable = unlockable
};
PageTitle = "Avatar Bundles";
return(View(viewModel));
}
public async Task <ICollection <DynamicAvatarItem> > PageAsync(AvatarFilter filter)
{
return(await ApplyFilters(filter)
.ApplyPagination(filter)
.ProjectTo <DynamicAvatarItem>()
.ToListAsync());
}
public async Task <ICollection <AvatarBundle> > PageAsync(AvatarFilter filter)
{
return(await ApplyFilters(filter)
.ApplyPagination(filter)
.ProjectTo <AvatarBundle>()
.ToListAsync());
}
public async Task <ICollection <AvatarItem> > PageAsync(AvatarFilter filter)
{
return(await ApplyFilters(filter)
.OrderBy(_ => _.SortOrder)
.ApplyPagination(filter)
.ProjectTo <AvatarItem>(_mapper.ConfigurationProvider)
.ToListAsync());
}
GetPaginatedBundleListAsync(AvatarFilter filter)
{
VerifyManagementPermission();
filter.SiteId = GetCurrentSiteId();
return(new DataWithCount <ICollection <AvatarBundle> >
{
Data = await _avatarBundleRepository.PageAsync(filter),
Count = await _avatarBundleRepository.CountAsync(filter)
});
}
public async Task <DataWithCount <ICollection <AvatarItem> > > PageItemsAsync(
AvatarFilter filter)
{
VerifyManagementPermission();
filter.SiteId = GetCurrentSiteId();
return(new DataWithCount <ICollection <AvatarItem> >
{
Data = await _avatarItemRepository.PageAsync(filter),
Count = await _avatarItemRepository.CountAsync(filter)
});
}
private IQueryable <Model.AvatarBundle> ApplyFilters(AvatarFilter filter)
{
var bundles = DbSet
.AsNoTracking()
.Where(_ => _.SiteId == filter.SiteId && !_.IsDeleted);
if (filter.Unlockable)
{
bundles = bundles.Where(_ => _.CanBeUnlocked);
}
return(bundles);
}
private IQueryable <Model.AvatarItem> ApplyFilters(AvatarFilter filter)
{
var items = DbSet.AsNoTracking()
.Where(_ => _.AvatarLayer.SiteId == filter.SiteId);
if (filter.Available)
{
items = items.Where(_ => !_.Unlockable);
}
else if (filter.CanBeUnlocked || filter.Unavailable || filter.Unlockable)
{
items = items.Where(_ => _.Unlockable);
if (filter.Unavailable || filter.Unlockable)
{
var unlockableItems = _context.AvatarBundleItems
.Where(_ => !_.AvatarBundle.IsDeleted && _.AvatarBundle.CanBeUnlocked)
.Select(_ => _.AvatarItemId)
.Distinct();
if (filter.Unavailable)
{
items = items.Where(_ => !unlockableItems.Contains(_.Id));
}
else
{
items = items.Where(_ => unlockableItems.Contains(_.Id));
}
}
}
if (filter.LayerId.HasValue)
{
items = items.Where(_ => _.AvatarLayerId == filter.LayerId.Value);
}
if (filter.ItemIds?.Count > 0)
{
items = items.Where(_ => !filter.ItemIds.Contains(_.Id));
}
if (!string.IsNullOrEmpty(filter.Search))
{
items = items.Where(_ =>
_.Name.Contains(filter.Search, System.StringComparison.OrdinalIgnoreCase));
}
return(items);
}
public async Task <IActionResult> Layer(int id, string search, bool?unlockable = null,
int page = 1)
{
var filter = new AvatarFilter(page, 12)
{
LayerId = id,
Search = search,
Unlockable = unlockable
};
var itemList = await _avatarService.PageItemsAsync(filter);
PaginateViewModel paginateModel = new PaginateViewModel()
{
ItemCount = itemList.Count,
CurrentPage = page,
ItemsPerPage = filter.Take.Value
};
if (paginateModel.MaxPage > 0 && paginateModel.CurrentPage > paginateModel.MaxPage)
{
return(RedirectToRoute(
new
{
page = paginateModel.LastPage ?? 1
}));
}
foreach (var item in itemList.Data)
{
item.Thumbnail = _pathResolver.ResolveContentPath(item.Thumbnail);
}
if (itemList.Data.Any())
{
PageTitle = $"Avatar Items: {itemList.Data.First().AvatarLayerName}";
}
var viewModel = new ItemsListViewModel()
{
Items = itemList.Data,
PaginateModel = paginateModel,
Id = id,
Search = search,
Unlockable = unlockable
};
return(View(viewModel));
}
public async Task <IActionResult> GetItemsList(string itemIds,
int?layerId,
string search,
bool unlockable,
int page = 1)
{
var filter = new AvatarFilter(page, 10)
{
Search = search,
LayerId = layerId,
Unlockable = unlockable
};
if (!string.IsNullOrWhiteSpace(itemIds))
{
filter.ItemIds = itemIds.Split(',')
.Where(_ => !string.IsNullOrWhiteSpace(_))
.Select(int.Parse)
.ToList();
}
var items = await _avatarService.PageItemsAsync(filter);
var paginateModel = new PaginateViewModel
{
ItemCount = items.Count,
CurrentPage = page,
ItemsPerPage = filter.Take.Value
};
foreach (var item in items.Data)
{
if (!string.IsNullOrWhiteSpace(item.Thumbnail))
{
item.Thumbnail = _pathResolver.ResolveContentPath(item.Thumbnail);
}
}
var viewModel = new ItemsListViewModel
{
Items = items.Data,
PaginateModel = paginateModel
};
return(PartialView("_ItemsPartial", viewModel));
}
public async Task <int> CountAsync(AvatarFilter filter)
{
return(await ApplyFilters(filter)
.CountAsync());
}
public async Task <IActionResult> Layer(int id,
string search,
bool available = false,
bool unavailable = false,
bool unlockable = false,
int page = 1)
{
var computedAvailable = available;
var computedUnavailable = unavailable;
var computedUnlockable = unlockable;
var filter = new AvatarFilter(page, 12)
{
LayerId = id,
Search = search
};
if (computedAvailable)
{
filter.Available = true;
computedUnavailable = false;
computedUnlockable = false;
}
else if (computedUnavailable)
{
filter.Unavailable = true;
computedUnlockable = false;
}
else if (computedUnlockable)
{
filter.Unlockable = true;
}
var itemList = await _avatarService.PageItemsAsync(filter);
var paginateModel = new PaginateViewModel
{
ItemCount = itemList.Count,
CurrentPage = page,
ItemsPerPage = filter.Take.Value
};
if (paginateModel.PastMaxPage)
{
return(RedirectToRoute(
new
{
page = paginateModel.LastPage ?? 1
}));
}
foreach (var item in itemList.Data)
{
item.Thumbnail = _pathResolver.ResolveContentPath(item.Thumbnail);
}
if (itemList.Data.Count > 0)
{
PageTitle = $"Avatar Items: {itemList.Data.First().AvatarLayerName}";
}
var viewModel = new ItemsListViewModel
{
Items = itemList.Data,
PaginateModel = paginateModel,
Id = id,
Search = search,
Available = computedAvailable,
Unavailable = computedUnavailable,
Unlockable = computedUnlockable
};
return(View(viewModel));
}
