public async Task <BasePageList <UserStatusResult> > GetAsync(UserStatusFilter filter)
{
var search = filter.Keyword != null?filter.Keyword.ToLower() : "";
var query = _statusRepository.Table
.Select(x => new UserStatusResult()
{
Id = x.Id,
Name = x.Name,
Description = x.Description
});
if (!string.IsNullOrEmpty(search))
{
query = query.Where(x => x.Name.ToLower().Contains(search) || x.Description.ToLower().Contains(search));
}
var filteredNumber = query.Select(x => x.Id).Count();
var statuses = await query.OrderBy(x => x.Id)
.Skip(filter.PageSize * (filter.Page - 1))
.Take(filter.PageSize)
.ToListAsync();
var result = new BasePageList <UserStatusResult>(statuses)
{
TotalResult = filteredNumber,
TotalPage = (int)Math.Ceiling((double)filteredNumber / filter.PageSize)
};
return(result);
}
public async Task <BasePageList <CountryResult> > GetAsync(CountryFilter filter)
{
var keyword = filter.Keyword != null?filter.Keyword.ToLower() : "";
var query = _countryRepository.Table
.Select(x => new CountryResult()
{
Code = x.Code,
Id = x.Id,
Name = x.Name
});
if (!string.IsNullOrEmpty(keyword))
{
query = query.Where(x => x.Code.ToLower().Contains(keyword) || x.Name.ToLower().Contains(keyword));
}
var filteredNumber = query.Select(x => x.Id).Count();
var countries = await query.OrderBy(x => x.Code).Skip(filter.PageSize * (filter.Page - 1))
.Take(filter.PageSize)
.ToListAsync();
var result = new BasePageList <CountryResult>(countries)
{
TotalResult = filteredNumber,
TotalPage = (int)Math.Ceiling((double)filteredNumber / filter.PageSize)
};
return(result);
}
public async Task <BasePageList <ShortcutResult> > GetAsync(ShortcutFilter filter)
{
var inactivedStatus = ShortcutStatus.Inactived.GetCode();
var search = filter.Keyword != null?filter.Keyword.ToLower() : "";
var shortcutQuery = _shortcutRepository.Get(x => filter.CanGetInactived || x.StatusId != inactivedStatus);
if (!string.IsNullOrEmpty(search))
{
shortcutQuery = shortcutQuery.Where(user => user.Name.ToLower().Contains(search) ||
user.Description.ToLower().Contains(search));
}
var query = shortcutQuery.Select(x => new ShortcutResult
{
Description = x.Description,
Id = x.Id,
Name = x.Name,
Icon = x.Icon,
TypeId = x.TypeId,
Url = x.Url,
Order = x.Order,
StatusId = x.StatusId,
CreatedDate = x.CreatedDate,
CreatedById = x.CreatedById,
UpdatedDate = x.UpdatedDate,
UpdatedById = x.UpdatedById
});
if (filter.StatusId.HasValue)
{
query = query.Where(x => x.StatusId == filter.StatusId);
}
if (filter.TypeId.HasValue && filter.TypeId != 0)
{
query = query.Where(x => x.TypeId == filter.TypeId);
}
var filteredNumber = query.Select(x => x.Id).Count();
var categories = await query
.OrderBy(x => x.Order)
.Skip(filter.PageSize * (filter.Page - 1))
.Take(filter.PageSize).ToListAsync();
var result = new BasePageList <ShortcutResult>(categories)
{
TotalResult = filteredNumber,
TotalPage = (int)Math.Ceiling((double)filteredNumber / filter.PageSize)
};
return(result);
}
public async Task <BasePageList <ProductAttributeResult> > GetAsync(ProductAttributeFilter filter)
{
var inactivedStatus = ProductAttributeStatus.Inactived.GetCode();
var search = filter.Keyword != null?filter.Keyword.ToLower() : "";
var productAttributeQuery = _productAttributeRepository.Get(x => filter.CanGetInactived || x.StatusId != inactivedStatus);
if (!string.IsNullOrEmpty(search))
{
productAttributeQuery = productAttributeQuery.Where(user => user.Name.ToLower().Contains(search) ||
user.Description.ToLower().Contains(search));
}
var query = productAttributeQuery.Select(x => new ProductAttributeResult
{
Description = x.Description,
Id = x.Id,
Name = x.Name,
StatusId = x.StatusId,
CreatedById = x.CreatedById,
UpdatedById = x.UpdatedById,
CreatedDate = x.CreatedDate,
UpdatedDate = x.UpdatedDate
});
if (filter.StatusId.HasValue)
{
query = query.Where(x => x.StatusId == filter.StatusId);
}
var filteredNumber = query.Select(x => x.Id).Count();
var productAttributes = await query.Skip(filter.PageSize *(filter.Page - 1))
.Take(filter.PageSize).ToListAsync();
var result = new BasePageList <ProductAttributeResult>(productAttributes)
{
TotalResult = filteredNumber,
TotalPage = (int)Math.Ceiling((double)filteredNumber / filter.PageSize)
};
return(result);
}
public async Task <BasePageList <RoleResult> > GetAsync(RoleFilter filter)
{
var search = filter.Keyword != null?filter.Keyword.ToLower() : "";
var query = (from role in _roleRepository.Table
join createdBy in _userRepository.Table
on role.CreatedById equals createdBy.Id
join updatedBy in _userRepository.Table
on role.UpdatedById equals updatedBy.Id
where string.IsNullOrEmpty(search) || role.Name.ToLower().Contains(search) ||
(role.Description != null && role.Description.ToLower().Contains(search))
select new RoleResult
{
Id = role.Id,
Name = role.Name,
CreatedById = role.CreatedById,
CreatedByName = createdBy.Lastname + " " + createdBy.Firstname,
CreatedDate = role.CreatedDate,
Description = role.Description,
UpdatedById = role.UpdatedById,
UpdatedByName = updatedBy.Lastname + " " + updatedBy.Firstname,
UpdatedDate = role.UpdatedDate
});
var filteredNumber = query.Select(x => x.Id).Count();
var roles = await query.Skip(filter.PageSize *(filter.Page - 1))
.Take(filter.PageSize)
.ToListAsync();
var result = new BasePageList <RoleResult>(roles)
{
TotalResult = filteredNumber,
TotalPage = (int)Math.Ceiling((double)filteredNumber / filter.PageSize)
};
return(result);
}
public BasePageList <AuthorizationPolicyResult> Get(AuthorizationPolicyFilter filter)
{
var search = filter.Keyword != null?filter.Keyword.ToLower() : "";
var query = (from policy in _authorizationPolicyRepository.Table
join createdBy in _userRepository.Table
on policy.CreatedById equals createdBy.Id
join updatedBy in _userRepository.Table
on policy.UpdatedById equals updatedBy.Id
where string.IsNullOrEmpty(search) || policy.Name.ToLower().Contains(search) ||
(policy.Description != null && policy.Description.ToLower().Contains(search))
select new AuthorizationPolicyResult()
{
CreatedById = policy.CreatedById,
CreatedByName = createdBy.Lastname + " " + createdBy.Firstname,
CreatedDate = policy.CreatedDate,
UpdatedById = policy.UpdatedById,
UpdatedByName = updatedBy.Lastname + " " + updatedBy.Firstname,
UpdatedDate = policy.UpdatedDate,
Description = policy.Description,
Id = policy.Id,
Name = policy.Name
});
var filteredNumber = query.Select(x => x.Id).Count();
var authorizationPolicies = query.Skip(filter.PageSize * (filter.Page - 1))
.Take(filter.PageSize)
.ToList();
var result = new BasePageList <AuthorizationPolicyResult>(authorizationPolicies)
{
TotalResult = filteredNumber,
TotalPage = (int)Math.Ceiling((double)filteredNumber / filter.PageSize)
};
return(result);
}
public async Task <BasePageList <dynamic> > PageList()
{
var querymodel = new PagingModel
{
PageSize = 10,
CurrentPage = 1,
Table = "System_UserInfo",
Column = "*",
Condition = "",
OrderColumn = "EID desc",
};
var outParam = new DynamicParameters();
outParam.Add("TotalCount", dbType: DbType.Int32, direction: ParameterDirection.Output);
outParam.Add("TotalPage", dbType: DbType.Int32, direction: ParameterDirection.Output);
var mainval = new BasePageList <dynamic>
{
aaData = await MSSQL.QuerySPAsync <dynamic>("Com_Pagination", querymodel, outParam),
Totalcount = outParam.Get <int>("TotalCount"),
TotalPage = outParam.Get <int>("TotalPage")
};
return(mainval);
}
public async Task <BasePageList <FarmTypeResult> > GetAsync(FarmTypeFilter filter)
{
var search = filter.Keyword != null?filter.Keyword.ToLower() : "";
var farmTypeQuery = _farmTypeRepository.Table;
if (!string.IsNullOrEmpty(search))
{
farmTypeQuery = farmTypeQuery.Where(user => user.Name.ToLower().Contains(search) ||
user.Description.ToLower().Contains(search));
}
if (filter.StatusId.HasValue)
{
farmTypeQuery = farmTypeQuery.Where(x => x.StatusId == filter.StatusId);
}
if (filter.CreatedById.HasValue)
{
farmTypeQuery = farmTypeQuery.Where(x => x.CreatedById == filter.CreatedById);
}
if (filter.UpdatedById.HasValue)
{
farmTypeQuery = farmTypeQuery.Where(x => x.UpdatedById == filter.UpdatedById);
}
// Filter by register date/ created date
if (filter.CreatedDateFrom.HasValue && filter.CreatedDateTo.HasValue)
{
farmTypeQuery = farmTypeQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= filter.CreatedDateTo);
}
else if (filter.CreatedDateTo.HasValue)
{
farmTypeQuery = farmTypeQuery.Where(x => x.CreatedDate <= filter.CreatedDateTo);
}
else if (filter.CreatedDateFrom.HasValue)
{
farmTypeQuery = farmTypeQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= DateTime.UtcNow);
}
var query = farmTypeQuery.Select(a => new FarmTypeResult
{
CreatedById = a.CreatedById,
CreatedDate = a.CreatedDate,
Description = a.Description,
Id = a.Id,
Name = a.Name,
UpdatedById = a.UpdatedById,
UpdatedDate = a.UpdatedDate,
StatusId = a.StatusId
});
var filteredNumber = query.Select(x => x.Id).Count();
var farmTypes = await query.Skip(filter.PageSize *(filter.Page - 1))
.Take(filter.PageSize).ToListAsync();
var result = new BasePageList <FarmTypeResult>(farmTypes)
{
TotalResult = filteredNumber,
TotalPage = (int)Math.Ceiling((double)filteredNumber / filter.PageSize)
};
return(result);
}
public async Task <BasePageList <UserFullResult> > GetAsync(UserFilter filter)
{
var search = filter.Keyword != null?filter.Keyword.ToLower() : "";
var userQuery = _userRepository.Get(x => (x.StatusId == _userDeletedStatus && filter.CanGetDeleted) ||
(x.StatusId == _userInactivedStatus && filter.CanGetInactived) ||
(x.StatusId != _userDeletedStatus && x.StatusId != _userInactivedStatus));
if (!string.IsNullOrEmpty(search))
{
userQuery = userQuery.Where(user => user.Lastname.ToLower().Contains(search) ||
user.Firstname.ToLower().Contains(search) ||
(user.Lastname + " " + user.Firstname).ToLower().Contains(search) ||
user.Email.Contains(search) ||
user.DisplayName.ToLower().Contains(search));
}
if (filter.CreatedById.HasValue)
{
userQuery = userQuery.Where(x => x.CreatedById == filter.CreatedById);
}
if (filter.UpdatedById.HasValue)
{
userQuery = userQuery.Where(x => x.UpdatedById == filter.UpdatedById);
}
if (filter.StatusId.HasValue)
{
userQuery = userQuery.Where(x => x.StatusId == filter.StatusId);
}
if (filter.ExclusiveUserById.HasValue)
{
userQuery = userQuery.Where(x => x.Id != filter.ExclusiveUserById);
}
if (filter.IsEmailConfirmed.HasValue)
{
userQuery = userQuery.Where(x => x.IsEmailConfirmed == filter.IsEmailConfirmed);
}
// Filter by register date/ created date
if (filter.CreatedDateFrom.HasValue && filter.CreatedDateTo.HasValue)
{
userQuery = userQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= filter.CreatedDateTo);
}
else if (filter.CreatedDateTo.HasValue)
{
userQuery = userQuery.Where(x => x.CreatedDate <= filter.CreatedDateTo);
}
else if (filter.CreatedDateFrom.HasValue)
{
userQuery = userQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= DateTime.UtcNow);
}
// Filter in UserInfo
var userInfoQuery = _userInfoRepository.Table;
if (filter.GenderId.HasValue)
{
userInfoQuery = userInfoQuery.Where(x => x.GenderId == filter.GenderId);
}
if (filter.CountryId.HasValue)
{
userInfoQuery = userInfoQuery.Where(x => x.CountryId == filter.CountryId);
}
if (!string.IsNullOrEmpty(filter.PhoneNumber))
{
userInfoQuery = userInfoQuery.Where(x => x.PhoneNumber.Contains(filter.PhoneNumber));
}
if (!string.IsNullOrEmpty(filter.Address))
{
userInfoQuery = userInfoQuery.Where(x => x.Address.Contains(filter.Address));
}
// Filter by birthdate
if (filter.BirthDateFrom.HasValue && filter.BirthDateTo.HasValue)
{
userInfoQuery = userInfoQuery.Where(x => x.BirthDate >= filter.BirthDateFrom && x.BirthDate <= filter.BirthDateTo);
}
else if (filter.BirthDateTo.HasValue)
{
userInfoQuery = userInfoQuery.Where(x => x.BirthDate <= filter.BirthDateTo);
}
else if (filter.BirthDateFrom.HasValue)
{
userInfoQuery = userInfoQuery.Where(x => x.BirthDate >= filter.BirthDateFrom && x.BirthDate <= DateTime.UtcNow);
}
var query = (from user in userQuery
join userInfo in userInfoQuery
on user.Id equals userInfo.Id
select new UserFullResult()
{
Id = user.Id,
Email = user.Email,
Address = user.UserInfo.Address,
Lastname = user.Lastname,
Firstname = user.Firstname,
DisplayName = user.DisplayName,
CreatedDate = user.CreatedDate,
UpdatedDate = user.UpdatedDate,
BirthDate = user.UserInfo.BirthDate,
IsEmailConfirmed = user.IsEmailConfirmed,
PhoneNumber = user.UserInfo.PhoneNumber,
GenderLabel = user.UserInfo.Gender.Name,
StatusLabel = user.Status.Name,
StatusId = user.StatusId,
CountryName = user.UserInfo.Country.Name
});
var filteredNumber = query.Select(x => x.Id).Count();
var users = await query.Skip(filter.PageSize *(filter.Page - 1))
.Take(filter.PageSize)
.ToListAsync();
var result = new BasePageList <UserFullResult>(users)
{
TotalResult = filteredNumber,
TotalPage = (int)Math.Ceiling((double)filteredNumber / filter.PageSize)
};
return(result);
}
public async Task <BasePageList <FeedResult> > GetAsync(FeedFilter filter)
{
var articleQuery = _articleRepository.Get(x => (x.StatusId == _articleDeletedStatus && filter.CanGetDeleted) ||
(x.StatusId == _articleInactivedStatus && filter.CanGetInactived) ||
(x.StatusId != _articleDeletedStatus && x.StatusId != _articleInactivedStatus));
var productQuery = _productRepository.Get(x => (x.StatusId == _productDeletedStatus && filter.CanGetDeleted) ||
(x.StatusId == _productInactivedStatus && filter.CanGetInactived) ||
(x.StatusId != _productDeletedStatus && x.StatusId != _productInactivedStatus));
var farmQuery = _farmRepository.Get(x => (x.StatusId == _farmDeletedStatus && filter.CanGetDeleted) ||
(x.StatusId == _farmInactivedStatus && filter.CanGetInactived) ||
(x.StatusId != _farmDeletedStatus && x.StatusId != _farmInactivedStatus));
if (!string.IsNullOrEmpty(filter.Keyword))
{
filter.Keyword = filter.Keyword.ToLower();
articleQuery = articleQuery.Where(x => x.Name.ToLower().Contains(filter.Keyword) || x.Description.Contains(filter.Keyword));
productQuery = productQuery.Where(x => x.Name.ToLower().Contains(filter.Keyword) || x.Description.Contains(filter.Keyword));
farmQuery = farmQuery.Where(x => x.Name.ToLower().Contains(filter.Keyword) || x.Description.Contains(filter.Keyword));
}
if (filter.CreatedById.HasValue)
{
articleQuery = articleQuery.Where(x => x.CreatedById == filter.CreatedById);
productQuery = productQuery.Where(x => x.CreatedById == filter.CreatedById);
farmQuery = farmQuery.Where(x => x.CreatedById == filter.CreatedById);
}
if (filter.CreatedDateFrom.HasValue && filter.CreatedDateTo.HasValue)
{
articleQuery = articleQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= filter.CreatedDateTo);
productQuery = productQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= filter.CreatedDateTo);
farmQuery = farmQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= filter.CreatedDateTo);
}
else if (filter.CreatedDateTo.HasValue)
{
articleQuery = articleQuery.Where(x => x.CreatedDate <= filter.CreatedDateTo);
productQuery = productQuery.Where(x => x.CreatedDate <= filter.CreatedDateTo);
farmQuery = farmQuery.Where(x => x.CreatedDate <= filter.CreatedDateTo);
}
else if (filter.CreatedDateFrom.HasValue)
{
articleQuery = articleQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom);
productQuery = productQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom);
farmQuery = farmQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom);
}
var articleFeeds = (from article in articleQuery
select new FeedResult()
{
CreatedById = article.CreatedById,
CreatedDate = article.CreatedDate,
Description = string.IsNullOrEmpty(article.Description) ? article.Content : article.Description,
Id = article.Id.ToString(),
Name = article.Name,
FeedType = FeedType.Article,
});
var productFeeds = (from product in productQuery
join pr in _productPriceRepository.Get(x => x.IsCurrent)
on product.Id equals pr.ProductId into prices
from price in prices.DefaultIfEmpty()
select new FeedResult
{
CreatedById = product.CreatedById,
CreatedDate = product.CreatedDate,
Description = product.Description,
Id = product.Id.ToString(),
Name = product.Name,
FeedType = FeedType.Product,
Price = price != null ? price.Price : 0,
});
var farmFeeds = (from farm in farmQuery
select new FeedResult()
{
CreatedById = farm.CreatedById,
CreatedDate = farm.CreatedDate,
Description = farm.Description,
Id = farm.Id.ToString(),
Name = farm.Name,
FeedType = FeedType.Farm,
Address = farm.Address,
});
var feedQuery = articleFeeds
.UnionAll(productFeeds)
.UnionAll(farmFeeds);
var filteredNumber = await feedQuery.CountAsync();
articleFeeds = articleFeeds.Take(filter.PageSize);
productFeeds = productFeeds.Take(filter.PageSize);
farmFeeds = farmFeeds.Take(filter.PageSize);
feedQuery = articleFeeds
.UnionAll(productFeeds)
.UnionAll(farmFeeds)
.OrderByDescending(x => x.CreatedDate)
.Skip(filter.PageSize * (filter.Page - 1))
.Take(filter.PageSize);
var feeds = await feedQuery.ToListAsync();
var result = new BasePageList <FeedResult>(feeds)
{
TotalResult = filteredNumber,
TotalPage = (int)Math.Ceiling((double)filteredNumber / filter.PageSize)
};
return(result);
}
public async Task <BasePageList <ProductResult> > GetAsync(ProductFilter filter)
{
var deletedStatus = ProductStatus.Deleted.GetCode();
var inactivedStatus = ProductStatus.Inactived.GetCode();
var search = filter.Keyword != null?filter.Keyword.ToLower() : "";
var productQuery = _productRepository.Get(x => (x.StatusId == deletedStatus && filter.CanGetDeleted) ||
(x.StatusId == inactivedStatus && filter.CanGetInactived) ||
(x.StatusId != deletedStatus && x.StatusId != inactivedStatus));
if (!string.IsNullOrEmpty(search))
{
productQuery = productQuery.Where(user => user.Name.ToLower().Contains(search) ||
user.Description.ToLower().Contains(search));
}
if (filter.CreatedById.HasValue)
{
productQuery = productQuery.Where(x => x.CreatedById == filter.CreatedById);
}
if (filter.StatusId.HasValue)
{
productQuery = productQuery.Where(x => x.StatusId == filter.StatusId);
}
if (filter.UpdatedById.HasValue)
{
productQuery = productQuery.Where(x => x.UpdatedById == filter.UpdatedById);
}
if (filter.CategoryId.HasValue)
{
productQuery = productQuery.Where(x => x.ProductCategories.Any(c => c.ProductCategoryId == filter.CategoryId));
}
if (filter.FarmId.HasValue)
{
productQuery = productQuery.Where(x => x.ProductFarms.Any(c => c.FarmId == filter.FarmId));
}
// Filter by register date/ created date
if (filter.CreatedDateFrom.HasValue && filter.CreatedDateTo.HasValue)
{
productQuery = productQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= filter.CreatedDateTo);
}
else if (filter.CreatedDateTo.HasValue)
{
productQuery = productQuery.Where(x => x.CreatedDate <= filter.CreatedDateTo);
}
else if (filter.CreatedDateFrom.HasValue)
{
productQuery = productQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= DateTimeOffset.UtcNow);
}
var filteredNumber = productQuery.Select(x => x.Id).Count();
var farmQuery = from farm in _farmRepository.Get(x => x.StatusId != ProductStatus.Deleted.GetCode())
join farmProduct in _farmProductRepository.Table
on farm.Id equals farmProduct.FarmId
select new
{
Id = farmProduct.Id,
FarmId = farm.Id,
ProductId = farmProduct.ProductId,
Name = farm.Name
};
var query = from product in productQuery
join pr in _productPriceRepository.Get(x => x.IsCurrent)
on product.Id equals pr.ProductId into prices
from price in prices.DefaultIfEmpty()
join fp in farmQuery
on product.Id equals fp.ProductId into farmProducts
select new ProductResult
{
Id = product.Id,
Name = product.Name,
Price = price != null ? price.Price : 0,
CreatedById = product.CreatedById,
CreatedDate = product.CreatedDate,
Description = product.Description,
UpdatedById = product.UpdatedById,
UpdatedDate = product.UpdatedDate,
StatusId = product.StatusId,
Farms = farmProducts.Select(x => new ProductFarmResult
{
Id = x.Id,
FarmId = x.FarmId,
Name = x.Name
})
};
var products = await query
.OrderByDescending(x => x.CreatedDate)
.Skip(filter.PageSize * (filter.Page - 1))
.Take(filter.PageSize).ToListAsync();
var result = new BasePageList <ProductResult>(products)
{
TotalResult = filteredNumber,
TotalPage = (int)Math.Ceiling((double)filteredNumber / filter.PageSize)
};
return(result);
}
public async Task <BasePageList <ArticlePictureResult> > GetAsync(ArticlePictureFilter filter)
{
var pictureQuery = _pictureRepository.Get(x => x.StatusId != PictureStatus.Pending.GetCode());
if (!string.IsNullOrEmpty(filter.Keyword))
{
var search = filter.Keyword.ToLower();
pictureQuery = pictureQuery.Where(pic => pic.Title.ToLower().Contains(search));
}
if (filter.CreatedById.HasValue)
{
pictureQuery = pictureQuery.Where(x => x.CreatedById == filter.CreatedById);
}
if (!string.IsNullOrEmpty(filter.MimeType))
{
var mimeType = filter.MimeType.ToLower();
pictureQuery = pictureQuery.Where(x => x.MimeType.Contains(mimeType));
}
// Filter by register date/ created date
if (filter.CreatedDateFrom.HasValue && filter.CreatedDateTo.HasValue)
{
pictureQuery = pictureQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= filter.CreatedDateTo);
}
else if (filter.CreatedDateTo.HasValue)
{
pictureQuery = pictureQuery.Where(x => x.CreatedDate <= filter.CreatedDateTo);
}
else if (filter.CreatedDateFrom.HasValue)
{
pictureQuery = pictureQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= DateTimeOffset.UtcNow);
}
var query = from ap in _articlePictureRepository.Table
join p in pictureQuery
on ap.PictureId equals p.Id
join a in _articleRepository.Table
on ap.ArticleId equals a.Id
select new ArticlePictureResult()
{
ArticleId = a.Id,
ArticleName = a.Name,
PictureId = p.Id,
PictureName = p.FileName,
ArticlePictureTypeId = ap.PictureTypeId,
PictureCreatedById = p.CreatedById,
PictureCreatedDate = p.CreatedDate,
ContentType = p.MimeType
};
var filteredNumber = query.Select(x => x.PictureId).Count();
var articlePictures = await query.Skip(filter.PageSize *(filter.Page - 1))
.Take(filter.PageSize).ToListAsync();
var result = new BasePageList <ArticlePictureResult>(articlePictures)
{
TotalResult = filteredNumber,
TotalPage = (int)Math.Ceiling((double)filteredNumber / filter.PageSize)
};
return(result);
}
public async Task <BasePageList <ArticleResult> > GetAsync(ArticleFilter filter)
{
var deletedStatus = ArticleStatus.Deleted.GetCode();
var inactivedStatus = ArticleStatus.Inactived.GetCode();
var search = filter.Keyword != null?filter.Keyword.ToLower() : "";
var articleQuery = _articleRepository.Get(x => (x.StatusId == deletedStatus && filter.CanGetDeleted) ||
(x.StatusId == inactivedStatus && filter.CanGetInactived) ||
(x.StatusId != deletedStatus && x.StatusId != inactivedStatus));
if (!string.IsNullOrEmpty(search))
{
articleQuery = articleQuery.Where(user => user.Name.ToLower().Contains(search) ||
user.Description.ToLower().Contains(search));
}
var content = filter.Content != null?filter.Content.ToLower() : "";
if (!string.IsNullOrEmpty(content))
{
articleQuery = articleQuery.Where(user => user.Content.ToLower().Contains(content));
}
if (filter.StatusId.HasValue)
{
articleQuery = articleQuery.Where(x => x.StatusId == filter.StatusId);
}
if (filter.CreatedById.HasValue)
{
articleQuery = articleQuery.Where(x => x.CreatedById == filter.CreatedById);
}
if (filter.UpdatedById.HasValue)
{
articleQuery = articleQuery.Where(x => x.UpdatedById == filter.UpdatedById);
}
if (filter.CategoryId.HasValue)
{
articleQuery = articleQuery.Where(x => x.ArticleCategoryId == filter.CategoryId);
}
// Filter by register date/ created date
if (filter.CreatedDateFrom.HasValue && filter.CreatedDateTo.HasValue)
{
articleQuery = articleQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= filter.CreatedDateTo);
}
else if (filter.CreatedDateTo.HasValue)
{
articleQuery = articleQuery.Where(x => x.CreatedDate <= filter.CreatedDateTo);
}
else if (filter.CreatedDateFrom.HasValue)
{
articleQuery = articleQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= DateTimeOffset.UtcNow);
}
var filteredNumber = articleQuery.Select(x => x.Id).Count();
var query = from ar in articleQuery
select new ArticleResult
{
Id = ar.Id,
Name = ar.Name,
CreatedById = ar.CreatedById,
CreatedDate = ar.CreatedDate,
Description = ar.Description,
UpdatedById = ar.UpdatedById,
UpdatedDate = ar.UpdatedDate,
Content = ar.Content,
StatusId = ar.StatusId
};
var articles = await query
.OrderByDescending(x => x.CreatedDate)
.Skip(filter.PageSize * (filter.Page - 1))
.Take(filter.PageSize).ToListAsync();
var result = new BasePageList <ArticleResult>(articles)
{
TotalResult = filteredNumber,
TotalPage = (int)Math.Ceiling((double)filteredNumber / filter.PageSize)
};
return(result);
}
public async Task <BasePageList <FarmResult> > GetAsync(FarmFilter filter)
{
var deletedStatus = FarmStatus.Deleted.GetCode();
var inactivedStatus = FarmStatus.Inactived.GetCode();
var search = filter.Keyword != null?filter.Keyword.ToLower() : "";
var farmQuery = _farmRepository.Get(x => (x.StatusId == deletedStatus && filter.CanGetDeleted) ||
(x.StatusId == inactivedStatus && filter.CanGetInactived) ||
(x.StatusId != deletedStatus && x.StatusId != inactivedStatus));
if (!string.IsNullOrEmpty(search))
{
farmQuery = farmQuery.Where(user => user.Name.ToLower().Contains(search) ||
user.Description.ToLower().Contains(search));
}
if (filter.ExclusiveUserId.HasValue)
{
farmQuery = farmQuery.Where(x => x.CreatedById != filter.ExclusiveUserId);
}
if (filter.StatusId.HasValue)
{
farmQuery = farmQuery.Where(x => x.StatusId == filter.StatusId);
}
if (filter.CreatedById.HasValue)
{
farmQuery = farmQuery.Where(x => x.CreatedById == filter.CreatedById);
}
if (filter.UpdatedById.HasValue)
{
farmQuery = farmQuery.Where(x => x.UpdatedById == filter.UpdatedById);
}
if (filter.FarmTypeId.HasValue)
{
farmQuery = farmQuery.Where(x => x.FarmTypeId == filter.FarmTypeId);
}
// Filter by register date/ created date
if (filter.CreatedDateFrom.HasValue && filter.CreatedDateTo.HasValue)
{
farmQuery = farmQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= filter.CreatedDateTo);
}
else if (filter.CreatedDateTo.HasValue)
{
farmQuery = farmQuery.Where(x => x.CreatedDate <= filter.CreatedDateTo);
}
else if (filter.CreatedDateFrom.HasValue)
{
farmQuery = farmQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= DateTimeOffset.UtcNow);
}
var filteredNumber = farmQuery.Select(x => x.Id).Count();
var query = from farm in farmQuery
select new FarmResult
{
Id = farm.Id,
Name = farm.Name,
Address = farm.Address,
CreatedById = farm.CreatedById,
CreatedDate = farm.CreatedDate,
Description = farm.Description,
UpdatedById = farm.UpdatedById,
UpdatedDate = farm.UpdatedDate,
StatusId = farm.StatusId
};
var farms = await query
.OrderByDescending(x => x.CreatedDate)
.Skip(filter.PageSize * (filter.Page - 1))
.Take(filter.PageSize).ToListAsync();
var result = new BasePageList <FarmResult>(farms)
{
TotalResult = filteredNumber,
TotalPage = (int)Math.Ceiling((double)filteredNumber / filter.PageSize)
};
return(result);
}
