public async Task <ArticleResult> FindDetailAsync(IdRequestFilter <long> filter)
{
var article = await _articleRepository.FindDetailAsync(filter);
if (article == null)
{
return(null);
}
var picture = await _articlePictureRepository.GetArticlePictureByArticleIdAsync(new IdRequestFilter <long>
{
Id = filter.Id,
CanGetDeleted = filter.CanGetDeleted,
CanGetInactived = filter.CanGetInactived
});
if (picture != null)
{
article.Picture = new PictureResult
{
Id = picture.PictureId
};
}
var createdByUserName = (await _userRepository.FindByIdAsync(article.CreatedById)).DisplayName;
article.CreatedBy = createdByUserName;
var updatedByUserName = (await _userRepository.FindByIdAsync(article.UpdatedById)).DisplayName;
article.UpdatedBy = updatedByUserName;
return(article);
}
public async Task <ProductResult> FindDetailAsync(IdRequestFilter <long> filter)
{
var product = await _productRepository.FindDetailAsync(filter);
if (product == null)
{
return(null);
}
var pictures = await _productPictureRepository.GetProductPicturesByProductIdAsync(new IdRequestFilter <long>
{
Id = filter.Id,
CanGetDeleted = filter.CanGetDeleted,
CanGetInactived = filter.CanGetInactived
});
product.Pictures = pictures.Select(x => new PictureResult
{
Id = x.PictureId
});
product.ProductAttributes = await _productAttributeRepository.GetAttributeRelationsByProductIdAsync(filter.Id);
product.CreatedBy = (await _userRepository.FindByIdAsync(product.CreatedById)).DisplayName;
product.UpdatedBy = (await _userRepository.FindByIdAsync(product.CreatedById)).DisplayName;
return(product);
}
public async Task <FarmResult> FindDetailAsync(IdRequestFilter <long> filter)
{
var deletedStatus = FarmStatus.Deleted.GetCode();
var inactivedStatus = FarmStatus.Inactived.GetCode();
var exist = await(from farm in _farmRepository
.Get(x => x.Id == filter.Id)
join farmType in _farmTypeRepository.Table
on farm.FarmTypeId equals farmType.Id
where (farm.StatusId == deletedStatus && filter.CanGetDeleted) ||
(farm.StatusId == inactivedStatus && filter.CanGetInactived) ||
(farm.StatusId != deletedStatus && farm.StatusId != inactivedStatus)
select new FarmResult
{
Id = farm.Id,
Name = farm.Name,
Address = farm.Address,
Description = farm.Description,
CreatedDate = farm.CreatedDate,
CreatedById = farm.CreatedById,
UpdatedById = farm.UpdatedById,
UpdatedDate = farm.UpdatedDate,
FarmTypeName = farmType.Name,
FarmTypeId = farm.FarmTypeId,
StatusId = farm.StatusId,
}).FirstOrDefaultAsync();
return(exist);
}
public async Task <FarmResult> FindDetailAsync(IdRequestFilter <long> filter)
{
var exist = await _farmRepository.FindDetailAsync(filter);
if (exist == null)
{
return(null);
}
var pictures = await _farmPictureRepository.GetFarmPicturesByFarmIdAsync(new IdRequestFilter <long>
{
Id = filter.Id,
CanGetDeleted = filter.CanGetDeleted,
CanGetInactived = filter.CanGetInactived
});
exist.Pictures = pictures.Select(x => new PictureResult
{
Id = x.PictureId
});
var createdByUserName = (await _userRepository.FindByIdAsync(exist.CreatedById)).DisplayName;
exist.CreatedBy = createdByUserName;
var updatedByUserName = (await _userRepository.FindByIdAsync(exist.UpdatedById)).DisplayName;
exist.UpdatedBy = updatedByUserName;
return(exist);
}
public async Task <ArticleResult> FindDetailAsync(IdRequestFilter <long> filter)
{
var deletedStatus = ArticleStatus.Deleted.GetCode();
var inactivedStatus = ArticleStatus.Inactived.GetCode();
var exist = await(from article in _articleRepository
.Get(x => x.Id == filter.Id)
join category in _articleCategoryRepository.Table
on article.ArticleCategoryId equals category.Id
where (article.StatusId == deletedStatus && filter.CanGetDeleted) ||
(article.StatusId == inactivedStatus && filter.CanGetInactived) ||
(article.StatusId != deletedStatus && article.StatusId != inactivedStatus)
select new ArticleResult
{
Description = article.Description,
CreatedDate = article.CreatedDate,
CreatedById = article.CreatedById,
Id = article.Id,
Name = article.Name,
UpdatedById = article.UpdatedById,
UpdatedDate = article.UpdatedDate,
ArticleCategoryName = category.Name,
ArticleCategoryId = article.ArticleCategoryId,
Content = article.Content,
StatusId = article.StatusId
}).FirstOrDefaultAsync();
return(exist);
}
public async Task <UserFullResult> FindFullByIdAsync(IdRequestFilter <long> filter)
{
var existUser = await _userRepository
.Get(x => x.Id.Equals(filter.Id) && (x.StatusId == _userDeletedStatus && filter.CanGetDeleted) ||
(x.StatusId == _userInactivedStatus && filter.CanGetInactived) ||
(x.StatusId != _userDeletedStatus && x.StatusId != _userInactivedStatus))
.Select(x => new UserFullResult
{
CreatedDate = x.CreatedDate,
DisplayName = x.DisplayName,
Firstname = x.Firstname,
Lastname = x.Lastname,
UserName = x.UserName,
Email = x.Email,
PhoneNumber = x.UserInfo.PhoneNumber,
Description = x.UserInfo.Description,
Address = x.UserInfo.Address,
BirthDate = x.UserInfo.BirthDate,
GenderId = x.UserInfo.GenderId,
GenderLabel = x.UserInfo.Gender.Name,
StatusId = x.StatusId,
StatusLabel = x.Status.Name,
Id = x.Id,
UpdatedDate = x.UpdatedDate,
CountryId = x.UserInfo.CountryId,
CountryCode = x.UserInfo.Country.Code,
CountryName = x.UserInfo.Country.Name,
IsEmailConfirmed = x.IsEmailConfirmed
})
.FirstOrDefaultAsync();
return(existUser);
}
public async Task <ProductAttributeResult> FindAsync(IdRequestFilter <int> filter)
{
var inactivedStatus = ProductAttributeStatus.Inactived.GetCode();
var productAttribute = await _productAttributeRepository.Get(x => x.Id == filter.Id && (filter.CanGetInactived || x.StatusId != inactivedStatus))
.Select(x => new ProductAttributeResult
{
Description = x.Description,
Id = x.Id,
Name = x.Name,
StatusId = x.StatusId
}).FirstOrDefaultAsync();
return(productAttribute);
}
public IList<SelectOption> Search(IdRequestFilter<int?> filter, string search = "")
{
search = search != null ? search.ToLower() : "";
var result = new List<SelectOption>();
if (filter.Id.HasValue)
{
var selected = (ArticleStatus)filter.Id;
result = EnumUtil.ToSelectOptions(selected).ToList();
}
else
{
result = EnumUtil.ToSelectOptions<ArticleStatus>().ToList();
}
result = result.Where(x => string.IsNullOrEmpty(search) || x.Text.ToLower().Equals(search)).ToList();
return result;
}
public async Task <ArticleCategoryResult> FindAsync(IdRequestFilter <int> filter)
{
var category = await _articleCategoryRepository.FindAsync(filter);
if (category == null)
{
return(null);
}
var createdByUser = await _userRepository.FindByIdAsync(category.CreatedById);
var updatedByUser = await _userRepository.FindByIdAsync(category.UpdatedById);
category.CreatedBy = createdByUser.DisplayName;
category.UpdatedBy = updatedByUser.DisplayName;
return(category);
}
public async Task <IList <ArticleResult> > GetArticleByCategoryIdAsync(IdRequestFilter <int> categoryIdFilter)
{
return(await _articleRepository
.Get(x => x.ArticleCategoryId == categoryIdFilter.Id)
.Where(x => categoryIdFilter.CanGetInactived || x.StatusId != ArticleCategoryStatus.Inactived.GetCode())
.Select(x => new ArticleResult
{
Id = x.Id,
Name = x.Name,
CreatedById = x.CreatedById,
CreatedDate = x.CreatedDate,
Description = x.Description,
UpdatedById = x.UpdatedById,
UpdatedDate = x.UpdatedDate,
Content = x.Content,
})
.ToListAsync());
}
public async Task <ArticlePictureResult> GetArticlePictureByArticleIdAsync(IdRequestFilter <long> filter)
{
var deletedStatus = PictureStatus.Deleted.GetCode();
var inactivedStatus = PictureStatus.Inactived.GetCode();
var articlePicture = await(from articlePic in _articlePictureRepository.Get(x => x.ArticleId == filter.Id)
join picture in _pictureRepository
.Get(x => (x.StatusId == deletedStatus && filter.CanGetDeleted) ||
(x.StatusId == inactivedStatus && filter.CanGetInactived) ||
(x.StatusId != deletedStatus && x.StatusId != inactivedStatus))
on articlePic.PictureId equals picture.Id
select new ArticlePictureResult
{
ArticleId = articlePic.ArticleId,
ArticlePictureTypeId = articlePic.PictureTypeId,
PictureId = articlePic.PictureId
}).FirstOrDefaultAsync();
return(articlePicture);
}
public async Task <IList <FarmPictureResult> > GetFarmPicturesByFarmIdAsync(IdRequestFilter <long> filter, int?farmPictureTypeId = null)
{
var deletedStatus = PictureStatus.Deleted.GetCode();
var inactivedStatus = PictureStatus.Inactived.GetCode();
var farmPictures = await(from farmPic in _farmPictureRepository
.Get(x => x.FarmId == filter.Id && (!farmPictureTypeId.HasValue || x.PictureTypeId == farmPictureTypeId))
join picture in _pictureRepository
.Get(x => (x.StatusId == deletedStatus && filter.CanGetDeleted) ||
(x.StatusId == inactivedStatus && filter.CanGetInactived) ||
(x.StatusId != deletedStatus && x.StatusId != inactivedStatus))
on farmPic.PictureId equals picture.Id
select new FarmPictureResult
{
FarmId = farmPic.FarmId,
FarmPictureTypeId = farmPic.PictureTypeId,
PictureId = farmPic.PictureId
}).ToListAsync();
return(farmPictures);
}
public async Task <ProductResult> FindAsync(IdRequestFilter <long> filter)
{
var deletedStatus = ProductStatus.Deleted.GetCode();
var inactivedStatus = ProductStatus.Inactived.GetCode();
var exist = await(from product in _productRepository
.Get(x => x.Id == filter.Id)
.Where(x => (x.StatusId == deletedStatus && filter.CanGetDeleted) ||
(x.StatusId == inactivedStatus && filter.CanGetInactived) ||
(x.StatusId != deletedStatus && x.StatusId != inactivedStatus))
select new ProductResult
{
CreatedDate = product.CreatedDate,
CreatedById = product.CreatedById,
Id = product.Id,
Name = product.Name,
UpdatedById = product.UpdatedById,
UpdatedDate = product.UpdatedDate,
}).FirstOrDefaultAsync();
return(exist);
}
public async Task <PictureResult> FindAsync(IdRequestFilter <long> filter)
{
using (_pictureRepository)
{
var picture = await _pictureRepository
.Get(x => x.Id == filter.Id)
.Where(x => (x.StatusId == _pictureDeletedStatus && filter.CanGetDeleted) ||
(x.StatusId == _pictureInactivedStatus && filter.CanGetInactived) ||
(x.StatusId != _pictureDeletedStatus && x.StatusId != _pictureInactivedStatus))
.Select(pic => new PictureResult
{
Id = pic.Id,
FileName = pic.FileName,
BinaryData = pic.BinaryData,
ContentType = pic.MimeType,
CreatedById = pic.CreatedById,
UpdatedById = pic.UpdatedById
}).FirstOrDefaultAsync();
return(picture);
}
}
public async Task <IList <FarmResult> > GetFarmByTypeIdAsync(IdRequestFilter <int> typeIdFilter)
{
var deletedStatus = FarmStatus.Deleted.GetCode();
var inactivedStatus = FarmStatus.Inactived.GetCode();
return(await _farmRepository
.Get(x => x.FarmTypeId == typeIdFilter.Id &&
((x.StatusId == deletedStatus && typeIdFilter.CanGetDeleted) ||
(x.StatusId == inactivedStatus && typeIdFilter.CanGetInactived) ||
(x.StatusId != deletedStatus && x.StatusId != inactivedStatus)))
.Select(x => new FarmResult
{
Id = x.Id,
Name = x.Name,
CreatedById = x.CreatedById,
CreatedDate = x.CreatedDate,
Description = x.Description,
UpdatedById = x.UpdatedById,
UpdatedDate = x.UpdatedDate
})
.ToListAsync());
}
public IList <ArticleCategoryResult> SearchParents(IdRequestFilter <int?> idRequestFilter, BaseFilter filter)
{
var keyword = filter.Keyword != null?filter.Keyword.ToLower() : "";
var query = _articleCategoryRepository.Get(x => !x.ParentId.HasValue && (idRequestFilter.CanGetInactived || x.StatusId != _inactivedStatus))
.Select(c => new ArticleCategoryResult
{
Id = c.Id,
Name = c.Name,
Description = c.Description,
ParentId = c.ParentId
});
if (idRequestFilter.Id.HasValue)
{
query = query.Where(x => x.Id != idRequestFilter.Id);
}
if (!string.IsNullOrEmpty(keyword))
{
query = query.Where(x => x.Name.ToLower().Contains(keyword) || x.Description.ToLower().Contains(keyword));
}
if (filter.PageSize > 0)
{
query = query.Skip((filter.Page - 1) * filter.PageSize).Take(filter.PageSize);
}
var categories = query
.Select(x => new ArticleCategoryResult()
{
Id = x.Id,
Name = x.Name,
ParentId = x.ParentId
})
.ToList();
return(categories);
}
public async Task <ShortcutResult> FindAsync(IdRequestFilter <int> filter)
{
var inactivedStatus = ShortcutStatus.Inactived.GetCode();
var shortcut = await(_shortcutRepository.Get(x => x.Id == filter.Id && (filter.CanGetInactived || x.StatusId != inactivedStatus))
.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
})).FirstOrDefaultAsync();
return(shortcut);
}
public async Task <IList <ProductResult> > GetProductByCategoryIdAsync(IdRequestFilter <int> categoryIdFilter)
{
var deletedStatus = ProductStatus.Deleted.GetCode();
var inactivedStatus = ProductStatus.Inactived.GetCode();
return(await(from relation in _productCategoryRelationRepository.Get(x => x.ProductCategoryId == categoryIdFilter.Id)
join product in _productRepository.Get(x => (x.StatusId == deletedStatus && categoryIdFilter.CanGetDeleted) ||
(x.StatusId == inactivedStatus && categoryIdFilter.CanGetInactived) ||
(x.StatusId != deletedStatus && x.StatusId != inactivedStatus))
on relation.ProductId equals product.Id
select new ProductResult
{
Id = product.Id,
Name = product.Name,
CreatedById = product.CreatedById,
CreatedDate = product.CreatedDate,
Description = product.Description,
UpdatedById = product.UpdatedById,
UpdatedDate = product.UpdatedDate,
})
.ToListAsync());
}
public async Task <ArticleCategoryResult> FindAsync(IdRequestFilter <int> filter)
{
var category = await(from child in _articleCategoryRepository.Table
join parent in _articleCategoryRepository.Table
on child.ParentId equals parent.Id into categories
from cate in categories.DefaultIfEmpty()
where child.Id == filter.Id && (filter.CanGetInactived || child.StatusId != _inactivedStatus)
select new ArticleCategoryResult
{
Description = child.Description,
CreatedDate = child.CreatedDate,
CreatedById = child.CreatedById,
Id = child.Id,
Name = child.Name,
ParentId = child.ParentId,
UpdatedById = child.UpdatedById,
UpdatedDate = child.UpdatedDate,
StatusId = child.StatusId,
ParentCategoryName = cate != null ? cate.Name : null
}).FirstOrDefaultAsync();
return(category);
}
public async Task <IList <ArticlePictureResult> > GetArticlePicturesByArticleIdsAsync(IEnumerable <long> articleIds, IdRequestFilter <long> filter)
{
return(await GetArticlePicturesByArticleIdsAsync(articleIds, filter, null));
}
public IList <SelectOption> SearchStatus(IdRequestFilter <int?> filter, string search = "")
{
return(_shortcutStatusRepository.Search(filter, search));
}
public async Task <ShortcutResult> FindAsync(IdRequestFilter <int> filter)
{
return(await _shortcutRepository.FindAsync(filter));
}
public async Task <UserFullResult> FindFullByIdAsync(IdRequestFilter <long> filter)
{
return(await _userRepository.FindFullByIdAsync(filter));
}
public IList <ArticleCategoryResult> Search(IdRequestFilter <int?> idRequestFilter, BaseFilter filter)
{
return(_articleCategoryRepository.Search(idRequestFilter, filter));
}
public async Task <PictureResult> FindAsync(IdRequestFilter <long> filter)
{
var picture = await _pictureRepository.FindAsync(filter);
return(picture);
}
public async Task <ProductResult> FindDetailAsync(IdRequestFilter <long> filter)
{
var farmDeletedStatus = ProductStatus.Deleted.GetCode();
var farmInactivedStatus = ProductStatus.Inactived.GetCode();
var farmQuery = from farm in _farmRepository
.Get(x => x.Id == filter.Id)
join farmProduct in _farmProductRepository.Table
on farm.Id equals farmProduct.FarmId
where (farm.StatusId == farmDeletedStatus && filter.CanGetDeleted) ||
(farm.StatusId == farmInactivedStatus && filter.CanGetInactived) ||
(farm.StatusId != farmDeletedStatus && farm.StatusId != farmInactivedStatus)
select new
{
Id = farmProduct.Id,
FarmId = farm.Id,
ProductId = farmProduct.ProductId,
Name = farm.Name
};
var productCategoryQuery = from category in _productCategoryRepository.Table
join categoryRelation in _productCategoryRelationRepository.Table
on category.Id equals categoryRelation.ProductCategoryId
select new
{
Id = categoryRelation.Id,
CategoryId = category.Id,
ProductId = categoryRelation.ProductId,
Name = category.Name
};
var deletedStatus = ProductStatus.Deleted.GetCode();
var inactivedStatus = ProductStatus.Inactived.GetCode();
var product = await(from p in _productRepository
.Get(x => x.Id == filter.Id)
join pr in _productPriceRepository.Get(x => x.IsCurrent)
on p.Id equals pr.ProductId into prices
from price in prices.DefaultIfEmpty()
join categoryRelation in productCategoryQuery
on p.Id equals categoryRelation.ProductId into productCategories
join fp in farmQuery
on p.Id equals fp.ProductId into farmProducts
where (p.StatusId == deletedStatus && filter.CanGetDeleted) ||
(p.StatusId == inactivedStatus && filter.CanGetInactived) ||
(p.StatusId != deletedStatus && p.StatusId != inactivedStatus)
select new ProductResult
{
Description = p.Description,
CreatedDate = p.CreatedDate,
CreatedById = p.CreatedById,
Id = p.Id,
Name = p.Name,
UpdatedById = p.UpdatedById,
UpdatedDate = p.UpdatedDate,
Price = price.Price,
StatusId = p.StatusId,
Categories = productCategories.Select(x => new ProductCategoryResult()
{
Id = x.CategoryId,
Name = x.Name
}),
Farms = farmProducts.Select(x => new ProductFarmResult()
{
Id = x.Id,
FarmId = x.FarmId,
Name = x.Name
})
}).FirstOrDefaultAsync();
return(product);
}
public async Task <ArticleResult> FindAsync(IdRequestFilter <long> filter)
{
return(await _articleRepository.FindAsync(filter));
}
public async Task <ProductAttributeResult> FindAsync(IdRequestFilter <int> filter)
{
var productAttribute = await _productAttributeRepository.FindAsync(filter);
return(productAttribute);
}
public IList <SelectOption> SearchStatus(IdRequestFilter <int?> filter, string search = "")
{
return(_productAttributeStatusRepository.Search(filter, search));
}
public async Task <IList <ArticlePictureResult> > GetArticlePicturesByArticleIdsAsync(IEnumerable <long> articleIds, IdRequestFilter <long> filter, ArticlePictureType?articlePictureType)
{
var deletedStatus = PictureStatus.Deleted.GetCode();
var inactivedStatus = PictureStatus.Inactived.GetCode();
var articlePictureTypeId = articlePictureType.HasValue ? articlePictureType.Value.GetCode() : 0;
var articlePictures = await(from articlePic in _articlePictureRepository.Get(x => x.ArticleId.In(articleIds))
join picture in _pictureRepository.Get(x => (x.StatusId == deletedStatus && filter.CanGetDeleted) ||
(x.StatusId == inactivedStatus && filter.CanGetInactived) ||
(x.StatusId != deletedStatus && x.StatusId != inactivedStatus))
on articlePic.PictureId equals picture.Id
where articlePictureTypeId == 0 || articlePic.PictureTypeId == articlePictureTypeId
select new ArticlePictureResult
{
ArticleId = articlePic.ArticleId,
ArticlePictureTypeId = articlePic.PictureTypeId,
PictureId = articlePic.PictureId
}).ToListAsync();
return(articlePictures);
}
