public static DataTableResponseModel <T> GetDataTableResponse <T>(this IQueryable <T> data,
DataTableRequestModel dataTableRequestModel) where T : class, new()
{
// Count or LongCount is very annoying cause an extra evaluation.
var totalRecords = data.Count();
var filters = new DataTableParamModelHelper();
var outputProperties = new DataTableTypeInfoModel <T>().Properties;
var filteredData = filters.ApplyFiltersAndSort(dataTableRequestModel, data, outputProperties);
var totalDisplayRecords = filteredData.Count();
var skipped = filteredData.Skip(dataTableRequestModel.DisplayStart);
var page = (dataTableRequestModel.DisplayLength <= 0
? skipped
: skipped.Take(dataTableRequestModel.DisplayLength)).ToArray();
var result = new DataTableResponseModel <T>
{
TotalRecord = totalRecords,
TotalDisplayRecord = totalDisplayRecords,
Echo = dataTableRequestModel.Echo,
Data = page.Cast <object>().ToArray()
};
return(result);
}
public DataTableResponseModel <SmallBusinessSubjectAuditViewModel> GetSmallBusinessSubjectAuditDataTable(int start, int length, int draw, string name, DateTime?startDate, DateTime?endDate)
{
try {
var model = new DataTableResponseModel <SmallBusinessSubjectAuditViewModel>();
var smallBusinessSubjectAudits = GetEntities <SmallBusinessSubjectAudit>(true,
x => x.SmallBusinessSubject,
x => x.SupervisoryAuthority);
if (!string.IsNullOrEmpty(name))
{
name = name.ToLower();
smallBusinessSubjectAudits = smallBusinessSubjectAudits.Where(x => x.SmallBusinessSubject.Name.ToLower().Contains(name));
}
if (startDate.HasValue)
{
smallBusinessSubjectAudits = smallBusinessSubjectAudits.Where(x => x.BeginAuditDate >= startDate.Value);
}
if (endDate.HasValue)
{
smallBusinessSubjectAudits = smallBusinessSubjectAudits.Where(x => x.BeginAuditDate <= endDate.Value);
}
model.recordsFiltered = smallBusinessSubjectAudits.Count();
var data = smallBusinessSubjectAudits.OrderBy(x => 0)
.Skip(start).Take(length).Select(ModelToViewModel()).ToArray();
model.data = data;
model.draw = draw;
return(model);
} catch (Exception e) {
return(DataTableResponseModel <SmallBusinessSubjectAuditViewModel> .ErrorResponse(e));
}
}
public DataTableActionResult <UserModel> GetDataTable([FromForm] DataTableRequestModel model)
{
// 1. In Service Layer
DataTableResponseModel <UserModel> response = GetDataTableResponse(model);
// 2. In Controller
var result = response.GetDataTableActionResult(model, x => new
{
IsActive = x.IsActive ? "Yes" : "No" // Transform Data before Response
});
return(result);
}
public DataTableResponseModel InquiryMasterDatatable(DatableOption option, ConfigurationMaster master)
{
var result = new DataTableResponseModel();
try
{
_logger.LogInformation($"Start => {MethodBase.GetCurrentMethod().Name}");
result = _dataAccess.ConfigurationDataAccess.InquiryMasterDatatable(option, master);
_logger.LogInformation($"Finish => {MethodBase.GetCurrentMethod().Name}", JsonSerializer.Serialize(result));
}
catch (Exception ex)
{
_logger.LogError(ex, $"Faile => {MethodBase.GetCurrentMethod().Name}");
}
return(result);
}
internal static DataTableActionResult <T> Create <T>(DataTableRequestModel request,
DataTableResponseModel <T> response) where T : class, new()
{
var result = new DataTableActionResult <T>(response);
var dictionaryTransformFunc = new DataTableTypeInfoModel <T>().ToFuncDictionary();
result.Data =
result
.Data
.Transform(dictionaryTransformFunc)
.Transform <Dictionary <string, object>, Dictionary <string, object> >(
StringTransformer.StringifyValues);
result.Data = ApplyOutputRules(request, result.Data);
return(result);
}
public DataTableResponseModel InquiryMasterDatatable(DatableOption option, ConfigurationMaster master)
{
var methodName = MethodBase.GetCurrentMethod().Name;
var result = new DataTableResponseModel();
try
{
_logger.LogInformation($"Start Function => {methodName}, Parameters => {JsonSerializer.Serialize(master)}");
result = _dataAccess.ConfigurationDataAccess.InquiryMasterDatatable(option, master);
_logger.LogInformation($"Finish Function => {methodName}, Result => {JsonSerializer.Serialize(result)}");
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error Function => {methodName}");
}
return(result);
}
private static DataTableResponseModel <T> ApplyOutputRules <T>(DataTableRequestModel request,
DataTableResponseModel <T> response) where T : class, new()
{
if (request.ColReorderIndexs?.Any() == true)
{
var actualData = new List <Dictionary <string, object> >();
foreach (var row in response.Data)
{
var correctIndexDictionary = new Dictionary <string, object>();
if (!(row is Dictionary <string, object> rowDictionary))
{
continue;
}
foreach (var acctualIndex in request.ColReorderIndexs)
{
if (rowDictionary.Count <= acctualIndex)
{
correctIndexDictionary.Add(acctualIndex.ToString(), string.Empty);
continue;
}
var acctualCol = rowDictionary.ElementAt(acctualIndex);
correctIndexDictionary.Add(acctualCol.Key, acctualCol.Value);
}
actualData.Add(correctIndexDictionary);
}
response.Data = actualData.Cast <object>().ToArray();
}
var outputData = response.Transform <Dictionary <string, object>, object[]>(d => d.Values.ToArray());
return(outputData);
}
/// <typeparam name="T"></typeparam>
/// <param name="request"> </param>
/// <param name="response">
/// The properties of this can be marked up with [DataTablesAttribute] to control sorting/searchability/visibility
/// </param>
/// <param name="transform">
/// // a transform for custom column rendering e.g. to do a custom date row => new {
/// CreatedDate = row.CreatedDate.ToString("dd MM yy") }
/// </param>
/// <returns></returns>
internal static DataTableActionResult <T> Create <T>(DataTableRequestModel request,
DataTableResponseModel <T> response, Func <T, object> transform)
where T : class, new()
{
transform = transform ?? (s => s);
var result = new DataTableActionResult <T>(response);
result.Data =
result
.Data
.Transform <T, Dictionary <string, object> >
(
row => TransformTypeInfoHelper.MergeTransformValuesIntoDictionary(transform, row)
)
.Transform <Dictionary <string, object>, Dictionary <string, object> >(
StringTransformer.StringifyValues);
result.Data = ApplyOutputRules(request, result.Data);
return(result);
}
public JsonResult InquiryDataTableUser(DatableOption option, UserModel model)
{
var users = new List <UserModel>();
for (int i = 0; i < 30; i++)
{
users.Add(new UserModel {
ID = Guid.NewGuid(), Code = $"000{ i.ToString() }", Name = $"Name{i.ToString()}", Last = $"Last{ i.ToString()}", CreateBy = $"CreateBy {i.ToString()}", CreateDate = DateTime.Now
});
}
var query = (from user in users
where string.IsNullOrEmpty(model.Name) || model.Name.Contains(user.Name)
where string.IsNullOrEmpty(model.Last) || model.Last.Contains(user.Last)
select user);
switch (option.sortingby)
{
case 1: query = (option.orderby == "asc" ? query.OrderBy(r => r.Code) : query.OrderByDescending(r => r.Code)); break;
case 2: query = (option.orderby == "asc" ? query.OrderBy(r => r.Name) : query.OrderByDescending(r => r.Name)); break;
case 3: query = (option.orderby == "asc" ? query.OrderBy(r => r.Last) : query.OrderByDescending(r => r.Last)); break;
case 4: query = (option.orderby == "asc" ? query.OrderBy(r => r.CreateDate) : query.OrderByDescending(r => r.CreateDate)); break;
case 5: query = (option.orderby == "asc" ? query.OrderBy(r => r.CreateBy) : query.OrderByDescending(r => r.CreateBy)); break;
default: query = (option.orderby == "asc" ? query.OrderBy(r => r.Code) : query.OrderByDescending(r => r.Code)); break;
}
var datas = query.Skip(option.start).Take(option.length).ToList();
var recordsTotal = query.Count();
var result = new DataTableResponseModel {
status = true, message = "success", data = datas, draw = option.draw, recordsTotal = recordsTotal, recordsFiltered = recordsTotal
};
return(Json(result));
}
/// <typeparam name="T"></typeparam>
/// <param name="request"> </param>
/// <param name="response">
/// The properties of this can be marked up with [DataTablesAttribute] to control sorting/searchability/visibility
/// </param>
/// <returns></returns>
protected DataTableActionResult <T> Create <T>(DataTableRequestModel request, DataTableResponseModel <T> response)
where T : class, new()
{
return(DataTableActionResultHelper.Create(request, response));
}
/// <typeparam name="T"></typeparam>
/// <param name="request"> </param>
/// <param name="response">
/// The properties of this can be marked up with [DataTablesAttribute] to control sorting/searchability/visibility
/// </param>
/// <param name="transform">
/// // a transform for custom column rendering e.g. to do a custom date row => new {
/// CreatedDate = row.CreatedDate.ToString("dd MM yy") }
/// </param>
/// <returns></returns>
protected DataTableActionResult <T> Create <T>(DataTableRequestModel request, DataTableResponseModel <T> response,
Func <T, object> transform) where T : class, new()
{
return(DataTableActionResultHelper.Create(request, response, transform));
}
public static DataTableResult FromModel(DataTableResponseModel model)
{
string content = JsonConvert.SerializeObject(model);
return(new DataTableResult(content));
}
public static DataTableActionResult <T> GetDataTableActionResult <T>(this DataTableResponseModel <T> response,
DataTableRequestModel request) where T : class, new()
{
return(DataTableActionResultHelper.Create(request, response));
}
public static DataTableActionResult <T> GetDataTableActionResult <T>(this DataTableResponseModel <T> response,
DataTableRequestModel request, Func <T, object> transform)
where T : class, new()
{
return(DataTableActionResultHelper.Create(request, response, transform));
}
public DataTableResponseModel InquiryMasterDatatable(DatableOption option, ConfigurationMaster master)
{
var methodName = MethodBase.GetCurrentMethod().Name;
var result = new DataTableResponseModel();
try
{
_logger.LogInformation($"Start Function => {methodName}, Parameters => {JsonSerializer.Serialize(master)}");
var query = _context.ConfigurationMaster
.Where(r => (master.ID == Guid.Empty || r.ID == master.ID))
.Where(r => master.IsActive == null || r.IsActive == master.IsActive)
.OrderByDescending(r => r.CreateDate)
.ThenByDescending(r => r.UpdateDate)
.Select(item => new ConfigurationMaster
{
ID = item.ID,
TemplateName = item.TemplateName,
InputFile = item.InputFile,
OutputFile = item.OutputFile,
CreateDate = item.CreateDate,
CreateBy = item.CreateBy,
UpdateDate = item.UpdateDate,
IsActive = item.IsActive
});
switch (option.sortingby)
{
case 1: query = (option.orderby == "asc" ? query.OrderBy(r => r.TemplateName) : query.OrderByDescending(r => r.TemplateName)); break;
case 2: query = (option.orderby == "asc" ? query.OrderBy(r => r.InputFile) : query.OrderByDescending(r => r.InputFile)); break;
case 3: query = (option.orderby == "asc" ? query.OrderBy(r => r.OutputFile) : query.OrderByDescending(r => r.OutputFile)); break;
case 4: query = (option.orderby == "asc" ? query.OrderBy(r => r.CreateDate) : query.OrderByDescending(r => r.CreateDate)); break;
case 5: query = (option.orderby == "asc" ? query.OrderBy(r => r.CreateBy) : query.OrderByDescending(r => r.CreateBy)); break;
case 6: query = (option.orderby == "asc" ? query.OrderBy(r => r.UpdateDate) : query.OrderByDescending(r => r.UpdateDate)); break;
case 7: query = (option.orderby == "asc" ? query.OrderBy(r => r.UpdateBy) : query.OrderByDescending(r => r.UpdateBy)); break;
default: query = (option.orderby == "asc" ? query.OrderBy(r => r.CreateDate) : query.OrderByDescending(r => r.CreateDate)); break;
}
var datas = query.Skip(option.start).Take(option.length).ToList();
var recordsTotal = query.Count();
result = new DataTableResponseModel
{
status = true,
message = "success",
data = datas,
draw = option.draw,
recordsTotal = recordsTotal,
recordsFiltered = recordsTotal
};
_logger.LogInformation($"Finish Function => {methodName}, Result => {JsonSerializer.Serialize(result)}");
}
catch (Exception ex)
{
var messageError = $"Error Function => {methodName}";
_logger.LogError(ex, messageError);
throw new ArgumentException(messageError, ex);
}
return(result);
}
public DataTableActionResult(DataTableResponseModel <T> data)
{
Data = data;
}
