private ApiResponse <PagedListResponse <ParameterViewModel> > Search(SearchParameterViewModel model)
{
var apiResp = new ApiResponse <PagedListResponse <ParameterViewModel> >
{
Type = ResponseType.Fail,
Data = new PagedListResponse <ParameterViewModel>()
};
var request = new FilteredPagedListRequest <SearchParameterCriteria>
{
FilterCriteria = new SearchParameterCriteria
{
UserId = GetUserId().Value,
Name = model.Name
},
IncludeRecordsTotal = model.IncludeRecordsTotal,
Limit = model.Limit,
Offset = model.Offset
};
var resp = _parameterBusiness.Search(request);
apiResp.Data.Items = resp.Items.Select(p => new ParameterViewModel
{
Id = p.Id,
ParameterTypeId = p.ParameterTypeId,
Order = p.Order,
Name = p.Name
});
apiResp.Data.RecordsTotal = resp.RecordsTotal;
apiResp.Type = ResponseType.Success;
return(apiResp);
}
public PagedListResponse <Entities.Parameter> Search(FilteredPagedListRequest <SearchParameterCriteria> request)
{
var result = new PagedListResponse <Entities.Parameter>();
var query = Entities.Where(p => p.IsDeleted == false);
if (!request.FilterCriteria.IncludeSystemParameters)
{
query = query.Where(p => p.IsSystem == false);
}
if (!string.IsNullOrEmpty(request.FilterCriteria.Name))
{
var nameLikeText = $"%{request.FilterCriteria.Name}%";
query = query.Where(p => EF.Functions.ILike(p.Value, nameLikeText));
}
if (request.IncludeRecordsTotal)
{
result.RecordsTotal = query.Count();
}
result.Items = query
.OrderBy(p => p.Order)
.ThenBy(p => p.Value)
.Skip(request.Offset)
.Take(request.Limit)
.ToList();
return(result);
}
private ApiResponse <PagedListResponse <TransactionViewModel> > Search(SearchTransactionViewModel model)
{
var apiResp = new ApiResponse <PagedListResponse <TransactionViewModel> >
{
Type = ResponseType.Fail,
Data = new PagedListResponse <TransactionViewModel>()
};
var request = new FilteredPagedListRequest <SearchTransactionCriteria>
{
FilterCriteria = new SearchTransactionCriteria
{
UserId = GetUserId().Value,
CustomerId = model.CustomerId,
TypeId = model.TypeId,
IsDebt = model.IsDebt,
SortType = model.GetSortType()
},
IncludeRecordsTotal = model.IncludeRecordsTotal,
Limit = model.Limit,
Offset = model.Offset
};
_transactionBusiness.OwnerId = GetUserId().Value;
var resp = _transactionBusiness.Search(request);
apiResp.Data.Items = resp.Items.Select(p => new TransactionViewModel
{
Id = p.Id,
Customer = new CustomerViewModel
{
Id = p.Customer.Id,
Title = p.Customer.Title,
AuthorizedPersonName = p.Customer.AuthorizedPersonName
},
Type = new ParameterViewModel
{
Id = p.Type.Id,
ParameterTypeId = p.Type.ParameterTypeId,
Name = p.Type.Name
},
Amount = p.Amount,
Description = p.Description,
AttachmentName = p.AttachmentName,
IsDebt = p.IsDebt,
CreatedAt = p.CreatedAt,
ModifiedAt = p.ModifiedAt,
Date = p.Date
});;
apiResp.Data.RecordsTotal = resp.RecordsTotal;
apiResp.Type = ResponseType.Success;
return(apiResp);
}
public PagedListResponse <Dto.Customer> Search(FilteredPagedListRequest <SearchCustomerCriteria> request)
{
var resp = Repository.Search(request);
var customers = Mapper.Map <IEnumerable <Dal.Entities.Customer>, IEnumerable <Dto.Customer> >(resp.Items);
return(new PagedListResponse <Dto.Customer>
{
Items = customers,
RecordsTotal = resp.RecordsTotal
});
}
public PagedListResponse <Dto.Transaction> Search(FilteredPagedListRequest <SearchTransactionCriteria> request)
{
var resp = Repository.Search(request);
var transactions = Mapper.Map <IEnumerable <Dal.Entities.Transaction>, IEnumerable <Dto.Transaction> >(resp.Items);
SetTransactionTypes(transactions);
return(new PagedListResponse <Dto.Transaction>
{
Items = transactions,
RecordsTotal = resp.RecordsTotal
});
}
public PagedListResponse <Entities.Customer> Search(FilteredPagedListRequest <SearchCustomerCriteria> request)
{
var result = new PagedListResponse <Entities.Customer>();
var query = Entities.Where(p => p.UserId == request.FilterCriteria.UserId);
if (!string.IsNullOrEmpty(request.FilterCriteria.Title))
{
var titleLikeText = $"%{request.FilterCriteria.Title}%";
query = query.Where(p => EF.Functions.ILike(p.Title, titleLikeText));
}
if (!string.IsNullOrEmpty(request.FilterCriteria.AuthorizedPersonName))
{
var personLikeText = $"{request.FilterCriteria.AuthorizedPersonName}%";
query = query.Where(p => EF.Functions.ILike(p.AuthorizedPersonName, personLikeText));
}
if (request.IncludeRecordsTotal)
{
result.RecordsTotal = query.Count();
}
switch (request.FilterCriteria.SortType)
{
case SortType.Ascending:
query = query
.OrderBy(p => p.Title);
break;
case SortType.Descending:
query = query
.OrderByDescending(p => p.Title);
break;
default:
query = query
.OrderByDescending(p => p.Id);
break;
}
result.Items = query
.Skip(request.Offset)
.Take(request.Limit)
.ToList();
return(result);
}
private ApiResponse <PagedListResponse <CustomerViewModel> > Search(SearchCustomerViewModel model)
{
var apiResp = new ApiResponse <PagedListResponse <CustomerViewModel> >
{
Type = ResponseType.Fail,
Data = new PagedListResponse <CustomerViewModel>()
};
var request = new FilteredPagedListRequest <SearchCustomerCriteria>
{
FilterCriteria = new SearchCustomerCriteria
{
AuthorizedPersonName = model.AuthorizedPersonName,
Title = model.Title,
UserId = GetUserId().Value,
SortType = model.GetSortType()
},
IncludeRecordsTotal = model.IncludeRecordsTotal,
Limit = model.Limit,
Offset = model.Offset
};
var resp = _customerBusiness.Search(request);
apiResp.Data.Items = resp.Items.Select(p => new CustomerViewModel
{
Id = p.Id,
Title = p.Title,
AuthorizedPersonName = p.AuthorizedPersonName,
CreatedAt = p.CreatedAt,
PhoneNumber = p.PhoneNumber,
DebtBalance = p.DebtBalance,
ReceivableBalance = p.ReceivableBalance
});
apiResp.Data.RecordsTotal = resp.RecordsTotal;
apiResp.Type = ResponseType.Success;
return(apiResp);
}
private ApiResponse <PagedListResponse <ParameterViewModel> > Search(SearchParameterViewModel model)
{
var apiResp = new ApiResponse <PagedListResponse <ParameterViewModel> >
{
Type = ResponseType.Fail,
Data = new PagedListResponse <ParameterViewModel>()
};
var request = new FilteredPagedListRequest <SearchParameterCriteria>
{
FilterCriteria = new SearchParameterCriteria
{
Name = model.Name,
IncludeSystemParameters = model.IncludeSystemParameters
},
IncludeRecordsTotal = model.IncludeRecordsTotal,
Limit = model.Limit,
Offset = model.Offset
};
var resp = _parameterService.Search(request);
apiResp.Data.Items = resp.Items.Select(p => new ParameterViewModel
{
Id = p.Id,
TypeId = p.TypeId,
Order = p.Order,
Value = p.Value,
Description = p.Description,
IsSystem = p.IsSystem
});
apiResp.Data.RecordsTotal = resp.RecordsTotal;
apiResp.Type = ResponseType.Success;
return(apiResp);
}
public PagedListResponse <Entities.Transaction> Search(FilteredPagedListRequest <SearchTransactionCriteria> request)
{
var result = new PagedListResponse <Entities.Transaction>();
var query = Entities.Where(p => p.Customer.UserId == request.FilterCriteria.UserId);
if (request.FilterCriteria.CustomerId.HasValue)
{
query = query.Where(p => p.CustomerId == request.FilterCriteria.CustomerId.Value);
}
if (request.FilterCriteria.TypeId.HasValue)
{
query = query.Where(p => p.TypeId == request.FilterCriteria.TypeId.Value);
}
if (request.FilterCriteria.IsDebt.HasValue)
{
query = query.Where(p => p.IsDebt == request.FilterCriteria.IsDebt.Value);
}
if (request.IncludeRecordsTotal)
{
result.RecordsTotal = query.Count();
}
switch (request.FilterCriteria.SortType)
{
case SortType.Ascending:
query = query
.OrderBy(p => p.Customer.Title);
break;
case SortType.Descending:
query = query
.OrderByDescending(p => p.Customer.Title);
break;
default:
query = query
.OrderByDescending(p => p.Id);
break;
}
query = query.Select(p => new Entities.Transaction
{
Id = p.Id,
Description = p.Description,
AttachmentName = p.AttachmentName,
Amount = p.Amount,
TypeId = p.TypeId,
IsDebt = p.IsDebt,
Date = p.Date,
CreatedAt = p.CreatedAt,
ModifiedAt = p.ModifiedAt,
Customer = new Entities.Customer
{
Id = p.CustomerId,
AuthorizedPersonName = p.Customer.AuthorizedPersonName,
Title = p.Customer.Title
}
});
result.Items = query
.Skip(request.Offset)
.Take(request.Limit)
.ToList();
return(result);
}
