public GridResponseModel<SupplierModel> Get(GridRequestModel gridRequestModel, SupplierModel searchModel)
{
var query = _unitOfWork.SupplierRepository.Queryable;
var dbModel = query.ToPagingResult(gridRequestModel);
var model = dbModel.Rows.Select(m => Mapper.Map<SupplierModel>(m)).ToArray();
var gridData = new GridResponseModel<SupplierModel>(gridRequestModel, dbModel.RowCount, model);
return gridData;
}
public GridResponseModel <UserViewModel> GridView(GridRequestModel request)
{
GridResponseModel <UserViewModel> gridData = new GridResponseModel <UserViewModel>();
var user = GetUserFromToken();
gridData.Count = _repository.GetAllActive().Count();
IQueryable <User> query = null;
if (user.Role.Name == "SuperAdmin")
{
gridData.Count = _repository.GetAllActive().Count();
query = _repository.GetAllActive().Include(x => x.Role).Include(x => x.Company);
}
else
{
gridData.Count = _repository.GetAllActive(user.CompanyId).Count();
query = _repository.GetAllActive(user.CompanyId).Include(x => x.Role).Include(x => x.Company);
}
if (!string.IsNullOrEmpty(request.Keyword))
{
query = query.Where(x => x.Name.Contains(request.Keyword) || x.Name.Contains(request.Keyword));
}
if (request.IsAscending)
{
switch (request.OrderBy)
{
case "Name": query = query.OrderBy(l => l.Name); break;
default: query = query.OrderBy(l => l.Created); break;
}
}
else
{
switch (request.OrderBy)
{
case "Name": query = query.OrderByDescending(l => l.Name); break;
default: query = query.OrderByDescending(l => l.Created); break;
}
}
query = query.Skip(((request.Page - 1) * request.PerPageCount)).Take(request.PerPageCount);
List <User> users = query.ToList();
foreach (var usr in users)
{
gridData.Data.Add(new UserViewModel(usr));
}
return(gridData);
}
public GridResponseModel <SaleViewModel> GetGridData(GridRequestModel request, DateTime startDate, DateTime endDate)
{
GridResponseModel <SaleViewModel> gridData = new GridResponseModel <SaleViewModel>();
endDate = endDate.AddDays(1);
gridData.Count = _repository.GetAllActive(getCreatedCompanyId())
.Where(x => x.Created >= startDate && x.Created <= endDate).Count();
var query = _repository.GetAllActive(getCreatedCompanyId())
.Where(x => x.Created >= startDate && x.Created <= endDate)
.Include(x => x.SalesDetails)
.Include(x => x.SalesDetails.Select(y => y.Product))
.Include(x => x.SalesDetails.Select(y => y.Product.Group))
.Include(x => x.SalesDetails.Select(y => y.Product.Brand))
.Include(x => x.Customer);
if (!string.IsNullOrEmpty(request.Keyword))
{
query = query.Where(x => x.InvoiceNo.Contains(request.Keyword));
}
if (request.IsAscending)
{
switch (request.OrderBy)
{
case "Name": query = query.OrderBy(l => l.InvoiceNo); break;
default: query = query.OrderBy(l => l.Created); break;
}
}
else
{
switch (request.OrderBy)
{
case "Name": query = query.OrderByDescending(l => l.InvoiceNo); break;
default: query = query.OrderByDescending(l => l.Created); break;
}
}
query = query.Skip(((request.Page - 1) * request.PerPageCount)).Take(request.PerPageCount);
List <Sale> sales = query.ToList();
foreach (var sale in sales)
{
gridData.Data.Add(new SaleViewModel(sale));
}
return(gridData);
}
public async Task <GridResponseModel> SearchLogs(GridSearchModel searchModel)
{
GridResponseModel result = new GridResponseModel();
IQueryable <UserLogs> userLogs = _context.UserLogs.OrderByDescending(x => x.Id).AsQueryable();
string searchToLower = searchModel.Search.ToLower();
if (searchModel.StartDate.HasValue && searchModel.EndDate.HasValue)
{
if (searchModel.StartDate > searchModel.EndDate)
{
DateTime?temp = searchModel.StartDate;
searchModel.StartDate = searchModel.EndDate;
searchModel.EndDate = temp;
}
userLogs = userLogs.Where(
ul => ul.ServerTimeUtc.Date >= searchModel.StartDate &&
ul.ServerTimeUtc.Date <= searchModel.EndDate);
}
if (!String.IsNullOrEmpty(searchToLower))
{
userLogs = userLogs.Where(ul => ul.ActionName.ToLower().Contains(searchToLower) ||
ul.Controller.ToLower().Contains(searchToLower) ||
ul.Data.ToLower().Contains(searchToLower) ||
ul.Id.ToString().ToLower().Contains(searchToLower) ||
ul.Message.ToLower().Contains(searchToLower) ||
ul.RequestMethod.ToLower().Contains(searchToLower) ||
ul.Result.ToLower().Contains(searchToLower) ||
ul.UserId.ToLower().Contains(searchToLower) ||
ul.Ip.ToLower().Contains(searchToLower) ||
ul.Duration.ToString().ToLower().Contains(searchToLower) ||
ul.ResponseStatusCode.ToString().ToLower().Contains(searchToLower));
}
result.Total = userLogs.Count();
if (!String.IsNullOrEmpty(searchModel.SortBy))
{
userLogs = OrderByStringWithReflection.OrderBy(userLogs, searchModel.SortBy, searchModel.SortDesc);
}
userLogs = userLogs.Skip((searchModel.Page - 1) * searchModel.ItemsPerPage)
.Take(searchModel.ItemsPerPage);
result.Items = userLogs;
result.Page = searchModel.Page;
result.PageSize = searchModel.ItemsPerPage;
return(result);
}
public GridResponseModel <PurchaseViewModel> GetPurchaseReportGridData(GridRequestModel request, DateTime startDate, DateTime endDate)
{
GridResponseModel <PurchaseViewModel> gridData = new GridResponseModel <PurchaseViewModel>();
gridData.Count = _repository.GetAllActive(getCreatedCompanyId()).Count(x => x.Created >= startDate && x.Created <= endDate);
gridData.Value = _repository.GetAllActive(getCreatedCompanyId())
.Where(x => x.Created >= startDate && x.Created <= endDate).Sum(x => (decimal?)x.Amount) ?? 0;
var query = _repository.GetAllActive(getCreatedCompanyId())
.Where(x => x.Created >= startDate && x.Created <= endDate)
.Include(x => x.PurchaseDetails)
.Include(x => x.PurchaseDetails.Select(y => y.Product))
.Include(x => x.PurchaseDetails.Select(y => y.Product.Group))
.Include(x => x.PurchaseDetails.Select(y => y.Product.Brand));
if (!string.IsNullOrEmpty(request.Keyword))
{
query = query.Where(x => x.InvoiceNo.Contains(request.Keyword));
}
if (request.IsAscending)
{
switch (request.OrderBy)
{
case "Name": query = query.OrderBy(l => l.InvoiceNo); break;
default: query = query.OrderBy(l => l.Created); break;
}
}
else
{
switch (request.OrderBy)
{
case "Name": query = query.OrderByDescending(l => l.InvoiceNo); break;
default: query = query.OrderByDescending(l => l.Created); break;
}
}
query = query.Skip(((request.Page - 1) * request.PerPageCount)).Take(request.PerPageCount);
List <Purchase> purchases = query.ToList();
foreach (var purchase in purchases)
{
gridData.Data.Add(new PurchaseViewModel(purchase));
}
return(gridData);
}
public GridResponseModel <BrandViewModel> GetGridData(GridRequestModel request)
{
GridResponseModel <BrandViewModel> gridData = new GridResponseModel <BrandViewModel>();
gridData.Count = _repository.GetAllActive(getCreatedCompanyId()).Count();
var query = _repository.GetAllActive(getCreatedCompanyId());
if (!string.IsNullOrEmpty(request.Keyword))
{
query = query.Where(x => x.Name.Contains(request.Keyword));
}
if (request.IsAscending)
{
switch (request.OrderBy)
{
case "Name": query = query.OrderBy(l => l.Name); break;
default: query = query.OrderBy(l => l.Created); break;
}
}
else
{
switch (request.OrderBy)
{
case "Name": query = query.OrderByDescending(l => l.Name); break;
default: query = query.OrderByDescending(l => l.Created); break;
}
}
query = query.Skip(((request.Page - 1) * request.PerPageCount)).Take(request.PerPageCount);
List <Brand> brands = query.ToList();
foreach (var brand in brands)
{
gridData.Data.Add(new BrandViewModel(brand));
}
return(gridData);
}
public GridResponseModel <RoleViewModel> RoleGridView(GridRequestModel request)
{
GridResponseModel <RoleViewModel> gridData = new GridResponseModel <RoleViewModel>();
gridData.Count = _repository.GetAllActive().Count();
var query = _repository.GetAllActive().Include(x => x.PermissionMaps.Select(y => y.Permission));
if (!string.IsNullOrEmpty(request.Keyword))
{
query = query.Where(x => x.Name.Contains(request.Keyword) || x.Name.Contains(request.Keyword));
}
if (request.IsAscending)
{
switch (request.OrderBy)
{
case "Name": query = query.OrderBy(l => l.Name); break;
default: query = query.OrderBy(l => l.Created); break;
}
}
else
{
switch (request.OrderBy)
{
case "Name": query = query.OrderByDescending(l => l.Name); break;
default: query = query.OrderByDescending(l => l.Created); break;
}
}
query = query.Skip(((request.Page - 1) * request.PerPageCount)).Take(request.PerPageCount);
List <Role> roles = query.ToList();
foreach (var role in roles)
{
gridData.Data.Add(new RoleViewModel(role));
}
return(gridData);
}
public GridResponseModel <PermissionViewModel> PermissionGridView(GridRequestModel request)
{
GridResponseModel <PermissionViewModel> gridData = new GridResponseModel <PermissionViewModel>();
gridData.Count = _repository.GetAllActive().Count();
var query = _repository.GetAllActive();
if (!string.IsNullOrEmpty(request.Keyword))
{
query = query.Where(x => x.Resource.Contains(request.Keyword) || x.Resource.Contains(request.Keyword));
}
if (request.IsAscending)
{
switch (request.OrderBy)
{
case "Name": query = query.OrderBy(l => l.Resource); break;
default: query = query.OrderBy(l => l.Created); break;
}
}
else
{
switch (request.OrderBy)
{
case "Name": query = query.OrderByDescending(l => l.Resource); break;
default: query = query.OrderByDescending(l => l.Created); break;
}
}
query = query.Skip(((request.Page - 1) * request.PerPageCount)).Take(request.PerPageCount);
List <Permission> permissions = query.ToList();
foreach (var permission in permissions)
{
gridData.Data.Add(new PermissionViewModel(permission));
}
return(gridData);
}
public GridResponseModel <JournalTypeViewModel> GetJournalTypeGridData(GridRequestModel request)
{
GridResponseModel <JournalTypeViewModel> gridData = new GridResponseModel <JournalTypeViewModel>();
gridData.Count = _journalTypeRepository.GetAllActive(getCreatedCompanyId()).Count();
var query = _journalTypeRepository.GetAllActive(getCreatedCompanyId());
query = query.OrderByDescending(l => l.Created);
query = query.Skip(((request.Page - 1) * request.PerPageCount)).Take(request.PerPageCount);
List <JournalType> journalTypes = query.ToList();
foreach (var journalTpe in journalTypes)
{
gridData.Data.Add(new JournalTypeViewModel(journalTpe));
}
return(gridData);
}
public GridResponseModel <JournalViewModel> GetGridData(GridRequestModel request, DateTime startDate, DateTime endDate)
{
GridResponseModel <JournalViewModel> gridData = new GridResponseModel <JournalViewModel>();
endDate = endDate.AddDays(1);
gridData.Count = _repository.GetAllActive(getCreatedCompanyId()).Where(x => x.Status == JournalStatus.paid).Where(x => x.Created >= startDate && x.Created <= endDate).Count();
var totalValue = _repository.GetAllActive(getCreatedCompanyId()).Where(x => x.Status == JournalStatus.paid).Where(x => x.Created >= startDate && x.Created <= endDate).Sum(x => x.Amount);
gridData.Value = totalValue;
var query = _repository.GetAllActive(getCreatedCompanyId());
if (request.IsAscending)
{
switch (request.OrderBy)
{
case "Status": query = query.OrderBy(l => l.Status); break;
default: query = query.OrderBy(l => l.Created); break;
}
}
else
{
switch (request.OrderBy)
{
case "Status": query = query.OrderByDescending(l => l.Status); break;
default: query = query.OrderByDescending(l => l.Created); break;
}
}
query = query.Where(x => x.Status == JournalStatus.paid).Where(x => x.Created >= startDate && x.Created <= endDate).Include(x => x.JournalType).Include(x => x.SubmittedBy).Skip(((request.Page - 1) * request.PerPageCount)).Take(request.PerPageCount);
List <Journal> journals = query.ToList();
foreach (var journal in journals)
{
gridData.Data.Add(new JournalViewModel(journal));
}
return(gridData);
}
public GridResponseModel <JournalViewModel> GetGridDataByUser(GridRequestModel request)
{
GridResponseModel <JournalViewModel> gridData = new GridResponseModel <JournalViewModel>();
var user = this.GetUserFromToken();
gridData.Count = _repository.GetAllActive(getCreatedCompanyId()).Where(x => x.CreatedBy == user.UserId).Count();
var query = _repository.GetAllActive(getCreatedCompanyId()).Where(x => x.CreatedBy == user.UserId);
if (request.IsAscending)
{
switch (request.OrderBy)
{
case "Status": query = query.OrderBy(l => l.Status); break;
default: query = query.OrderBy(l => l.Created); break;
}
}
else
{
switch (request.OrderBy)
{
case "Status": query = query.OrderByDescending(l => l.Status); break;
default: query = query.OrderByDescending(l => l.Created); break;
}
}
query = query.Include(x => x.JournalType).Include(x => x.SubmittedBy).Skip(((request.Page - 1) * request.PerPageCount)).Take(request.PerPageCount);
List <Journal> journals = query.ToList();
foreach (var journal in journals)
{
gridData.Data.Add(new JournalViewModel(journal));
}
return(gridData);
}
public GridResponseModel <ProductViewModel> GetGridData(GridRequestModel request)
{
var firstCharOfKey = " ";
if (request.Keyword != null && request.Keyword != "")
{
firstCharOfKey = request.Keyword[0].ToString();
}
GridResponseModel <ProductViewModel> gridData = new GridResponseModel <ProductViewModel>();
List <Product> products = new List <Product>();
gridData.Count = _repository.GetAllActive(getCreatedCompanyId()).Count();
var query = _repository.GetAllActive(getCreatedCompanyId()).Include(x => x.Group).Include(x => x.Brand);
if (firstCharOfKey.All(char.IsDigit))
{
if (request.Keyword.Length > 9)
{
products = _repository.GetAllActive(getCreatedCompanyId())
.Where(x => x.VendorBarcodeNo.Equals(request.Keyword)).Include(x => x.Group).Include(x => x.Brand).OrderBy(l => l.Name).Skip(((request.Page - 1) * request.PerPageCount)).Take(request.PerPageCount).ToList();
}
else
{
products = _repository.GetAllActive(getCreatedCompanyId())
.Where(x => x.BarCodeNo.Equals(request.Keyword)).Include(x => x.Group).Include(x => x.Brand).OrderBy(l => l.Name).Skip(((request.Page - 1) * request.PerPageCount)).Take(request.PerPageCount).ToList();
}
}
else
{
if (!string.IsNullOrEmpty(request.Keyword))
{
query = query.Where(x => x.Name.Contains(request.Keyword));
}
if (request.IsAscending)
{
switch (request.OrderBy)
{
case "Name": query = query.OrderBy(l => l.Name); break;
default: query = query.OrderBy(l => l.Created); break;
}
}
else
{
switch (request.OrderBy)
{
case "Name": query = query.OrderByDescending(l => l.Name); break;
default: query = query.OrderByDescending(l => l.Created); break;
}
}
query = query.Skip(((request.Page - 1) * request.PerPageCount)).Take(request.PerPageCount);
products = query.ToList();
}
foreach (var product in products)
{
gridData.Data.Add(new ProductViewModel(product));
}
return(gridData);
}
public GridResponseModel<ProductModel> Get(GridRequestModel gridRequestModel, ProductModel searchModel)
{
var query = _unitOfWork.ProductRepository.Queryable;
if (searchModel != null)
{
if (searchModel.ProductTypeId > 0)
query = query.Where(p => p.ProductType.Id == searchModel.ProductTypeId);
if (searchModel.SupplierId > 0)
query = query.Where(p => p.Supplier != null && p.Supplier.Id == searchModel.SupplierId);
if (!string.IsNullOrWhiteSpace(searchModel.Name))
query = query.Where(p => p.Name.Contains(searchModel.Name));
}
switch (gridRequestModel.Sidx)
{
default:
case "Name":
query = query.OrderBy(p => p.Name, gridRequestModel.IsSortAsending);
break;
}
var dbModel = query.ToPagingResult(gridRequestModel);
var model = dbModel.Rows.Select(m => Mapper.Map<ProductModel>(m)).ToArray();
var gridData = new GridResponseModel<ProductModel>(gridRequestModel, dbModel.RowCount, model);
return gridData;
}
