public static BaseSearchDto <TModel> Paginate <TModel>(
this IQueryable <TModel> query,
int page,
int limit)
where TModel : class
{
var paged = new BaseSearchDto <TModel>();
page = (page <= 0) ? 0 : page;
paged.currentPage = page;
paged.recordOfPage = limit;
var totalItemsCountTask = query.Count();
var startRow = (page) * limit;
paged.result = query
.Skip(startRow)
.Take(limit)
.ToList();
paged.totalRecords = totalItemsCountTask;
return(paged);
}
public BaseSearchDto <ImportingOrderDto> GetAll(BaseSearchDto <ImportingOrderDto> searchDto)
{
var orderSearch = _orderRepo.GetAll(searchDto);
var suppliers = _supplierRepo.GetAll().ToList();
var employees = _employeeRepo.GetAll().ToList();
foreach (ImportingOrder o in orderSearch.result)
{
o.Supplier = suppliers.Where(s => s.Id == o.SupplierId).FirstOrDefault();
o.Employee = employees.Where(e => e.Id == o.EmployeeId).FirstOrDefault();
}
BaseSearchDto <ImportingOrderDto> orderDtoSearch = new BaseSearchDto <ImportingOrderDto> {
currentPage = orderSearch.currentPage,
recordOfPage = orderSearch.recordOfPage,
totalRecords = orderSearch.totalRecords,
sortAsc = orderSearch.sortAsc,
sortBy = orderSearch.sortBy,
createdDateSort = orderSearch.createdDateSort,
pagingRange = orderSearch.pagingRange,
result = _mapper.Map <List <ImportingOrderDto> >(orderSearch.result)
};
return(orderDtoSearch);
}
public BaseSearchDto <ProductDetailDto> GetAll(BaseSearchDto <ProductDetailDto> searchDto)
{
var productdetailSearch = _repo.GetAll(searchDto);
var colors = _colorRepo.GetAll().ToList();
var sizes = _sizeRepo.GetAll().ToList();
var products = _productRepo.GetAll().ToList();
foreach (ProductDetail c in productdetailSearch.result)
{
c.Product = products.Where(s => s.Id == c.ProductId).FirstOrDefault();
c.Size = sizes.Where(s => s.Id == c.SizeId).FirstOrDefault();
c.Color = colors.Where(s => s.Id == c.ColorId).FirstOrDefault();
}
BaseSearchDto <ProductDetailDto> productdetailDtoSearch = new BaseSearchDto <ProductDetailDto> {
currentPage = productdetailSearch.currentPage,
recordOfPage = productdetailSearch.recordOfPage,
totalRecords = productdetailSearch.totalRecords,
sortAsc = productdetailSearch.sortAsc,
sortBy = productdetailSearch.sortBy,
createdDateSort = productdetailSearch.createdDateSort,
pagingRange = productdetailSearch.pagingRange,
result = _mapper.Map <List <ProductDetailDto> >(productdetailSearch.result)
};
return(productdetailDtoSearch);
}
public async Task <PagedResult <SuggestedNotableDto> > GetSuggestedNotables(
BaseSearchDto getNotablesRequest,
int customerId,
string token)
{
string endpointUrl = string.Format("api/{0}/notables/", customerId);
var queryStringBuilder = new StringBuilder();
if (getNotablesRequest != null)
{
queryStringBuilder.AppendFormat("?skip={0}", getNotablesRequest.Skip);
queryStringBuilder.AppendFormat("&take={0}", getNotablesRequest.Take);
if (!string.IsNullOrEmpty(getNotablesRequest.Q))
{
queryStringBuilder.AppendFormat("&q={0}", getNotablesRequest.Q);
}
}
endpointUrl += queryStringBuilder.ToString();
var response =
await
apiClient.SendRequestAsync <PagedResult <SuggestedNotableDto> >(endpointUrl, null, Method.GET, null, token);
return(response);
}
/// <summary>
/// Gets the categories of care.
/// </summary>
/// <param name="customerId">The customer identifier.</param>
/// <param name="request">The request.</param>
/// <returns></returns>
public async Task <PagedResultDto <CategoryOfCareResponseDto> > GetCategoriesOfCare(
int customerId,
BaseSearchDto request
)
{
var categoriesOfCare = await сategoriesOfCareService.GetCategoriesOfCare(customerId, request);
return(Mapper.Map <PagedResult <CategoryOfCare>, PagedResultDto <CategoryOfCareResponseDto> >(categoriesOfCare));
}
public async Task <IHttpActionResult> GetCategoriesOfCare(
int customerId,
[FromUri] BaseSearchDto request
)
{
var result = await categoriesOfCareControllerHelper.GetCategoriesOfCare(customerId, request);
return(Ok(result));
}
public async Task <IHttpActionResult> SearchTags(
int customerId,
[FromUri] BaseSearchDto request
)
{
var result = await tagsControllerHelper.SearchTags(customerId, request);
return(Ok(result));
}
public async Task <PageModelDto <OpsLogDto> > GetUserOpsLogsPaged(BaseSearchDto searchDto)
{
var logSearchDto = new LogSearchDto()
{
Account = _userContext.Account,
PageIndex = searchDto.PageIndex,
PageSize = searchDto.PageSize
};
return(await _logService.GetOpsLogsPaged(logSearchDto));
}
public BaseSearchDto <Category> GetAll(BaseSearchDto <CategoryDto> search)
{
var categorySearch = _db.Categories.Paginate(search.currentPage, search.recordOfPage);
return(new BaseSearchDto <Category> {
currentPage = search.currentPage,
pagingRange = search.pagingRange,
recordOfPage = search.recordOfPage,
totalRecords = categorySearch.totalRecords,
result = categorySearch.result.ToList()
});
}
public BaseSearchDto <Size> GetAll(BaseSearchDto <SizeDto> search)
{
var sizeSearch = _db.Sizes.Paginate(search.currentPage, search.recordOfPage);
return(new BaseSearchDto <Size> {
currentPage = search.currentPage,
pagingRange = search.pagingRange,
recordOfPage = search.recordOfPage,
totalRecords = sizeSearch.totalRecords,
result = sizeSearch.result.ToList()
});
}
public BaseSearchDto <Supplier> GetAll(BaseSearchDto <SupplierDto> searchDto)
{
var supplierSearch = _db.Suppliers.Paginate(searchDto.currentPage, searchDto.recordOfPage);
return(new BaseSearchDto <Supplier> {
currentPage = searchDto.currentPage,
pagingRange = searchDto.pagingRange,
recordOfPage = searchDto.recordOfPage,
totalRecords = supplierSearch.totalRecords,
result = supplierSearch.result.ToList()
});
}
public BaseSearchDto <Product> GetAll(BaseSearchDto <ProductDto> search)
{
var productSearch = _db.Products.Paginate(search.currentPage, search.recordOfPage);
return(new BaseSearchDto <Product> {
currentPage = search.currentPage,
pagingRange = search.pagingRange,
recordOfPage = search.recordOfPage,
totalRecords = productSearch.totalRecords,
result = productSearch.result.ToList()
});
}
public BaseSearchDto <Customer> GetAll(BaseSearchDto <CustomerDto> search)
{
var customerSearch = _db.Customers.Paginate(search.currentPage, search.recordOfPage);
return(new BaseSearchDto <Customer> {
currentPage = search.currentPage,
pagingRange = search.pagingRange,
recordOfPage = search.recordOfPage,
totalRecords = customerSearch.totalRecords,
result = customerSearch.result.ToList()
});
}
public BaseSearchDto <Employee> GetAll(BaseSearchDto <EmployeeDto> search)
{
var employeeSearch = _db.Employees.Paginate(search.currentPage, search.recordOfPage);
return(new BaseSearchDto <Employee> {
currentPage = search.currentPage,
pagingRange = search.pagingRange,
recordOfPage = search.recordOfPage,
totalRecords = employeeSearch.totalRecords,
result = employeeSearch.result.ToList()
});
}
public BaseSearchDto <CategoryDto> GetAll(BaseSearchDto <CategoryDto> searchDto)
{
var categorySearch = _repo.GetAll(searchDto);
BaseSearchDto <CategoryDto> categoryDtoSearch = new BaseSearchDto <CategoryDto> {
currentPage = categorySearch.currentPage,
recordOfPage = categorySearch.recordOfPage,
totalRecords = categorySearch.totalRecords,
sortAsc = categorySearch.sortAsc,
sortBy = categorySearch.sortBy,
createdDateSort = categorySearch.createdDateSort,
pagingRange = categorySearch.pagingRange,
result = _mapper.Map <List <CategoryDto> >(categorySearch.result)
};
return(categoryDtoSearch);
}
public BaseSearchDto <SupplierDto> GetAll(BaseSearchDto <SupplierDto> searchDto)
{
var supplierSearch = _repo.GetAll(searchDto);
BaseSearchDto <SupplierDto> supplierDtoSearch = new BaseSearchDto <SupplierDto> {
currentPage = supplierSearch.currentPage,
recordOfPage = supplierSearch.recordOfPage,
totalRecords = supplierSearch.totalRecords,
sortAsc = supplierSearch.sortAsc,
sortBy = supplierSearch.sortBy,
createdDateSort = supplierSearch.createdDateSort,
pagingRange = supplierSearch.pagingRange,
result = _mapper.Map <List <SupplierDto> >(supplierSearch.result)
};
return(supplierDtoSearch);
}
public BaseSearchDto <RoleDto> GetAll(BaseSearchDto <RoleDto> searchDto)
{
var roleSearch = _repo.GetAll(searchDto);
BaseSearchDto <RoleDto> roleDtoSearch = new BaseSearchDto <RoleDto> {
currentPage = roleSearch.currentPage,
recordOfPage = roleSearch.recordOfPage,
totalRecords = roleSearch.totalRecords,
sortAsc = roleSearch.sortAsc,
sortBy = roleSearch.sortBy,
createdDateSort = roleSearch.createdDateSort,
pagingRange = roleSearch.pagingRange,
result = _mapper.Map <List <RoleDto> >(roleSearch.result)
};
return(roleDtoSearch);
}
public ActionResult <BaseSearchDto <CategoryDto> > GetAll([FromBody] BaseSearchDto <CategoryDto> searchDto)
{
var search = _categoryService.GetAll(searchDto);
if (search == null)
{
List <string> errorMessage = new List <string>();
errorMessage.Add("Đã phát sinh lỗi, vui lòng thử lại");
return(BadRequest(new ResponseDto(errorMessage, 500, search)));
}
List <string> successMessage = new List <string>();
successMessage.Add("Lấy danh mục hàng hoá thành công");
var responseDto = new ResponseDto(successMessage, 200, search);
return(Ok(responseDto));
}
public BaseSearchDto <SubCategoryDto> GetAll(BaseSearchDto <SubCategoryDto> searchDto)
{
var subCategorySearch = _repo.GetAll(searchDto);
var categories = _categoryRepo.GetAll().ToList();
foreach (SubCategory c in subCategorySearch.result)
{
c.Category = categories.Where(s => s.Id == c.CategoryId).FirstOrDefault();
}
BaseSearchDto <SubCategoryDto> subCategoryDtoSearch = new BaseSearchDto <SubCategoryDto> {
currentPage = subCategorySearch.currentPage,
recordOfPage = subCategorySearch.recordOfPage,
totalRecords = subCategorySearch.totalRecords,
sortAsc = subCategorySearch.sortAsc,
sortBy = subCategorySearch.sortBy,
createdDateSort = subCategorySearch.createdDateSort,
pagingRange = subCategorySearch.pagingRange,
result = _mapper.Map <List <SubCategoryDto> >(subCategorySearch.result)
};
return(subCategoryDtoSearch);
}
public BaseSearchDto <SellingOrderDto> GetAll(BaseSearchDto <SellingOrderDto> searchDto)
{
var orderSearch = _orderRepo.GetAll(searchDto);
var customers = _customerRepo.GetAll().ToList();
foreach (SellingOrder o in orderSearch.result)
{
o.Customer = customers.Where(c => c.Id == o.CustomerId).FirstOrDefault();
}
BaseSearchDto <SellingOrderDto> orderDtoSearch = new BaseSearchDto <SellingOrderDto> {
currentPage = orderSearch.currentPage,
recordOfPage = orderSearch.recordOfPage,
totalRecords = orderSearch.totalRecords,
sortAsc = orderSearch.sortAsc,
sortBy = orderSearch.sortBy,
createdDateSort = orderSearch.createdDateSort,
pagingRange = orderSearch.pagingRange,
result = _mapper.Map <List <SellingOrderDto> >(orderSearch.result)
};
return(orderDtoSearch);
}
public BaseSearchDto <ProductDto> GetAll(BaseSearchDto <ProductDto> searchDto)
{
var productSearch = _productRepo.GetAll(searchDto);
var subCategories = _subCategoryRepo.GetAll().ToList();
foreach (Product c in productSearch.result)
{
c.SubCategory = subCategories.Where(s => s.Id == c.SubCategoryId).FirstOrDefault();
}
BaseSearchDto <ProductDto> productDtoSearch = new BaseSearchDto <ProductDto> {
currentPage = productSearch.currentPage,
recordOfPage = productSearch.recordOfPage,
totalRecords = productSearch.totalRecords,
sortAsc = productSearch.sortAsc,
sortBy = productSearch.sortBy,
createdDateSort = productSearch.createdDateSort,
pagingRange = productSearch.pagingRange,
result = _mapper.Map <List <ProductDto> >(productSearch.result)
};
return(productDtoSearch);
}
/// <summary>
/// Searches the tags.
/// </summary>
/// <param name="customerId">The customer identifier.</param>
/// <param name="request">The request.</param>
/// <returns></returns>
public async Task <PagedResultDto <string> > SearchTags(int customerId, BaseSearchDto request)
{
var allCachedTags = await tagsSearchCacheHelper.GetAllCachedTags(customerId);
Expression <Func <string, bool> > expression = PredicateBuilder.True <string>();
if (request != null)
{
if (!string.IsNullOrEmpty(request.Q))
{
var terms = request.Q.Split(' ').Where(r => !string.IsNullOrWhiteSpace(r));
foreach (var t in terms)
{
expression = expression.And(e => e.ToLower().Contains(t.ToLower()));
}
}
}
var filteredTags = allCachedTags
.Where(expression.Compile())
.OrderBy(t => t)
.ToList();
var total = filteredTags.LongCount();
if (request != null)
{
filteredTags = filteredTags.Skip(request.Skip).Take(request.Take).ToList();
}
return(new PagedResultDto <string>()
{
Results = filteredTags,
Total = total
});
}
public BaseSearchDto <EmployeeDto> GetAll(BaseSearchDto <EmployeeDto> searchDto)
{
var employeeSearch = employeeRepository.GetAll(searchDto);
var roles = _roleRepository.GetAll().ToList();
foreach (Employee c in employeeSearch.result)
{
c.Role = roles.Where(s => s.Id == c.RoleId).FirstOrDefault();
}
BaseSearchDto <EmployeeDto> subCategoryDtoSearch = new BaseSearchDto <EmployeeDto> {
currentPage = employeeSearch.currentPage,
recordOfPage = employeeSearch.recordOfPage,
totalRecords = employeeSearch.totalRecords,
sortAsc = employeeSearch.sortAsc,
sortBy = employeeSearch.sortBy,
createdDateSort = employeeSearch.createdDateSort,
pagingRange = employeeSearch.pagingRange,
result = _mapper.Map <List <EmployeeDto> >(employeeSearch.result)
};
return(subCategoryDtoSearch);
}
/// <summary>
/// Returns the sum of the values of all Incomes that match the given filter.
/// </summary>
/// <param name="dto">The search dto that will apply the filters.</param>
/// <returns>The sum of the 'value' property of the returned items.</returns>
public virtual decimal GetValueSum(BaseSearchDto <Income> dto)
{
return(this.Find(dto).Sum(i => i.Value));
}
/// <summary>
/// Gets the list of suggested notables
/// </summary>
/// <param name="getNotablesRequest">The search request.</param>
/// <param name="customerId">The customer identifier</param>
/// <param name="token">The authorization token</param>
/// <returns></returns>
public async Task <PagedResult <SuggestedNotableDto> > GetSuggestedNotables(BaseSearchDto getNotablesRequest, int customerId, string token)
{
return(await notesDataProvider.GetSuggestedNotables(getNotablesRequest, customerId, token));
}
/// <summary>
/// Returns calendar program by id.
/// </summary>
/// <param name="customerId"></param>
/// <param name="patientId"></param>
/// <param name="searchCriteria"></param>
/// <param name="token"></param>
/// <returns></returns>
public async Task <PagedResult <CalendarProgramResponseDto> > GetCalendarPrograms(int customerId, Guid patientId,
BaseSearchDto searchCriteria, string token)
{
return(await this.patientsDataProvider.GetCalendarPrograms(customerId, patientId, searchCriteria, token));
}
/// <summary>
/// Returns list of records from calendar history for specified criteria.
/// </summary>
/// <param name="customerId"></param>
/// <param name="patientId"></param>
/// <param name="searchDto"></param>
/// <param name="token"></param>
/// <returns></returns>
public async Task <PagedResult <CalendarChangeResponseDto> > GetCalendarHistory(int customerId, Guid patientId,
BaseSearchDto searchDto, string token)
{
return(await this.patientsDataProvider.GetCalendarHistory(customerId, patientId, searchDto, token));
}
/// <summary>
/// Returns calendar programs matches to search criteria.
/// </summary>
/// <param name="customerId"></param>
/// <param name="patientId"></param>
/// <param name="searchCriteria"></param>
/// <param name="token"></param>
/// <returns></returns>
public async Task <PagedResult <CalendarProgramResponseDto> > GetCalendarPrograms(int customerId, Guid patientId,
BaseSearchDto searchCriteria, string token)
{
string endpointUrl = string.Format("/api/{0}/patient/{1}/programs", customerId, patientId);
return(await this.apiClient.SendRequestAsync <PagedResult <CalendarProgramResponseDto> >(endpointUrl,
searchCriteria, Method.GET, null, token));
}
/// <summary>
/// Returns list of records from calendar history for specified criteria.
/// </summary>
/// <param name="customerId"></param>
/// <param name="patientId"></param>
/// <param name="searchDto"></param>
/// <param name="token"></param>
/// <returns></returns>
public async Task <PagedResult <CalendarChangeResponseDto> > GetCalendarHistory(int customerId, Guid patientId,
BaseSearchDto searchDto, string token)
{
string endpointUrl = string.Format("/api/{0}/patient/{1}/history", customerId, patientId);
return(await apiClient.SendRequestAsync <PagedResult <CalendarChangeResponseDto> >(
endpointUrl, searchDto, Method.GET, null, token));
}
/// <summary>
/// Returns list of all default sessions for specified patient.
/// </summary>
/// <param name="customerId"></param>
/// <param name="patientId"></param>
/// <param name="searchDto"></param>
/// <param name="token"></param>
/// <returns></returns>
public async Task <PagedResult <DefaultSessionResponseDto> > GetDefaultSessions(int customerId, Guid patientId, BaseSearchDto searchDto, string token)
{
string endpointUrl = string.Format("/api/{0}/patient/{1}/default-sessions", customerId, patientId);
return(await
this.apiClient.SendRequestAsync <PagedResult <DefaultSessionResponseDto> >(endpointUrl, searchDto,
Method.GET, null, token));
}
