public JsonResult UserDataHandler(DTParameters param)
{
try
{
var dtsource = svc.GetUserDtos(u => !u.IsDeleted).ToList();
List <string> columnSearch = new List <string>();
foreach (var col in param.Columns)
{
columnSearch.Add(col.Search.Value);
}
List <UserDto> data = new ResultSet().GetResult <IEnumerable <UserDto> >(
param.Search.Value,
param.SortOrder,
param.Start, param.Length,
dtsource, columnSearch,
UserFilterType.UserMap).ToList();
int count = new ResultSet().Count(param.Search.Value, dtsource, columnSearch, UserFilterType.UserMap);
DTResult <UserDto> result = new DTResult <UserDto>
{
draw = param.Draw,
data = data.ToList(),
recordsFiltered = count,
recordsTotal = count
};
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(Json(new { error = ex.Message }));
}
}
public JsonResult GetCategory(DTParameters param)
{
CategoryPageStore category = new CategoryPageStore();
category.PageIndex = param.Start / param.Length + 1;
category.PageSize = param.Length;
if (param.Search.Value == null)
{
category.Search = "%%";
}
else
{
category.Search = "%" + param.Search.Value + "%";
}
category.Order = param.SortOrder;
CategoryPageStore categories = new CategoryModel().GetCategoryByPage(category.Search, category.Order, category.PageIndex, category.PageSize);
DTResult <CategoryDTO> final = new DTResult <CategoryDTO>()
{
draw = param.Draw,
data = categories.Categories.ToList(),
recordsFiltered = categories.RecordCount,
recordsTotal = categories.Categories.Count
};
return(Json(final));
}
public JsonResult GetProducts(DTParameters param)
{
var query = db.Products.AsQueryable();
var totalCount = query.Count();
if (!string.IsNullOrEmpty(param.Search.Value))
{//where
var value = param.Search.Value.Trim();
query = query.Where(x => x.Title.Contains(value));
}
var filteredCount = query.Count();
var products = query.OrderBy(x => x.Title)
.Skip(param.Start)
.Take(param.Length)
.ToList();
var result = new DTResult <Product>
{
draw = param.Draw,
data = products,
recordsFiltered = filteredCount,
recordsTotal = totalCount
};
return(Json(result));
}
public JsonResult LoadLayouts(DTParameters param)
{
var filtered = _pagesContext.FilterAbstractContext <Page>(param.Search.Value, param.SortOrder, param.Start,
param.Length,
out var totalCount, x => x.IsLayout && !x.IsDeleted).Select(x => new Page
{
Id = x.Id,
Created = x.Created,
Changed = x.Changed,
Author = x.Author,
Settings = _pagesContext.PageSettings.FirstOrDefault(y => y.Id.Equals(x.SettingsId)),
PageType = x.PageType,
ModifiedBy = x.ModifiedBy,
IsDeleted = x.IsDeleted,
SettingsId = x.SettingsId,
PageTypeId = x.PageTypeId,
IsSystem = x.IsSystem,
Path = x.Path
}).ToList();
var finalResult = new DTResult <Page>
{
Draw = param.Draw,
Data = filtered.ToList(),
RecordsFiltered = totalCount,
RecordsTotal = filtered.Count()
};
return(Json(finalResult));
}
public static object ResponeDataTable(DTParameters param, IList <T> data, int intCount)
{
try
{
//List<Customer> data = new ResultSet().GetResult(param.Search.Value, param.SortOrder, param.Start, param.Length, dtsource, columnSearch);
// int count = new ResultSet().Count(param.Search.Value, dtsource, columnSearch);
DTResult <T> result = new DTResult <T>
{
draw = param.Draw,
data = data,
recordsFiltered = intCount,
recordsTotal = intCount
};
//SendResponse(HttpContext.Current.Response, result);
return(result);
}
catch (Exception ex)
{
//SendResponse(HttpContext.Current.Response, new { error = ex.Message });
return(new { error = ex.Message });
}
}
public async Task <IActionResult> DataHandlerHistory([FromBody] JObject json)
{
try
{
var a = Request;
var param = JsonConvert.DeserializeObject <DTParameters>(json.GetValue("param1").ToString());
var dictionary = new Dictionary <string, string>();
dictionary = JsonConvert.DeserializeObject <Dictionary <string, string> >(json.GetValue("data").ToString());
var id_supplier = dictionary["id_supplier"];
//var id_position = dictionary["id_position"];
var query = repo.FindAllHistory().Where(d => d.db.id_supplier == id_supplier);
var count = query.Count();
var dataList = await Task.Run(() => query
.OrderByDescending(d => d.db.update_date).ToList());
DTResult <sys_vendor_item_history_model> result = new DTResult <sys_vendor_item_history_model>
{
data = dataList,
recordsFiltered = count,
recordsTotal = count
};
return(Json(result));
}
catch (Exception ex)
{
return(Json(new { error = ex.Message }));
}
}
public JsonResult SRList(DTParameters param, string StatusType)
{
int TotalCount = 0;
var filtered = this.GetSRFiltered(param.Search.Value, param.SortOrder, param.Start, param.Length, StatusType, out TotalCount);
var SRList = filtered.Select(o => new ServiceRequests()
{
Id = o.Id,
DateTimeSubmitted = o.DateTimeSubmitted,
RequestHeading = o.RequestHeading,
RequestDescription = o.RequestDescription,
RequestorFirstName = o.RequestorFirstName,
RequestorLastName = o.RequestorLastName,
RequestorPhone = o.RequestorPhone,
RequestorEmail = o.RequestorEmail
});
DTResult <ServiceRequests> finalresult = new DTResult <ServiceRequests>
{
draw = param.Draw,
data = SRList.ToList(),
recordsFiltered = TotalCount,
recordsTotal = filtered.Count
};
return(Json(finalresult));
}
/// <summary>
/// Get all document category
/// </summary>
/// <returns></returns>
public virtual DTResult <DocumentCategoryViewModel> GetAllDocumentCategory(DTParameters param)
{
var filtered = DataFilter.FilterAbstractEntity <DocumentCategory, IDocumentContext>(_context, param.Search.Value,
param.SortOrder, param.Start,
param.Length,
out var totalCount).Select(x =>
{
var listModel = x.Adapt <DocumentCategoryViewModel>();
return(listModel);
}).ToList();
var result = new DTResult <DocumentCategoryViewModel>
{
Draw = param.Draw,
Data = filtered,
RecordsFiltered = totalCount,
RecordsTotal = filtered.Count
};
//var result = new ResultModel<IEnumerable<DocumentType>>();
//var listDocumentTypes = await _context.DocumentTypes.ToListAsync();
//if(listDocumentTypes is null || !listDocumentTypes.Any())
// new NotFoundResultModel<IEnumerable<DocumentType>>();
//result.IsSuccess = true;
//result.Result = listDocumentTypes;
return(result);
}
public async Task <IActionResult> DataHandler([FromBody] JObject json)
{
try
{
var a = Request;
var param = JsonConvert.DeserializeObject <DTParameters>(json.GetValue("param1").ToString());
var dictionary = new Dictionary <string, string>();
dictionary = JsonConvert.DeserializeObject <Dictionary <string, string> >(json.GetValue("data").ToString());
var search = dictionary["search"];
var query = repo.FindAll().Where(d => d.db.name.Contains(search));
var status_del = int.Parse(dictionary["status_del"]);
query = query.Where(d => d.db.status_del == status_del);
var count = query.Count();
var dataList = await Task.Run(() => query.Skip(param.Start).Take(param.Length)
.OrderByDescending(d => d.db.create_date).ToList());
DTResult <maintenance_system_device_detail_model> result = new DTResult <maintenance_system_device_detail_model>
{
start = param.Start,
draw = param.Draw,
data = dataList,
recordsFiltered = count,
recordsTotal = count
};
return(Json(result));
}
catch (Exception ex)
{
return(Json(new { error = ex.Message }));
}
}
public JsonResult DataHandler(DTParameters param)
{
try
{
var dtsource = new List<Customer>();
using (dataSetEntities dc = new dataSetEntities())
{
dtsource = dc.Customers.ToList();
}
List<String> columnSearch = new List<string>();
foreach (var col in param.Columns)
{
columnSearch.Add(col.Search.Value);
}
List<Customer> data = new ResultSet().GetResult(param.Search.Value, param.SortOrder, param.Start, param.Length, dtsource, columnSearch);
int count = new ResultSet().Count(param.Search.Value, dtsource, columnSearch);
DTResult<Customer> result = new DTResult<Customer>
{
draw = param.Draw,
data = data,
recordsFiltered = count,
recordsTotal = count
};
return Json(result);
}
catch (Exception ex)
{
return Json(new { error = ex.Message });
}
}
public JsonResult OrderList(DTParameters param, bool isStatic = false)
{
var filtered = Context.Filter <TableModel>(param.Search.Value, param.SortOrder, param.Start,
param.Length,
out var totalCount, x => x.IsPartOfDbContext.Equals(isStatic) && isStatic || x.EntityType == GearSettings.DEFAULT_ENTITY_SCHEMA && x.IsPartOfDbContext.Equals(isStatic));
var orderList = filtered.Select(o => new TableModel
{
Id = o.Id,
Name = o.Name,
IsDeleted = o.IsDeleted,
Author = o.Author,
Created = o.Created,
ModifiedBy = o.ModifiedBy,
Description = o.Description,
IsPartOfDbContext = o.IsPartOfDbContext,
EntityType = o.EntityType,
Changed = o.Changed,
IsSystem = o.IsSystem,
TableFields = o.TableFields
});
var finalResult = new DTResult <TableModel>
{
Draw = param.Draw,
Data = orderList.ToList(),
RecordsFiltered = totalCount,
RecordsTotal = filtered.Count
};
return(Json(finalResult));
}
public JsonResult LoadUploadsJS(DTParameters param)
{
try
{
var dtSource = ExtractViewModel.GetExtracts(_unitOfWork);
List <ExtractViewModel> data = new ResultSet_Extracts().GetResult(param.Search.Value, param.SortOrder, param.Start, param.Length, dtSource, null);
int count = new ResultSet_Extracts().Count(param.Search.Value, dtSource, null);
DTResult <ExtractViewModel> result = new DTResult <ExtractViewModel>
{
draw = param.Draw,
data = data,
recordsFiltered = count,
recordsTotal = count
};
return(Json(result));
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
return(Json(new { error = ex.Message }));
}
}
public JsonResult LoadUploadItemsJS(DTParameters param) //, int extractId) //, int auditId)
{
try
{
var dtSource = ExtractViewModel.GetExtractItems(_unitOfWork, param.PrimaryId);
//var dtsource = _unitOfWork.AuditExtracts.GetAll()
//.Select(s => new ManageStatusesViewModel { StatusId = s.StatusId, Name = s.Name, Description = s.Description, IncludeInAuditYN = s.IncludeInAuditYN }).ToList();
List <ExtractItemModel> data = new ResultSet_ExtractItems().GetResult(param.Search.Value, param.SortOrder, param.Start, param.Length, dtSource, null);
int count = new ResultSet_ExtractItems().Count(param.Search.Value, dtSource, null);
DTResult <ExtractItemModel> result = new DTResult <ExtractItemModel>
{
draw = param.Draw,
data = data,
recordsFiltered = count,
recordsTotal = count
};
return(Json(result));
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
return(Json(new { error = ex.Message }));
}
}
public JsonResult ProcessDiagramsList(DTParameters param)
{
var filtered = GetProcessDiagramsFiltered(param.Search.Value, param.SortOrder, param.Start, param.Length,
out var totalCount);
var orderList = filtered.Select(o => new ProcessesListViewModel
{
Id = o.Id,
Title = o.Title,
Synchronized = o.Synchronized,
IsDeleted = o.IsDeleted,
//AuthorName = _applicationDbContext.Users.Find(o.Author).Name,
CreatedString = o.Created.ToShortDateString(),
ChangedString = o.Changed.ToShortDateString(),
//ModifiedBy = _applicationDbContext.Users.Find(o.ModifiedBy).Name,
});
var finalResult = new DTResult <ProcessesListViewModel>
{
Draw = param.Draw,
Data = orderList.ToList(),
RecordsFiltered = totalCount,
RecordsTotal = filtered.Count
};
return(Json(finalResult));
}
public JsonResult DataHandler(DTParameters param)
{
try
{
var dtsource = new List <Customer>();
using (dataSetEntities dc = new dataSetEntities())
{
dtsource = dc.Customers.ToList();
}
List <String> columnSearch = new List <string>();
foreach (var col in param.Columns)
{
columnSearch.Add(col.Search.Value);
}
List <Customer> data = new ResultSet().GetResult(param.Search.Value, param.SortOrder, param.Start, param.Length, dtsource, columnSearch);
int count = new ResultSet().Count(param.Search.Value, dtsource, columnSearch);
DTResult <Customer> result = new DTResult <Customer>
{
draw = param.Draw,
data = data,
recordsFiltered = count,
recordsTotal = count
};
return(Json(result));
}
catch (Exception ex)
{
return(Json(new { error = ex.Message }));
}
}
/// <summary>
/// Get all document from table model
/// </summary>
/// <returns></returns>
public virtual DTResult <DocumentViewModel> GetAllDocument(DTParameters param)
{
var filtered = DataFilter.FilterAbstractEntity <Document, IDocumentContext>(_documentContext, param.Search.Value,
param.SortOrder,
param.Start,
param.Length,
out var totalCount).Select(x =>
{
x.DocumentVersions = _documentContext.DocumentVersions.Where(i => i.DocumentId == x.Id).ToList();
x.DocumentType = _documentContext.DocumentTypes.FirstOrDefault(i => x.DocumentTypeId == i.Id) ?? new DocumentType();
x.DocumentCategory = _documentContext.DocumentCategories.FirstOrDefault(i => i.Id == x.DocumentCategoryId);
var listModel = x.Adapt <DocumentViewModel>();
return(listModel);
}).Where(x => !x.IsDeleted && x.DocumentCategory?.Code == 1).ToList();
var result = new DTResult <DocumentViewModel>
{
Draw = param.Draw,
Data = filtered,
RecordsFiltered = totalCount,
RecordsTotal = filtered.Count
};
return(result);
}
public JsonResult PermissionList(int?id, DTParameters param)
{
var filtered = GetPermissionsFiltered(id, param.Search.Value, param.SortOrder, param.Start, param.Length,
out var totalCount);
var permissionList = filtered.Select(x => new PermissionListItemViewModel
{
Id = x.Id,
ClientName = _configurationDbContext.Clients.AsNoTracking()
.SingleOrDefaultAsync(z => z.Id.Equals(x.ClientId)).Result.ClientName,
PermissionDescription = x.Description,
PermissionKey = x.PermissionKey,
PermissionName = x.PermissionName
});
var finalResult = new DTResult <PermissionListItemViewModel>
{
Draw = param.Draw,
Data = permissionList.ToList(),
RecordsFiltered = totalCount,
RecordsTotal = filtered.Count
};
return(Json(finalResult));
}
/// <summary>
/// Get users with pagination
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public virtual async Task <DTResult <UserListItemViewModel> > GetAllUsersWithPaginationAsync(DTParameters parameters)
{
var filtered = await IdentityContext.Users.GetPagedAsDtResultAsync(parameters);
var usersList = filtered.Data.Select(async o =>
{
var sessions = _hub.GetSessionsCountByUserId(o.Id);
var roles = await UserManager.GetRolesAsync(o);
var org = await IdentityContext.Tenants.FirstOrDefaultAsync(x => x.Id == o.TenantId);
return(new UserListItemViewModel
{
Id = o.Id,
UserName = o.UserName,
CreatedDate = o.Created.ToShortDateString(),
CreatedBy = o.Author,
ModifiedBy = o.ModifiedBy,
Changed = o.Changed.ToShortDateString(),
Roles = roles,
Sessions = sessions,
AuthenticationType = o.AuthenticationType.ToString(),
LastLogin = o.LastLogin,
Organization = org?.Name
});
}).Select(x => x.Result);
var finalResult = new DTResult <UserListItemViewModel>
{
Draw = filtered.Draw,
Data = usersList.ToList(),
RecordsFiltered = filtered.RecordsFiltered,
RecordsTotal = filtered.RecordsTotal
};
return(finalResult);
}
public JsonResult GetEmployee(DTParameters param)
{
EmployeeViewStore employee = new EmployeeViewStore();
employee.PageIndex = param.Start / param.Length + 1;
employee.PageSize = param.Length;
if (param.Search.Value == null)
{
employee.Search = "%%";
}
else
{
employee.Search = "%" + param.Search.Value + "%";
}
employee.Order = param.SortOrder;
EmployeeViewStore categories = new EmployeeModels().GetEmployeeByPage(employee.Search, employee.Order, employee.PageIndex, employee.PageSize);
DTResult <EmployeeDTO> final = new DTResult <EmployeeDTO>()
{
draw = param.Draw,
data = categories.Employee.ToList(),
recordsFiltered = categories.RecordCount,
recordsTotal = categories.Employee.Count
};
return(Json(final));
}
public JsonResult GetShipper(DTParameters param)
{
ShipperViewStore shipper = new ShipperViewStore();
shipper.PageIndex = param.Start / param.Length + 1;
shipper.PageSize = param.Length;
if (param.Search.Value == null)
{
shipper.Search = "%%";
}
else
{
shipper.Search = "%" + param.Search.Value + "%";
}
shipper.Order = param.SortOrder;
ShipperViewStore categories = new ShipperModels().GetShipperByPage(shipper.Search, shipper.Order, shipper.PageIndex, shipper.PageSize);
DTResult <ShipperDTO> final = new DTResult <ShipperDTO>()
{
draw = param.Draw,
data = categories.Shippers.ToList(),
recordsFiltered = categories.RecordCount,
recordsTotal = categories.Shippers.Count
};
return(Json(final));
}
public ActionResult PostData(DTParameters getParam)
{
int total = 0;
int page = (getParam.Start != 0) ? 1 : ((getParam.Start / getParam.Length) + 1); int vertion = GetVersion(); getParam.Search.Value += "^VertionDDL_Int&" + vertion.ToString();
List <Insurance> queryData = m_BLL.GetByParam(null, page, getParam.Length, getParam.DescOrAsc, getParam.SortOrder, getParam.Search.Value, ref total);
DTResult <Insurance> result = new DTResult <Insurance>
{
draw = getParam.Draw,
data = queryData.Select(s => new
{
Name = s.Name
,
CreateTime = s.CreateTime
,
Remark = s.Remark
,
Id = s.Id
}).ToList(),
recordsFiltered = total
};
return(Json(result));
}
/// <summary>
/// Load view models with pagination
/// </summary>
/// <param name="param"></param>
/// <param name="entityId"></param>
/// <returns></returns>
public DTResult <object> LoadViewModelsWithPagination(DTParameters param, Guid entityId)
{
var filtered = PagesContext.FilterAbstractContext <ViewModel>(param.Search.Value, param.SortOrder,
param.Start,
param.Length,
out var totalCount,
x => (entityId != Guid.Empty && x.TableModelId == entityId) || entityId == Guid.Empty);
var sel = filtered.Select(x => new
{
x.Author,
x.Changed,
x.Created,
x.Id,
x.IsDeleted,
x.ModifiedBy,
x.Name,
Table = PagesContext.Table.FirstOrDefault(y => y.Id.Equals(x.TableModelId))?.Name
}).Adapt <IEnumerable <object> >();
var finalResult = new DTResult <object>
{
Draw = param.Draw,
Data = sel.ToList(),
RecordsFiltered = totalCount,
RecordsTotal = filtered.Count()
};
return(finalResult);
}
public DTResult <DynamicReportViewModel> GetFilteredReports(DTParameters param)
{
var filtered = _context.Filter <DynamicReport>(param.Search.Value, param.SortOrder, param.Start,
param.Length,
out var totalCount).Select(x =>
{
x.DynamicReportFolder = _context.DynamicReportsFolders.FirstOrDefault(y => y.Id == x.DynamicReportFolderId);
return(x);
}).ToList();
var finalResult = new DTResult <DynamicReportViewModel>
{
Draw = param.Draw,
Data = filtered.Select(x => new DynamicReportViewModel
{
Id = x.Id,
Name = x.Name,
ReportDataModel = x.ReportDataModel,
DynamicReportFolder = new DynamicReportFolderViewModel(x.DynamicReportFolder.Id, x.DynamicReportFolder.Name),
Author = x.Author,
ModifiedBy = x.ModifiedBy,
Created = x.Created,
Changed = x.Changed,
IsDeleted = x.IsDeleted
}).ToList(),
RecordsFiltered = totalCount,
RecordsTotal = filtered.Count
};
return(finalResult);
}
public async Task <IActionResult> DataHandler([FromBody] JObject json)
{
try
{
var a = Request;
var param = JsonConvert.DeserializeObject <DTParameters>(json.GetValue("param1").ToString());
var dictionary = JsonConvert.DeserializeObject <Dictionary <string, dynamic> >(json.GetValue("data").ToString());
var Month = dictionary["month"];
DateTime date = DateTime.Now;
string search = dictionary["search"];
DateTime startDate = new DateTime(date.Year, (int)Month, 1);
DateTime endDate = startDate.AddMonths(1).AddDays(-1) + new TimeSpan(23, 59, 59);
var query = repo.FindAllItemIndex(startDate, endDate);
var dataList = await Task.Run(() => query.Skip(param.Start).Take(param.Length).ToList());
var count = dataList.Count();
DTResult <dynamic> result = new DTResult <dynamic>
{
start = param.Start,
draw = param.Draw,
data = dataList,
recordsFiltered = count,
recordsTotal = count
};
return(Json(result));
}
catch (Exception ex)
{
return(Json(new { error = ex.Message }));
}
}
public JsonResult GetTransactions(DTParameters param, int?organizationID, int?clientID)
{
List <Transactions> dtsource = new List <Transactions>();
dtsource = db.GetTransactions(Convert.ToInt32(Session["organizationID"]), clientID);
TempData["Transactionsdtsource"] = dtsource;
TempData["organizationID"] = Convert.ToInt32(Session["organizationID"]);
List <String> columnSearch = new List <string>();
foreach (var col in param.Columns)
{
columnSearch.Add(col.Search.Value);
}
if (param.Length == -1)
{
param.Length = dtsource.Count();
}
List <Transactions> data = new ResultSet().GetResult(param.Search.Value, param.SortOrder, param.Start, param.Length, dtsource, columnSearch);
int count = new ResultSet().Count(param.Search.Value, dtsource, columnSearch);
DTResult <Transactions> result = new DTResult <Transactions>
{
draw = param.Draw,
data = data,
recordsFiltered = count,
recordsTotal = count
};
return(Json(result));
}
public async Task <JsonResult> LoadPagedData(DTParameters param, Guid viewModelId, ICollection <Filter> filters)
{
var response = new DTResult <object>
{
Data = new List <object>(),
Draw = param.Draw
};
if (viewModelId == Guid.Empty)
{
return(Json(response));
}
var viewModel = await _pagesContext.ViewModels
.Include(x => x.TableModel)
.ThenInclude(x => x.TableFields)
.Include(x => x.ViewModelFields)
.ThenInclude(x => x.TableModelFields)
.Include(x => x.ViewModelFields)
.ThenInclude(x => x.Configurations)
.FirstOrDefaultAsync(x => x.Id.Equals(viewModelId));
if (viewModel == null)
{
return(Json(response));
}
var orderConf = new Dictionary <string, EntityOrderDirection>();
if (param.Order.Any())
{
foreach (var order in param.Order)
{
var field = viewModel.ViewModelFields.FirstOrDefault(x => x.Order == order.Column - 1);
if (field != null)
{
orderConf.Add(field.TableModelFields?.Name ?? field.Name, (EntityOrderDirection)order.Dir);
}
}
}
var page = param.Start / param.Length + 1;
var pageDataRequest = await _service.GetPaginatedResultAsync(viewModel.TableModel.Name, (uint)page,
(uint)param.Length, param.Search.Value, filters, orderConf);
if (pageDataRequest.IsSuccess)
{
var final = (await LoadManyToManyReferences(pageDataRequest.Result.ViewModel.Values.ToList(), viewModel)).ToList();
response.Data = final;
response.RecordsTotal = final.Count;
response.RecordsFiltered = (int)pageDataRequest.Result.Total;
}
var serializerSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
DateFormatString = GearSettings.Date.DateFormat
};
return(Json(response, serializerSettings));
}
public async Task <IActionResult> DataHandler([FromBody] JObject json)
{
try
{
var a = Request;
var param = JsonConvert.DeserializeObject <DTParameters>(json.GetValue("param1").ToString());
var dictionary = new Dictionary <string, string>();
dictionary = JsonConvert.DeserializeObject <Dictionary <string, string> >(json.GetValue("data").ToString());
var search = dictionary["search"];
var query = repo.FindAllItemIndex()
.Where(d => d.sys_item_name.Contains(search) ||
d.sys_item_specification_name.Contains(search) ||
d.business_sale_order_name.Contains(search) ||
d.sys_customer_name.Contains(search)
)
;
var dateNow = DateTime.Now;
int NumberRecordDelivery = repo._context.inventory_deliverys.Where(d => d.create_date.Date == dateNow.Date).Count();
string receiptCode = $"PXTP{dateNow.Month.ToString("D2")}{dateNow.ToString("yy")}/{NumberRecordDelivery.ToString("D3")}";
var id_customer = dictionary["id_customer"];
var status_export = int.Parse(dictionary["status_export"]);
if (id_customer != "-1")
{
query = query.Where(d => d.id_customer == id_customer);
}
query = query.Where(d => d.db.status_export == status_export);
query = query.Where(d => repo._context.sys_approvals.Where(t => t.id == d.id_approval)
.Select(d => d.status_finish).SingleOrDefault() == 3);
query = query.OrderByDescending(d => d.db.estimated_delivery_date);
var dataList = await Task.Run(() => query.Skip(param.Start).Take(param.Length).ToList());
var count = dataList.Count();
DTResult <business_delivery_schedule_model> result = new DTResult <business_delivery_schedule_model>
{
receiptCode = receiptCode,
start = param.Start,
draw = param.Draw,
data = dataList,
recordsFiltered = count,
recordsTotal = count
};
return(Json(result));
}
catch (Exception ex)
{
return(Json(new { error = ex.Message }));
}
}
public ActionResult PaymentHistData(DTParameters param)
{
if (Request.IsAuthenticated)
{
try
{
string user_id = User.Identity.GetUserId();
var dtsource = new List <TransactionHistory>();//data source for payment history
using (BOSEMEntities dc = new BOSEMEntities())
{
if (isAdminUser())
{
dtsource = db.Database.SqlQuery <TransactionHistory>("select * from TransactionHistory where txn_id in (" +
"select distinct txn_id from requested_mark where txn_id is not NULL" +
") order by create_at desc").OrderByDescending(m => m.create_at).ToList();
}
else
{
dtsource = db.Database.SqlQuery <TransactionHistory>("select * from TransactionHistory where txn_id in (" +
"select distinct txn_id from requested_mark where txn_id is not NULL and user_id = '" + user_id + "'" +
") order by create_at desc").OrderByDescending(m => m.create_at).ToList();
}
}
List <String> columnSearch = new List <string>();
foreach (var col in param.Columns)
{
columnSearch.Add(col.Search.Value);
}
List <TransactionHistory> data = new ResultSet().GetTxnResult(param.Search.Value, param.SortOrder, param.Start, param.Length, dtsource, columnSearch);
List <TxnHistViewModel> new_data = new List <TxnHistViewModel>();
foreach (TransactionHistory row in data)
{
new_data.Add(new TxnHistViewModel(row));
}
int count = new ResultSet().TxnCount(param.Search.Value, dtsource, columnSearch);
DTResult <TxnHistViewModel> result = new DTResult <TxnHistViewModel>
{
draw = param.Draw,
data = new_data,
recordsFiltered = count,
recordsTotal = count
};
return(Json(result));
}
catch (Exception ex)
{
return(Json(new { error = ex.Message }));
}
}
else
{
return(RedirectToAction("Login", "Account"));
}
}
public async Task <JsonResult> DataHandler([FromBody] JObject json)
{
try
{
var a = Request;
var UserId = getUserId();
var param = JsonConvert.DeserializeObject <DTParameters>(json.GetValue("param1").ToString());
var dictionary = new Dictionary <string, string>();
dictionary = JsonConvert.DeserializeObject <Dictionary <string, string> >(json.GetValue("data").ToString());
var search = ((dictionary["search"]) ?? "").ToLower();
var id_customer = dictionary["id_customer"];
var id_business_sale_order = dictionary["id_business_sale_order"];
var status_bom = int.Parse(dictionary["status_bom"]);
var query = repo.FindAll()
.Where(d => d.db.status_bom == status_bom || status_bom == -1)
.Where(d => d.production_order_name.Contains(search) || d.sys_item_name.Contains(search) ||
d.sys_item_specification_name.Contains(search) ||
(d.db.note ?? "").ToLower().Contains(search))
;
///->check trang thai duyet
if (id_customer != "-1")
{
query = query.Where(d => d.id_customer == id_customer);
}
if (id_business_sale_order != "-1")
{
query = query.Where(d => d.id_business_sale_order == id_business_sale_order);
}
var count = query.Count();
var dataList = await Task.Run(() => query.OrderByDescending(d => d.db.id).Skip(param.Start).Take(param.Length)
.ToList());
DTResult <production_order_need_supplier_master_model> result = new DTResult <production_order_need_supplier_master_model>
{
start = param.Start,
draw = param.Draw,
data = dataList,
recordsFiltered = count,
recordsTotal = count
};
return(Json(result));
}
catch (Exception ex)
{
return(Json(new { error = ex.Message }));
}
}
public JsonResult ClientDataHandler(DTParameters param)
{
try
{
var ispUser = svc.GetISPUser(User.Identity.GetUserId());
//if ISP user id allowed to see the leads
if (ispUser.ISP != null && ispUser.ISP.AllowViewLeads)
{
var rnd = new Random(ispUser.ISPId ?? 0); //ispId will never be null
var dtsource = svc.GetUserDtos(u =>
!u.IsDeleted &&
(u.Zone != null && u.Zone.AllowLeads) &&
u.ISPCommsOptOutStatus == false &&
u.ISPClientContacts.All(c => c.ISPId != ispUser.ISPId) &&
!u.Orders.Any() &&
u.ClientISPContacts.Any(c => c.ISPId == ispUser.ISPId) &&
u.Location.ISPLocationProducts.Any(il => il.ISPId == ispUser.ISPId) &&
(u.Estate == null || u.Estate != null && u.Estate.ISPEstateProducts.Any(ie => ie.ISPId == ispUser.ISPId)))
.ToList().Shuffle(rnd).ToList();
List <string> columnSearch = new List <string>();
foreach (var col in param.Columns)
{
columnSearch.Add(col.Search.Value);
}
List <UserDto> data = new ResultSet().GetResult <IEnumerable <UserDto> >(
param.Search.Value,
param.SortOrder,
param.Start,
param.Length,
dtsource,
columnSearch,
UserFilterType.UserLeads).ToList();
int count = new ResultSet().Count(param.Search.Value, dtsource, columnSearch, UserFilterType.UserLeads);
DTResult <UserDto> result = new DTResult <UserDto>
{
draw = param.Draw,
data = data,
recordsFiltered = count,
recordsTotal = count
};
return(Json(result, JsonRequestBehavior.AllowGet));
}
return(Json(new {}));
}
catch (Exception ex)
{
return(Json(new { error = ex.Message }));
}
}
protected DTResult <T> GetListResult <T>(DTParameters param, ListResult <T> listResult)
{
DTResult <T> result = new DTResult <T>
{
draw = param.Draw,
data = listResult.ResultData,
recordsFiltered = listResult.TotalRecords,
recordsTotal = listResult.TotalRecords,
};
return(result);
}
public JsonResult GetDataTable(DTParameters param)
{
try
{
var columnSearch = param.Columns.Select(col => col.Search.Value).ToList();
var data = _electionService.GetElectionsTable(param.Search.Value, param.SortOrder, param.Start,
param.Length, columnSearch);
var count = _electionService.Count(param.Search.Value, columnSearch);
var result = new DTResult<Election>
{
draw = param.Draw,
data = data,
recordsFiltered = count,
recordsTotal = count
};
return Json(result);
}
catch (Exception ex)
{
return Json(new {error = ex.Message});
}
}
public JsonResult LoadUploadItemsJS(DTParameters param)
{
try
{
var dtSource = ExtractViewModel.GetExtractItems(_unitOfWork, param.PrimaryId);
//var dtsource = _unitOfWork.AuditExtracts.GetAll()
//.Select(s => new ManageStatusesViewModel { StatusId = s.StatusId, Name = s.Name, Description = s.Description, IncludeInAuditYN = s.IncludeInAuditYN }).ToList();
List<ExtractItemModel> data = new ResultSet_ExtractItems().GetResult(param.Search.Value, param.SortOrder, param.Start, param.Length, dtSource, null);
int count = new ResultSet_ExtractItems().Count(param.Search.Value, dtSource, null);
DTResult<ExtractItemModel> result = new DTResult<ExtractItemModel>
{
draw = param.Draw,
data = data,
recordsFiltered = count,
recordsTotal = count
};
return Json(result);
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
return Json(new { error = ex.Message });
}
}
public JsonResult LoadUploadsJS(DTParameters param)
{
try
{
var dtSource = ExtractViewModel.GetExtracts(_unitOfWork);
List<ExtractViewModel> data = new ResultSet_Extracts().GetResult(param.Search.Value, param.SortOrder, param.Start, param.Length, dtSource, null);
int count = new ResultSet_Extracts().Count(param.Search.Value, dtSource, null);
DTResult<ExtractViewModel> result = new DTResult<ExtractViewModel>
{
draw = param.Draw,
data = data,
recordsFiltered = count,
recordsTotal = count
};
return Json(result);
}
catch (Exception ex)
{
ErrorTools.HandleError(ex, ErrorLevel.NonFatal); //just log, no redirect
return Json(new { error = ex.Message });
}
}
