// GET: Admin/Basic
public ActionResult Index(int?page, FilterOptions options)
{
var allReservations = this.reservations.All();
var pagination = this.Paginate(page, allReservations.Count());
if (pagination.IsRedirect)
{
return(Index(pagination.Page, options));
}
ViewBag.CurrentPage = pagination.Page;
// Holds the view numbering of the reservations
ViewBag.CountStart = pagination.SkipSize;
IFilterStrategy filter = filterFactory.GetFilter(options);
if (filter != null)
{
allReservations = filter.Filter(allReservations);
}
IEnumerable <ReservationsOutputModel> viewReservations = allReservations
.OrderByDescending(x => x.CreatedOn)
.Skip(pagination.SkipSize)
.Take(PAGE_SIZE)
.Project()
.To <ReservationsOutputModel>()
.ToList();
return(View(viewReservations));
}
private async Task <int> GetWarningDuration(ulong guildId, FilterType type)
{
return(await _filterFactory.GetFilter(type).GetWarningExpirePeriod(guildId));
}
private async Task <Pagination <TEntity> > NormalizePagination(Pagination <TEntity> pagination)
{
var p = pagination ??= new Pagination <TEntity>();
if (!p.QueryOrFilter.HasValue() && p.QueryFunc == null)
{
p.QueryFunc = x => true;
}
var filter = p.QueryOrFilter.HasValue() ?
await FilterFactory.GetFilter <TEntity>(p.QueryOrFilter) : null;
if (filter != null)
{
var f = filter(new object());//payload is not supported yet
if (f == null)
{
return(null);
}
p.QueryFunc = c => f(c);
}
else
{
if (p.QueryFunc == null) //build only if func not exists
{
var right = ExpressionTreeBuilder.BuildBinaryTreeExpression <TEntity>(p.QueryOrFilter)?.Compile();
if (right == null)
{
return(null);
}
var ecr = WorkContext.CurrentEntityConfigRecord;
if (Config.ManageEntityPermissions)
{
var permittedIds = await PermissionManager.GetPermittedIds(WorkContext.CurrentUserId, ecr.EntityKey, ecr.PermissionRecord.ReadKey);
Func <TEntity, bool> left = a => permittedIds.Contains(a.Id);
p.QueryFunc = x => left(x) && right(x);
}
else
{
p.QueryFunc = x => right(x);
}
}
}
if (p.QueryFunc == null)
{
return(null);
}
if (!CurrentEntityConfigRecord.Metadata.ShowSoftDeleted && CurrentEntityConfigRecord.Metadata.IsSoftDeleted)
{
p.QueryFunc = p.QueryFunc.AndAlso(HideSoftDeletedFunc);
}
var paginationSettings = WorkContext.CurrentEntityConfigRecord.PaginationSettings;
p.OrderBy ??= paginationSettings.DefaultOrderBy;
p.Offset = p.Offset != 0 ? p.Offset : paginationSettings.DefaultOffset;
p.PageSize = p.PageSize != 0 ? p.PageSize : paginationSettings.DefaultPageSize;
p.IncludeNested = p.IncludeNested;
p.SortOrder ??= paginationSettings.DefaultSortOrder;
return(p);
}
public void Run(string[] args)
{
if (args == null || args.Length < 2)
{
return;
}
var target = args[1];
if (string.IsNullOrEmpty(target))
{
_dialogService.Warn("Empty target argument");
return;
}
if (_config == null)
{
try {
_config = _configProvider.GetConfig();
} catch (Exception ex) {
_dialogService.Error("Failed reading config:\n" + ex);
return;
}
}
if (_config?.Mappings == null || !_config.Mappings.Any())
{
_dialogService.Info("No mappings in config");
return;
}
List <Mapping> matchedMappings;
try {
matchedMappings =
_config.Mappings
.Where(m =>
m.Filters != null &&
m.Filters
.Select(f => _filterFactory.GetFilter(f.Key, f.Value))
.Where(f => f != null)
.All(f => f.Accepts(target))
)
.OrderBy(m => m.Priority).ThenBy(m => m.Name)
.Take(10)
.ToList();
if (!matchedMappings.Any())
{
matchedMappings =
_config.Mappings
.Where(m => m.Filters == null)
.OrderBy(m => m.Priority).ThenBy(m => m.Name)
.Take(10)
.ToList();
}
}
catch (Exception ex) {
_dialogService.Error(ex.ToString());
return;
}
if (!matchedMappings.Any())
{
return;
}
var stringExpander = new VarsStringExpander(_config.Vars);
bool StartMapping(Mapping mapping)
{
if (mapping != null)
{
var command = stringExpander.Expand(mapping.Command);
try {
_processStarter.Start(
command,
mapping.Admin,
Path.GetDirectoryName(target),
stringExpander.Expand(mapping.Args),
args
);
return(true);
}
catch (Exception ex) {
_dialogService.Error($"Error starting '{command}':\n" + ex);
}
}
return(false);
}
if (matchedMappings.Count == 1)
{
var mapping = matchedMappings.First();
StartMapping(mapping);
return;
}
MainWindow mainWindow = null;
mainWindow = new MainWindow {
AllowsTransparency = _config.Opacity < 1.0,
Opacity = _config.Opacity,
DataContext = new MainViewModel {
Theme = _config.Theme,
HeaderText = string.Format(_config.HeaderTemplate, target, Path.GetFileName(target)),
Items = matchedMappings.Select((m, i) => new OptionViewModel {
Number = i + 1,
Name = m.Name,
IconSupplier = () => _iconProvider.GetIcon(stringExpander.Expand(m.Icon ?? m.Command)).Result,
Action = () => { if (StartMapping(m))
{
mainWindow.Close();
}
}
}).ToList(),
CloseTimeout = _config.AutoCloseTimeout * 1000,
CloseAction = () => mainWindow.Close()
}
};
var app = new Application {
ShutdownMode = ShutdownMode.OnMainWindowClose,
MainWindow = mainWindow
};
mainWindow.Show();
app.Run();
}