public CustomerDto GetSingleCustomer(CustomerDto request)
{
try
{
var data = GetAllCachedData <CustomerDto>().AsQueryable();
var predicate = PredicateBuilderHelper.True <CustomerDto>();
if (request.Id.HasValue)
{
predicate = predicate.And(q => q.Id == request.Id);
}
predicate = predicate.And(q => q.ActivationStatus == (int)ActivationStatusType.Active);
if (!request.UserName.IsNullOrEmpty())
{
predicate = predicate.And(q => q.UserName.Contains(request.UserName));
}
if (!request.FullName.IsNullOrEmpty())
{
predicate = predicate.And(q => q.FullName.Contains(request.FullName));
}
var result = data.Where(predicate).AsEnumerable().FirstOrDefault();
return(result);
}
catch (KnownException ex)
{
throw ex;
}
catch (Exception ex)
{
Logger.AddLog(LogTypeEnum.Error, "CustomerManager.GetSingleCustomer", null, ex.Message, request.ToJson(), ex);
throw new KnownException(ErrorTypeEnum.UnexpectedExeption, ex.Message, ex);
}
}
public async Task <PagedResultDTO <BandDTO> > GetBandsPageAsync(int page, int pageSize, BandFilterDTO bandFilterDTO)
{
IQueryable <BandEntity> query = _DBContext.Bands
.Include(band => band.BandGenres)
.ThenInclude(bg => bg.Genre);
var predicate = PredicateBuilderHelper.True <BandEntity>();
if (bandFilterDTO.FestivalId != null)
{
predicate = predicate.And(band => band.Performances.Any(p => p.FestivalId == bandFilterDTO.FestivalId));
}
if (bandFilterDTO.StageId != null)
{
predicate = predicate.And(band => band.Performances.Any(p => p.StageId == bandFilterDTO.StageId));
}
if (bandFilterDTO.GenreIds != null)
{
//TO DO
//Потрібно щоб група одночасно належала до всіх вибраних жанрів.
//Чи не треба?
predicate = predicate.And(band => band.BandGenres.Any(bg => bandFilterDTO.GenreIds.Contains(bg.GenreId)));
}
query = query.Where(predicate);
var pagedResult = await _DBContext.GetPage <BandEntity, BandDTO>(_mapper, query, page, pageSize);
return(pagedResult);
}
public IEnumerable <ProductTypeDto> GetAllProductType(ProductTypeDto request, int RequestUserId, string TokenKey)
{
try
{
CheckAuthentication(RequestUserId, TokenKey);
var data = GetAllCachedData <ProductTypeEntity>().AsQueryable();
var predicate = PredicateBuilderHelper.True <ProductTypeEntity>();
if (request.Id.HasValue)
{
predicate = predicate.And(q => q.Id == request.Id);
}
if (request.ActivationStatus > 0)
{
predicate = predicate.And(q => q.ActivationStatus == request.ActivationStatus);
}
if (!request.Name.IsNullOrEmpty())
{
predicate = predicate.And(q => q.Name.Contains(request.Name));
}
var result = data.Where(predicate).AsEnumerable();
return(result.ConvertTo <IEnumerable <ProductTypeDto> >());
}
catch (KnownException ex)
{
throw ex;
}
catch (Exception ex)
{
Logger.AddLog(LogTypeEnum.Error, "ProductManager.GetAllProductType", RequestUserId, ex.Message, request.ToJson(), ex);
throw new KnownException(ErrorTypeEnum.UnexpectedExeption, ex.Message, ex);
}
}
public ProductDto GetSingleProduct(ProductDto request, int RequestUserId, string TokenKey)
{
try
{
CheckAuthentication(RequestUserId, TokenKey);
var data = GetAllCachedData <ProductEntity>().AsQueryable();
var predicate = PredicateBuilderHelper.True <ProductEntity>();
if (request.Id.HasValue)
{
predicate = predicate.And(q => q.Id == request.Id);
}
if (request.ActivationStatus > 0)
{
predicate = predicate.And(q => q.ActivationStatus == request.ActivationStatus);
}
var result = data.FirstOrDefault(predicate);
return(result.ConvertTo <ProductDto>());
}
catch (KnownException ex)
{
throw ex;
}
catch (Exception ex)
{
Logger.AddLog(LogTypeEnum.Error, "ProductManager.GetSingleProduct", null, ex.Message, request.ToJson(), ex);
throw new KnownException(ErrorTypeEnum.UnexpectedExeption, ex.Message, ex);
}
}
public PagingResultDto <IEnumerable <ProductDto> > GetAllProduct(ProductFilterRequestDto request, int RequestUserId, string TokenKey)
{
try
{
CheckAuthentication(RequestUserId, TokenKey);
var data = GetAllCachedData <ProductEntity>().AsQueryable();
var predicate = PredicateBuilderHelper.True <ProductEntity>();
if (request.PriceStart.HasValue && request.PriceEnd.HasValue)
{
predicate = predicate.And(q => q.Price >= request.PriceStart && q.Price <= request.PriceEnd);
}
if (request.DiscountPriceStart.HasValue && request.DiscountPriceEnd.HasValue)
{
predicate = predicate.And(q => q.DiscountPrice >= request.DiscountPriceStart && q.DiscountPrice <= request.DiscountPriceEnd);
}
if (request.ProductTypeId.HasValue)
{
predicate = predicate.And(q => q.ProductTypeId == request.ProductTypeId.Value);
}
var result = data.Where(predicate).AsEnumerable();
var rdata = result.ConvertTo <IEnumerable <ProductDto> >();
var ReturnData = PageingHelper.GetPagingResult(rdata, request.PageNumber, request.PageSize);
return(ReturnData);
}
catch (KnownException ex)
{
throw ex;
}
catch (Exception ex)
{
Logger.AddLog(LogTypeEnum.Error, "ProductManager.GetAllProduct", RequestUserId, ex.Message, request.ToJson(), ex);
throw new KnownException(ErrorTypeEnum.UnexpectedExeption, ex.Message, ex);
}
}
public ServicesResponse <IEnumerable <InvoiceHeaderReponseModel> > GetAllDataByFilterV2(InvoiceHeaderRequestModel requestModel)
{
var methodName = MethodBase.GetCurrentMethod().GetMethodName();
try
{
var invoiceHeaders = connectionFactory.CreateConnection().GetAll <InvoiceHeaderEntity>().AsQueryable();
var customers = customerInfoManager.GetAllDataByFilter(null, requestModel.CustomerNo).ResultData;
var users = usersInfoManager.GetAllData().ResultData;
#region Filter Condition
var predicate = PredicateBuilderHelper.True <InvoiceHeaderEntity>();
if (!requestModel.InvoiceNo.IsNullOrLessOrEqToZero())
{
predicate = predicate.Or(q => q.InvoiceNo == requestModel.InvoiceNo);
}
if (!requestModel.CustomerNo.IsNullOrLessOrEqToZero())
{
var cus = customers.FirstOrDefault(q => q.CustomerNo == requestModel.CustomerNo);
if (cus != null)
{
predicate = predicate.Or(q => q.CustomerId == cus.Id);
}
}
if (requestModel.StartDate.HasValue && requestModel.EndDate.HasValue)
{
predicate = predicate.Or(q => q.CreatedDate >= requestModel.StartDate.Value && q.CreatedDate <= requestModel.EndDate.Value);
}
#endregion
var result = invoiceHeaders.Where(predicate).Select(q => new InvoiceHeaderReponseModel
{
Currency = q.Currency,
Address = customers.FirstOrDefault(p => p.Id == q.Id).CutomerCity,
CustomerNo = customers.FirstOrDefault(p => p.Id == q.Id).CustomerNo,
GrandTotal = q.GrandTotal,
InvoiceNo = q.InvoiceNo,
CreatedDate = q.CreatedDate,
CreatedBy = users.FirstOrDefault(p => p.Id == q.CreatedUser).UserNo
}).AsEnumerable();
return(GlobalHelper.CreateServicesResponse(result));
}
catch (FattalDbException ex)
{
logger.AddErrorLog(LogTypeEnum.Error, methodName, null, ex.ExceptionMessageProp, ex);
return(GlobalHelper.CreateServicesErrorResponse <IEnumerable <InvoiceHeaderReponseModel> >(ex.ExceptionMessageProp, ex.ErrorTypeProp));
}
catch (KnownException ex)
{
return(GlobalHelper.CreateServicesErrorResponse <IEnumerable <InvoiceHeaderReponseModel> >(ex.ExceptionMessageProp, ex.ErrorTypeProp));
}
catch (Exception ex)
{
logger.AddErrorLog(LogTypeEnum.Error, methodName, null, ex.Message, ex);
return(GlobalHelper.CreateServicesErrorResponse <IEnumerable <InvoiceHeaderReponseModel> >());
}
}
private async Task <IEnumerable <ToDoDto> > QueryDataFromRepository(SearchRequestDto request)
{
var predicate = PredicateBuilderHelper.CreateSearchPredicate(request);
var result = (await _ToDoRepository.GetListAsync(predicate))
.Select(entity => _mapper.Map <ToDoEntity, ToDoDto>(entity));
return(result);
}
public ServicesResponse <IEnumerable <UserInfoModel> > GetAllDataByFilter(UserInfoRequestModel requestModel)
{
var methodName = MethodBase.GetCurrentMethod().GetMethodName();
try
{
var data = cache.GetAllCachedData().AsQueryable();
var predicate = PredicateBuilderHelper.True <UserInfoModel>();
#region Filter Condition
if (!requestModel.UserId.IsNullOrLessOrEqToZero())
{
predicate = predicate.Or(q => q.Id == requestModel.UserId);
}
if (!requestModel.UserNo.IsNullOrEmpty())
{
predicate = predicate.Or(q => q.UserNo == requestModel.UserNo);
}
if (!requestModel.UserName.IsNullOrEmpty())
{
predicate = predicate.Or(q => q.UserName.Contains(requestModel.UserName));
}
if (!requestModel.FullName.IsNullOrEmpty())
{
predicate = predicate.Or(q => q.FullName.Contains(requestModel.FullName));
}
#endregion
var result = data.Where(predicate).AsEnumerable();
return(GlobalHelper.CreateServicesResponse(result));
}
catch (FattalDbException ex)
{
logger.AddErrorLog(LogTypeEnum.Error, methodName, null, ex.ExceptionMessageProp, ex);
return(GlobalHelper.CreateServicesErrorResponse <IEnumerable <UserInfoModel> >(ex.ExceptionMessageProp, ex.ErrorTypeProp));
}
catch (KnownException ex)
{
return(GlobalHelper.CreateServicesErrorResponse <IEnumerable <UserInfoModel> >(ex.ExceptionMessageProp, ex.ErrorTypeProp));
}
catch (Exception ex)
{
logger.AddErrorLog(LogTypeEnum.Error, methodName, null, ex.Message, ex);
return(GlobalHelper.CreateServicesErrorResponse <IEnumerable <UserInfoModel> >());
}
}
public PagingResultDto <IEnumerable <UsersDto> > GetAll(UserFilterRequestDto request, int RequestUserId, string TokenKey)
{
try
{
CheckAuthentication(RequestUserId, TokenKey);
var data = GetAllCachedData <UsersDto>().AsQueryable();
var predicate = PredicateBuilderHelper.True <UsersDto>();
if (request.Id.HasValue)
{
predicate = predicate.And(q => q.Id == request.Id);
}
if (request.ActivationStatus.HasValue)
{
predicate = predicate.And(q => q.ActivationStatus == request.ActivationStatus);
}
if (!request.UserName.IsNullOrEmpty())
{
predicate = predicate.And(q => q.UserName.Contains(request.UserName));
}
if (!request.FullName.IsNullOrEmpty())
{
predicate = predicate.And(q => q.FullName.Contains(request.FullName));
}
if (!request.EMail.IsNullOrEmpty())
{
predicate = predicate.And(q => q.EMail == request.EMail);
}
var result = data.Where(predicate).AsEnumerable();
var ReturnData = PageingHelper.GetPagingResult(result, request.PageNumber, request.PageSize);
return(ReturnData);
}
catch (KnownException ex)
{
throw ex;
}
catch (Exception ex)
{
Logger.AddLog(LogTypeEnum.Error, "UserManager.GetAll", RequestUserId, ex.Message, request.ToJson(), ex);
throw new KnownException(ErrorTypeEnum.UnexpectedExeption, ex.Message, ex);
}
}
public async Task <PagedResultDTO <PerformanceDTO> > GetPerformancesPageAsync(int page, int pageSize, PerformanceFilterDTO performanceFilterDTO)
{
IQueryable <PerformanceEntity> query = _DBContext.Performances
.Include(p => p.Band)
.ThenInclude(b => b.BandGenres)
.ThenInclude(db => db.Genre)
.Include(p => p.Stage)
.Include(p => p.Festival);
var predicate = PredicateBuilderHelper.True <PerformanceEntity>();
predicate = predicate.And(performance => performance.FestivalId == performanceFilterDTO.FestivalId);
if (performanceFilterDTO.StageId != null)
{
predicate = predicate.And(performance => performance.StageId == performanceFilterDTO.StageId);
}
query = query.Where(predicate);
var pagedResult = await _DBContext.GetPage <PerformanceEntity, PerformanceDTO>(_mapper, query, page, pageSize);
return(pagedResult);
}
