using System;
using System.Collections.Generic;
using System.Data;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using ClosedXML.Excel;
using Ease.Core.DataAccess;
using Ease.Core.Model;
using Ease.Core.Utility;
using HRM.BO;
using Microsoft.Extensions.Caching.Memory;
namespace HRM.DA
{
///
/// The one service behind every virtual-scrolling grid (api/virtualGrid). It looks the grid up in
/// and serves it in one of two ways:
///
/// - List grid (): the grid's existing service returns a
/// List of business objects; that list is kept in server memory for a few minutes and every scroll,
/// sort, search and Excel export is answered from it.
/// - SQL grid (): SQL Server counts, sorts, searches and returns
/// one OFFSET/FETCH window per request (VirtualGridDA).
///
/// Shared work for both: access check, column validation, paging limits, sort whitelist, the Excel file.
///
public class VirtualGridService : ServiceTemplate, IVirtualGridService
{
private const int ExportCommandTimeoutSeconds = 600;
private const int MaxSearchLength = 200;
private const string ExcelContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
// List grids: loaded lists, per user + grid + filters. Size = rows, so at most ~1,000,000 rows are
// held in total; the least recently used lists are dropped first.
private static readonly MemoryCache ListCache = new MemoryCache(new MemoryCacheOptions { SizeLimit = 1000000 });
private static readonly TimeSpan ListCacheSliding = TimeSpan.FromMinutes(10);
private static readonly TimeSpan ListCacheAbsolute = TimeSpan.FromMinutes(30);
#region Public API
public VirtualGridLayout GetLayout(string gridKey, VirtualGridContext context)
{
VirtualGridDefinition grid = Open(gridKey, context);
List columns = GetValidatedColumns(grid, context);
VirtualGridColumn defaultSort = DefaultSortColumn(grid, columns);
var layout = new VirtualGridLayout
{
GridKey = grid.Key,
Title = grid.Title,
DefaultSortField = defaultSort?.Field,
DefaultSortDir = NormalizeDir(grid.DefaultSortDir),
MaxPageSize = grid.MaxPageSize,
};
layout.Columns.AddRange(columns.Select(c => new VirtualGridColumnInfo
{
Field = c.Field,
Title = c.Title,
Width = c.Width,
Type = c.Type,
Sortable = grid.CanSort(c),
}));
return layout;
}
public VirtualGridPage GetPage(VirtualGridRequest request, VirtualGridContext context)
{
if (request == null)
throw new ArgumentException("Invalid request.");
VirtualGridDefinition grid = Open(request.GridKey, context);
List columns = GetValidatedColumns(grid, context);
int skip = Math.Max(0, request.Skip);
int take = Math.Min(Math.Max(1, request.Take), grid.MaxPageSize);
var listSource = grid as IVirtualGridListSource;
if (listSource != null)
{
CachedList list = GetList(grid, listSource, columns, request, context);
List matches = Search(list, request.Search);
List ordered = Sort(grid, columns, list, matches, request);
return new VirtualGridPage
{
Total = ordered.Count,
TotalWithoutSearch = list.Rows.Count,
Data = ordered.Skip(skip).Take(take).Select(i => list.Rows[i]).ToList(),
};
}
var sqlGrid = (VirtualGridSqlDefinition)grid;
VirtualGridQuery query = BuildQuery(sqlGrid, columns, request, context);
var page = new VirtualGridPage();
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
page.Total = VirtualGridDA.Count(tc, query, true);
page.TotalWithoutSearch = query.SearchPattern == null ? page.Total : VirtualGridDA.Count(tc, query, false);
if (page.Total > skip)
page.Data = ReadRows(VirtualGridDA.GetRows(tc, query, skip, take));
tc.End();
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
// After the transaction: definitions may call other services that open their own.
FinishRows(sqlGrid, page.Data, context);
return page;
}
public VirtualGridFile ExportExcel(VirtualGridExportRequest request, VirtualGridContext context)
{
if (request == null)
throw new ArgumentException("Invalid request.");
VirtualGridDefinition grid = Open(request.GridKey, context);
List columns = GetValidatedColumns(grid, context);
List exportColumns = ResolveExportColumns(columns, request.Fields);
List> rows;
string filterDescription;
var listSource = grid as IVirtualGridListSource;
if (listSource != null)
{
CachedList list = GetList(grid, listSource, columns, request, context);
List ordered = Sort(grid, columns, list, Search(list, request.Search), request);
CheckExportLimit(grid, ordered.Count);
rows = ordered.Select(i => list.Rows[i]).ToList();
filterDescription = listSource.DescribeFilters(new VirtualGridFilters(request.Filters));
}
else
{
var sqlGrid = (VirtualGridSqlDefinition)grid;
VirtualGridQuery query = BuildQuery(sqlGrid, columns, request, context);
TransactionContext tc = null;
try
{
tc = TransactionContext.Begin();
tc.CommandTimeOut = ExportCommandTimeoutSeconds;
CheckExportLimit(grid, VirtualGridDA.Count(tc, query, true));
rows = ReadRows(VirtualGridDA.GetRows(tc, query, 0, null));
tc.End();
}
catch (ArgumentException)
{
if (tc != null)
tc.HandleError();
throw;
}
catch (Exception e)
{
#region Handle Exception
if (tc != null)
tc.HandleError();
ExceptionLog.Write(e);
throw new ServiceException(e.Message, e);
#endregion
}
FinishRows(sqlGrid, rows, context);
filterDescription = query.Source.FilterDescription;
}
return new VirtualGridFile
{
FileName = grid.ExcelFileName,
ContentType = ExcelContentType,
Content = BuildWorkbook(grid, exportColumns, rows, filterDescription, request.Search),
};
}
#endregion
#region Shared helpers
/// Finds the grid and checks the user may use it. Unknown key → ArgumentException.
private static VirtualGridDefinition Open(string gridKey, VirtualGridContext context)
{
if (context == null)
throw new UnauthorizedAccessException("Not signed in.");
VirtualGridDefinition grid = VirtualGridRegistry.Create(gridKey);
if (!(grid is IVirtualGridListSource) && !(grid is VirtualGridSqlDefinition))
throw new InvalidOperationException("Virtual grid '" + grid.Key
+ "' must derive from VirtualGridListDefinition or VirtualGridSqlDefinition.");
if (context.UserType == EnumUserType.Employee && !grid.AllowSelfServiceUsers)
throw new UnauthorizedAccessException("You do not have access to " + grid.Title + ".");
return grid;
}
/// The definition's columns, checked so a bad definition fails loudly.
private static List GetValidatedColumns(VirtualGridDefinition grid, VirtualGridContext context)
{
List columns = grid.GetColumns(context) ?? new List();
var seen = new HashSet(StringComparer.OrdinalIgnoreCase);
foreach (VirtualGridColumn c in columns)
{
if (!VirtualGridDefinition.IsIdentifier(c.Field) || c.Field.StartsWith("_") || !seen.Add(c.Field))
throw new InvalidOperationException("Virtual grid '" + grid.Key + "' has an invalid or duplicate column field: " + c.Field);
}
if (columns.Count == 0)
throw new InvalidOperationException("Virtual grid '" + grid.Key + "' has no columns.");
return columns;
}
private static VirtualGridColumn DefaultSortColumn(VirtualGridDefinition grid, List columns)
{
VirtualGridColumn byName = columns.FirstOrDefault(c => grid.CanSort(c)
&& string.Equals(c.Field, grid.DefaultSortField, StringComparison.OrdinalIgnoreCase));
return byName ?? columns.FirstOrDefault(c => grid.CanSort(c));
}
/// The column to sort by and its direction: a sortable column the user picked, else the grid's default.
private static VirtualGridColumn ResolveSort(VirtualGridDefinition grid, List columns,
VirtualGridRequest request, out bool descending)
{
VirtualGridColumn picked = columns.FirstOrDefault(c => grid.CanSort(c)
&& string.Equals(c.Field, request.SortField, StringComparison.OrdinalIgnoreCase));
descending = NormalizeDir(picked != null ? request.SortDir : grid.DefaultSortDir) == "desc";
return picked ?? DefaultSortColumn(grid, columns);
}
private static string NormalizeDir(string dir) =>
string.Equals(dir, "desc", StringComparison.OrdinalIgnoreCase) ? "desc" : "asc";
private static string CleanSearch(string search)
{
string term = (search ?? string.Empty).Trim();
return term.Length > MaxSearchLength ? term.Substring(0, MaxSearchLength) : term;
}
private static void CheckExportLimit(VirtualGridDefinition grid, int total)
{
if (total > grid.ExportRowLimit)
throw new ArgumentException("There are " + total.ToString("N0", CultureInfo.InvariantCulture)
+ " rows; Excel export is limited to " + grid.ExportRowLimit.ToString("N0", CultureInfo.InvariantCulture)
+ ". Please narrow the filters or the search.");
}
///
/// A value as the screen shows it (dates "dd MMM yyyy", money "1,234.56"), so the search box finds
/// what the user sees. Mirrors the formatting in <app-virtual-grid>.
///
private static string DisplayText(object value, EnumVirtualGridColumnType type)
{
if (value == null)
return string.Empty;
switch (type)
{
case EnumVirtualGridColumnType.Date:
if (value is DateTime d) return d.ToString("dd MMM yyyy", CultureInfo.InvariantCulture);
break;
case EnumVirtualGridColumnType.DateTime:
if (value is DateTime dt) return dt.ToString("dd MMM yyyy HH:mm", CultureInfo.InvariantCulture);
break;
case EnumVirtualGridColumnType.Money:
if (value is IConvertible && !(value is string))
return Convert.ToDecimal(value, CultureInfo.InvariantCulture).ToString("N2", CultureInfo.InvariantCulture);
break;
}
return Convert.ToString(value, CultureInfo.InvariantCulture);
}
#endregion
#region List grids (existing service + in-memory paging)
/// A loaded list plus, per row, the text the search box looks in.
private sealed class CachedList
{
public List> Rows;
public List SearchText;
}
///
/// The grid's list for this user and these filters: from the cache, or — on Preview (Refresh) or
/// when the cache has expired — freshly from the grid's service.
///
private static CachedList GetList(VirtualGridDefinition grid, IVirtualGridListSource source,
List columns, VirtualGridRequest request, VirtualGridContext context)
{
string key = CacheKey(grid, columns, request, context);
CachedList list;
if (!request.Refresh && ListCache.TryGetValue(key, out list))
return list;
List> rows = source.LoadRows(new VirtualGridFilters(request.Filters), context, columns);
List searchable = columns.Where(c => grid.CanSearch(c)).ToList();
var searchText = new List(rows.Count);
var sb = new StringBuilder();
foreach (Dictionary row in rows)
{
sb.Clear();
foreach (VirtualGridColumn c in searchable)
{
object value;
row.TryGetValue(c.Field, out value);
sb.Append(DisplayText(value, c.Type)).Append('\u0001'); // separator: no match across two columns
}
searchText.Add(sb.ToString());
}
list = new CachedList { Rows = rows, SearchText = searchText };
ListCache.Set(key, list, new MemoryCacheEntryOptions
{
Size = Math.Max(1, rows.Count),
SlidingExpiration = ListCacheSliding,
AbsoluteExpirationRelativeToNow = ListCacheAbsolute,
});
return list;
}
/// One list per user, payroll type, grid and filter values (and column set, in case configuration changes).
private static string CacheKey(VirtualGridDefinition grid, List columns,
VirtualGridRequest request, VirtualGridContext context)
{
var sb = new StringBuilder();
sb.Append(grid.Key.ToLowerInvariant())
.Append('|').Append(context.UserID)
.Append('|').Append(context.PayrollTypeID)
.Append('|').Append((int)context.UserType)
.Append('|').Append(string.Join(",", columns.Select(c => c.Field)));
foreach (KeyValuePair f in (request.Filters ?? new Dictionary())
.OrderBy(f => f.Key, StringComparer.OrdinalIgnoreCase))
sb.Append('|').Append(f.Key.ToLowerInvariant()).Append('=').Append(f.Value);
return sb.ToString();
}
/// Indexes of the rows whose shown text contains the search (case-insensitive); all rows when there is none.
private static List Search(CachedList list, string search)
{
string term = CleanSearch(search);
var result = new List(term.Length == 0 ? list.Rows.Count : 64);
for (int i = 0; i < list.Rows.Count; i++)
{
if (term.Length == 0 || list.SearchText[i].IndexOf(term, StringComparison.OrdinalIgnoreCase) >= 0)
result.Add(i);
}
return result;
}
/// Sorts row indexes by the chosen column (stable, so equal values keep the service's order).
private static List Sort(VirtualGridDefinition grid, List columns, CachedList list,
List indexes, VirtualGridRequest request)
{
bool descending;
VirtualGridColumn sortColumn = ResolveSort(grid, columns, request, out descending);
if (sortColumn == null)
return indexes;
string field = sortColumn.Field;
Func keyOf = i =>
{
object value;
list.Rows[i].TryGetValue(field, out value);
return value;
};
return (descending
? indexes.OrderByDescending(keyOf, ValueComparer.Instance)
: indexes.OrderBy(keyOf, ValueComparer.Instance))
.ToList();
}
/// Compares cell values: empty first, numbers as numbers, dates as dates, text case-insensitively.
private sealed class ValueComparer : IComparer