public async Task <ArticlePageListModel> GetArticlesAsync(ArticleFilterModel criterias)
{
if (criterias == null)
{
criterias = new ArticleFilterModel();
}
var filterRequest = new ArticleFilter
{
Page = criterias.Page,
PageSize = _pagerOptions.PageSize,
Keyword = criterias.Search
};
try
{
var articlePageList = await _articleService.GetAsync(filterRequest);
var articles = await MapArticlesResultToModelAsync(articlePageList.Collections);
var articlePage = new ArticlePageListModel(articles)
{
Filter = criterias,
TotalPage = articlePageList.TotalPage,
TotalResult = articlePageList.TotalResult
};
return(articlePage);
}
catch (Exception)
{
throw;
}
}
public void GetAllArticles_WithoutFilters_Success()
{
var filter = new ArticleFilter();
var pagination = new ArticlePaginationFilter()
{
PageNumber = 1, PageSize = 5
};
var filterQuery = _mapper.Map <ArticleQuery>(filter);
var articles = GetTestArticles().AsQueryable().OrderByDescending(x => x.Created);
var filteredArticles = articles.Select(x => _mapper.Map <ArticleDto>(x)).ToList();
_articleRepositoryMock.Setup(x => x.GetAllQueryable()).Returns(articles);
_articleFilterServiceMock.Setup(x => x.AddAllFiltersQuery(filterQuery, articles))
.Returns(articles);
var actual = _service.GetAllArticles(filter, pagination);
var expectedSer = JsonConvert.SerializeObject(filteredArticles);
var actualSer = JsonConvert.SerializeObject(actual.Data);
//Assert.AreEqual(1, actual.TotalPages);
Assert.AreEqual(pagination.PageSize, actual.PageSize);
Assert.AreEqual(pagination.PageNumber, actual.PageNumber);
//Assert.AreEqual(expectedSer, actualSer);
}
private IEnumerable <ArticleModel> GetWithPaging(ArticleFilter articleFilter, IQueryable <Articles> query)
{
_unitOfWork.GetRepository <Articles>().GetWithPaging(articleFilter.PageIndex, articleFilter.PageSize, 0, query);
return(query.Select(x => new ArticleModel {
Name = x.Title
}).ToList());
}
public IEnumerable<Article> FindArticles(ArticleSearchCriteria criteria)
{
var filter = new ArticleFilter(criteria);
return filter.Select(Entities.Articles);
//return criteria.Disciplines != null
// ? from article in Entities.Articles
// where
// article.Title.Contains(criteria.Title) &&
// article.Text.Contains(criteria.Description) &&
// (article.Authors.Any(a =>
// a.Email.Contains(criteria.Author) ||
// a.FirstName.Contains(criteria.Author) ||
// a.LastName.Contains(criteria.Author))) &&
// article.Disciplines.Any(d => criteria.Disciplines.Contains(d.Id))
// orderby article.PostedDate descending
// select article
// : from article in Entities.Articles
// where
// article.Title.Contains(criteria.Title) &&
// article.Text.Contains(criteria.Description) &&
// (article.Authors.Any(a =>
// a.Email.Contains(criteria.Author) ||
// a.FirstName.Contains(criteria.Author) ||
// a.LastName.Contains(criteria.Author)))
// orderby article.PostedDate descending
// select article;
}
public async Task <IList <ArticleResult> > GetRelevantsAsync(long id, ArticleFilter filter)
{
var articles = await _articleRepository.GetRelevantsAsync(id, filter);
var createdByIds = articles.Select(x => x.CreatedById).ToArray();
var createdByUsers = await _userRepository.GetNameByIdsAsync(createdByIds);
var articleIds = articles.Select(x => x.Id);
var pictures = await _articlePictureRepository.GetArticlePicturesByArticleIdsAsync(articleIds, new IdRequestFilter <long>
{
CanGetDeleted = filter.CanGetDeleted,
CanGetInactived = filter.CanGetInactived
});
foreach (var article in articles)
{
var createdBy = createdByUsers.FirstOrDefault(x => x.Id == article.CreatedById);
article.CreatedBy = createdBy.DisplayName;
var picture = pictures.FirstOrDefault(x => x.ArticleId == article.Id);
if (picture != null)
{
article.Picture = new PictureResult {
Id = picture.PictureId
};
}
}
return(articles);
}
public async Task <IList <ArticleModel> > GetRelevantArticlesAsync(ArticleFilterModel criterias)
{
if (criterias == null)
{
criterias = new ArticleFilterModel();
}
if (!criterias.Id.HasValue || criterias.Id <= 0)
{
return(new List <ArticleModel>());
}
var filterRequest = new ArticleFilter()
{
Page = criterias.Page,
PageSize = criterias.PageSize.HasValue && criterias.PageSize < _pagerOptions.PageSize ? criterias.PageSize.Value : _pagerOptions.PageSize,
Keyword = criterias.Search
};
try
{
var relevantArticles = await _articleService.GetRelevantsAsync(criterias.Id.GetValueOrDefault(), filterRequest);
var products = await MapArticlesResultToModelAsync(relevantArticles);
return(products);
}
catch (Exception)
{
throw;
}
}
public async Task <IList <ArticleResult> > GetRelevantsAsync(long id, ArticleFilter filter)
{
var exist = (from ar in _articleRepository.Get(x => x.Id == id && x.StatusId != ArticleStatus.Deleted.GetCode())
select new ArticleResult
{
Id = ar.Id,
CreatedById = ar.CreatedById,
UpdatedById = ar.UpdatedById,
ArticleCategoryId = ar.ArticleCategoryId
}).FirstOrDefault();
var relevantArticleQuery = (from ar in _articleRepository.Get(x => x.Id != exist.Id && x.StatusId != ArticleStatus.Deleted.GetCode())
where ar.CreatedById == exist.CreatedById ||
ar.ArticleCategoryId == exist.ArticleCategoryId ||
ar.UpdatedById == exist.UpdatedById
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,
});
var relevantArticles = await relevantArticleQuery
.OrderByDescending(x => x.CreatedDate).Skip(filter.PageSize * (filter.Page - 1))
.Take(filter.PageSize).ToListAsync();
return(relevantArticles);
}
private async void buttonGetArticle_Click(object sender, EventArgs e)
{
this.dataGridView1.DataSource = null;
this.buttonGetArticle.Enabled = false;
try
{
var zalandoWrapper = new ZalandoWrapper();
var filter = new ArticleFilter();
//filter.AgeGroup = AgeGroup.Kids | AgeGroup.Babies;
filter.AgeGroup = this.comboBoxAgeGroup.SelectedItem as AgeGroup?;
filter.Color = this.comboBoxColor.SelectedItem as Color?;
filter.FullText = this.textBoxFullText.Text;
filter.Gender = this.comboBoxGender.SelectedItem as Gender?;
var task = await zalandoWrapper.GetArticles(filter);
this.dataGridView1.DataSource = task.Content;
}
catch (Exception exception)
{
}
this.buttonGetArticle.Enabled = true;
}
public IEnumerable <Article> FindArticles(ArticleSearchCriteria criteria)
{
var filter = new ArticleFilter(criteria);
return(filter.Select(Entities.Articles));
//return criteria.Disciplines != null
// ? from article in Entities.Articles
// where
// article.Title.Contains(criteria.Title) &&
// article.Text.Contains(criteria.Description) &&
// (article.Authors.Any(a =>
// a.Email.Contains(criteria.Author) ||
// a.FirstName.Contains(criteria.Author) ||
// a.LastName.Contains(criteria.Author))) &&
// article.Disciplines.Any(d => criteria.Disciplines.Contains(d.Id))
// orderby article.PostedDate descending
// select article
// : from article in Entities.Articles
// where
// article.Title.Contains(criteria.Title) &&
// article.Text.Contains(criteria.Description) &&
// (article.Authors.Any(a =>
// a.Email.Contains(criteria.Author) ||
// a.FirstName.Contains(criteria.Author) ||
// a.LastName.Contains(criteria.Author)))
// orderby article.PostedDate descending
// select article;
}
// [OutputCache(VaryByParam = "filter")]
public ViewResult Index(ArticleFilter filter)
{
var repo = _unitOfWork.ArticlesRepository;
var query = _unitOfWork.ArticlesRepository
.All()
.Select(x => new { Article = x, DevicesCount = x.Devices.Count });
if (filter != null)
{
if (!string.IsNullOrWhiteSpace(filter.Code))
{
query = query.Where(x => x.Article.Code.StartsWith(filter.Code));
}
if (!string.IsNullOrWhiteSpace(filter.Name))
{
query = query.Where(x => x.Article.Name.StartsWith(filter.Name));
}
}
var model = new ArticlesList
{
Items = query.ToList()
.Select(x =>
{
// set devices count to use in mapper
x.Article.DevicesCount = x.DevicesCount;
return(_mapper.Map <Article>(x.Article));
})
.ToList(),
Filter = filter
};
return(View(model));
}
protected void InitalizeCategoryArticles()
{
ArticlesByCategoryPlaceHolder.Controls.Clear();
var categories = ArticleCategory.GetAllActiveCategories(SelectedCountry);
ArticleFilter articleFilter = new ArticleFilter(SelectedCountry);
articleFilter.FirstResults = 3;
if (categories.Count == 0)
{
ArticlesByCategoryPlaceHolder.Controls.Add(GetNoArticlesLiteral());
return;
}
foreach (var category in categories)
{
articleFilter.CategoryId = category.Id;
List <Article> articles = ArticlesManager.Get(articleFilter);
Literal literal = new Literal();
literal.Text = String.Format("<h5>{0}</h5>", category.Text);
ArticlesByCategoryPlaceHolder.Controls.Add(literal);
AddArticlesToPlaceholder(articles, ArticlesByCategoryPlaceHolder, ArticleType.Category);
}
}
public async Task <IEnumerable <ArticleModel> > GetData(ArticleFilter articleFilter)
{
var query = GetWithFilter(articleFilter);
var dataWithPaging = GetWithPaging(articleFilter, query);
return(await dataWithPaging.ToAsyncEnumerable().Select(x => new ArticleModel {
Name = x.Name
}).ToList());
}
public async Task <PagedList <Article> > GetArticles(ArticleFilter filter)
{
IQueryable <Article> articles = filter.StoreId > 0
? _context.ArticleStores
.Where(ast => ast.StoreId == filter.StoreId)
.Select(ast => ast.Article)
: _context.Articles.AsQueryable();
articles = articles
.Include(a => a.ArticleUserSettings)
.Include(a => a.StockEntryValues)
.Include(a => a.ArticleStores)
.Where(a => a.ArticleUserSettings.Any(aus => aus.EnvironmentId == filter.EnvironmentId));
if (filter.IsOnStock)
{
List <int> articlesOnStock = await _context.StockEntries
.Where(se => se.EnvironmentId == filter.EnvironmentId)
.Select(se => se.ArticleId).ToListAsync();
articles = articles.Where(a => articlesOnStock.Contains(a.Id));
}
if (filter.IsOpened)
{
var articlesOpened = await _context.StockEntryValues
.Where(sev => sev.IsOpened && sev.EnvironmentId == filter.EnvironmentId)
.Select(sev => sev.ArticleId)
.ToListAsync();
articles = articles.Where(a => articlesOpened.Contains(a.Id));
}
if (filter.KeepOnStock)
{
var keepStockArticles = await _context.ArticleUserSettings
.Where(aus => aus.KeepStockAmount > 0 && aus.EnvironmentId == filter.EnvironmentId)
.Select(aus => aus.ArticleId).ToListAsync();
articles = articles.Where(a => keepStockArticles.Contains(a.Id));
}
if (!string.IsNullOrEmpty(filter.NameOrEan))
{
var envArticles = await _context.ArticleUserSettings
.Where(aus => aus.EnvironmentId == filter.EnvironmentId)
.Select(aus => aus.ArticleId).ToListAsync();
articles = articles
.Where(a => a.Barcode == filter.NameOrEan || a.Name.Contains(filter.NameOrEan) &&
envArticles.Contains(a.Id));
}
articles = articles.OrderBy(a => a.Name);
return(await PagedList <Article> .CreateAsync(articles, filter.PageNumber, filter.PageSize));
}
// GET: Admin
public async Task <ActionResult> Index(ArticleFilter filter)
{
var articles = await db.GetArticles(filter.Year, filter.Title);
var model = new ArticleList {
Articles = articles, Filter = filter
};
return(View("Index", model));
}
/// <summary>
/// Gets a list of up to 250 articles belonging to the given blog.
/// </summary>
/// <param name="blogId">The blog that the articles belong to.</param>
/// <param name="filter">Options for filtering the result.</param>
public virtual async Task <IEnumerable <Article> > ListAsync(long blogId, ArticleFilter filter = null)
{
var req = PrepareRequest($"blogs/{blogId}/articles.json");
if (filter != null)
{
req.Url.QueryParams.AddRange(filter.ToParameters());
}
return(await ExecuteRequestAsync <List <Article> >(req, HttpMethod.Get, rootElement : "articles"));
}
protected void InitalizeTreningArticles()
{
TreningArticlesPlaceHolder.Controls.Clear();
ArticleFilter articleFilter = new ArticleFilter(SelectedCountry);
articleFilter.FirstResults = 5;
List <Article> articles = ArticlesManager.Get(articleFilter);
AddArticlesToPlaceholder(articles, TreningArticlesPlaceHolder);
}
protected void InitalizeHeadliner()
{
ArticleHeadlinerPlaceHolder.Controls.Clear();
ArticleFilter articleFilter = new ArticleFilter(SelectedCountry);
articleFilter.FirstResults = 1;
List <Article> articles = ArticlesManager.Get(articleFilter);
AddArticlesToPlaceholder(articles, ArticleHeadlinerPlaceHolder, ArticleType.Headliner);
}
protected void InitalizeSuggestedArticles()
{
SuggestedArticlesPlaceHolder.Controls.Clear();
ArticleFilter articleFilter = new ArticleFilter(SelectedCountry);
articleFilter.FirstResults = 5;
articleFilter.CategoryId = Article.CategoryId;
List <Article> articles = ArticlesManager.Get(articleFilter);
AddArticlesToPlaceholder(articles, SuggestedArticlesPlaceHolder);
}
protected void InitalizeMainArticles()
{
ArticlesPlaceHolder.Controls.Clear();
ArticleFilter articleFilter = new ArticleFilter(SelectedCountry);
articleFilter.SkipFirst = 1; //We want to skip headliner
articleFilter.FirstResults = 30;
List <Article> articles = ArticlesManager.Get(articleFilter);
AddArticlesToPlaceholder(articles, ArticlesPlaceHolder, ArticleType.Main);
}
public Pagination <ArticleDto> GetAllArticles(ArticleFilter filters = null, ArticlePaginationFilter pagination = null)
{
var filterQuery = _mapper.Map <ArticleQuery>(filters);
var paginationQuery = _mapper.Map <ArticlePaginationQuery>(pagination);
var skip = (paginationQuery.PageNumber - 1) * paginationQuery.PageSize;
var articles = GetArticlesWithIncludes().OrderByDescending(x => x.Created);
var filteredArticles = _articleFilterService.AddAllFiltersQuery(filterQuery, articles).ToList();
var articlesResult = filteredArticles.Select(x => _mapper.Map <ArticleDto>(x)).Skip(skip).Take(paginationQuery.PageSize);
var paginationResponse = PaginationHelper.CreatePaginatedResponse(_uriService, paginationQuery,
articlesResult.ToList(), filteredArticles.ToList(), "/Article", filterQuery);
return(paginationResponse);
}
public ActionResult <Pagination <IEnumerable <ArticleDto> > > GetAllArticles([FromQuery] ArticleFilter articleFilters = null,
[FromQuery] ArticlePaginationFilter pagination = null)
{
try
{
var articles = _articleService.GetAllArticles(articleFilters, pagination);
return(Ok(articles));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
// GET: SkinCare/page-1
public ActionResult Page(int page = 1)
{
ArticleFilter af = new ArticleFilter();
af.Status = Consts.ArticleStatus_Published;
var pager = PageReq <ArticleFilter> .Create(af, page, 10);
var article = jlService.ArticlePage(pager);
return(View(article));
}
public static SortDefinition <ArticleEntity> GetSortFilter(ArticleFilter filter)
{
SortDefinition <ArticleEntity> sortDefinition = null;
if (filter != null)
{
if (filter.ByAuthorAsc.HasValue)
{
if (filter.ByAuthorAsc.Value)
{
sortDefinition = Builders <ArticleEntity> .Sort.Ascending(a => a.Author);
}
else
{
sortDefinition = Builders <ArticleEntity> .Sort.Descending(a => a.Author);
}
}
if (filter.ByDateAsc.HasValue)
{
if (filter.ByDateAsc.Value)
{
sortDefinition = Builders <ArticleEntity> .Sort.Ascending(a => a.Date);
}
else
{
sortDefinition = Builders <ArticleEntity> .Sort.Descending(a => a.Date);
}
}
if (filter.ByOwnerAsc.HasValue)
{
if (filter.ByOwnerAsc.Value)
{
sortDefinition = Builders <ArticleEntity> .Sort.Ascending(a => a.Owner);
}
else
{
sortDefinition = Builders <ArticleEntity> .Sort.Descending(a => a.Owner);
}
}
}
if (sortDefinition == null)
{
sortDefinition = Builders <ArticleEntity> .Sort.Ascending(a => a.Id);
}
return(sortDefinition);
}
public async Task <RequestInfo> GetArticles(ArticleFilter articleFilter)
{
using (var httpClient = new HttpClient())
{
var query = articleFilter.GetFilter();
httpClient.DefaultRequestHeaders.Add("Accept-Language", this._language);
var httpResponseMessage = await httpClient.GetAsync($"https://api.zalando.com/articles{query}");
var json = await httpResponseMessage.Content.ReadAsStringAsync();
var requestInfo = JsonConvert.DeserializeObject <RequestInfo>(json);
return(requestInfo);
}
}
// GET: backend/Article
public ActionResult Index(ArticleSearchModel model, int page = 1)
{
ArticleFilter filter = new ArticleFilter();
filter.Title = model.Title;
filter.Status = Consts.ArticleStatus_All;
var pager = PageReq <ArticleFilter> .Create(filter, page);
pager.OrderBy = "order by addtime";
var data = jlService.ArticlePage(pager);
ViewBag.articleQuery = filter;
ViewBag.ReturnUrl = Request.Url.PathAndQuery;
return(View(data));
}
public async Task <IActionResult> GetArticles([FromQuery] ArticleFilter filter)
{
if (!await _authService
.IsPermitted(User, filter.EnvironmentId))
{
return(Unauthorized());
}
PagedList <Article> articles = await _repo.GetArticles(filter);
IEnumerable <ArticleDto> articlesDto = _mapper.Map <IEnumerable <ArticleDto> >(articles);
Response.AddPagination(articles.CurrentPage, articles.PageSize, articles.TotalCount, articles.TotalPages);
return(Ok(articlesDto));
}
public async Task <ArticlePageListModel> GetUserArticlesAsync(ClaimsPrincipal claimsPrincipal, ArticleFilterModel criterias)
{
if (criterias == null)
{
criterias = new ArticleFilterModel();
}
if (string.IsNullOrEmpty(criterias.UserIdentityId))
{
return(new ArticlePageListModel(new List <ArticleModel>())
{
Filter = criterias
});
}
var currentUserId = GetCurrentUserId(claimsPrincipal);
var userId = await _userManager.DecryptUserIdAsync(criterias.UserIdentityId);
var filterRequest = new ArticleFilter
{
Page = criterias.Page,
PageSize = _pagerOptions.PageSize,
Keyword = criterias.Search,
CreatedById = userId,
CanGetInactived = currentUserId == userId
};
try
{
var articlePageList = await _articleService.GetAsync(filterRequest);
var articles = await MapArticlesResultToModelAsync(articlePageList.Collections);
var articlePage = new ArticlePageListModel(articles)
{
Filter = criterias,
TotalPage = articlePageList.TotalPage,
TotalResult = articlePageList.TotalResult
};
return(articlePage);
}
catch (Exception)
{
throw;
}
}
// [HttpPost]
public ActionResult DeleteArticle(int id, ArticleFilter filter)
{
var repo = _unitOfWork.ArticlesRepository;
var hasDevices = _unitOfWork.DevicesRepository.All().Any(x => x.ArticleId == id);
var hasOrders = _unitOfWork.OrdersRepository.All().Any(x => x.Articles.Any(a => a.Id == id));
if (!hasDevices && !hasOrders)
{
repo.Delete(id);
_unitOfWork.SaveChanges();
return(RedirectToAction("Index", new { filter }));
}
ModelState.AddModelError("", "Can't delete article because it has devices or orders.");
return(View("CantDeleteArticle"));
}
private IQueryable <Articles> GetWithFilter(ArticleFilter articleFilter)
{
var repository = _unitOfWork.GetRepository <Articles>();
IQueryable <Articles> query = repository.GetWithFilter();
if (articleFilter.id != 0)
{
query = repository.GetWithFilter((x => x.ArticleId == articleFilter.id));
}
else if (articleFilter.name != "")
{
query = query.Where(x => x.Title == articleFilter.name);
}
return(query);
}
public async Task <BasePageList <ArticleResult> > GetAsync(ArticleFilter filter)
{
var articlePageList = await _articleRepository.GetAsync(filter);
var createdByIds = articlePageList.Collections.Select(x => x.CreatedById).ToArray();
var updatedByIds = articlePageList.Collections.Select(x => x.UpdatedById).ToArray();
var createdByUsers = await _userRepository.GetNameByIdsAsync(createdByIds);
var updatedByUsers = await _userRepository.GetNameByIdsAsync(updatedByIds);
var articleIds = articlePageList.Collections.Select(x => x.Id);
var pictures = await _articlePictureRepository.GetArticlePicturesByArticleIdsAsync(articleIds, new IdRequestFilter <long>
{
CanGetDeleted = filter.CanGetDeleted,
CanGetInactived = filter.CanGetInactived
});
var userAvatars = await _userPhotoRepository.GetUserPhotosByUserIdsAsync(createdByIds, UserPictureType.Avatar);
foreach (var article in articlePageList.Collections)
{
var createdBy = createdByUsers.FirstOrDefault(x => x.Id == article.CreatedById);
article.CreatedBy = createdBy.DisplayName;
var updatedBy = updatedByUsers.FirstOrDefault(x => x.Id == article.UpdatedById);
article.UpdatedBy = updatedBy.DisplayName;
article.Description = string.IsNullOrEmpty(article.Description) ? HtmlUtil.TrimHtml(article.Content) : article.Description;
var picture = pictures.FirstOrDefault(x => x.ArticleId == article.Id);
if (picture != null)
{
article.Picture = new PictureResult {
Id = picture.PictureId
};
}
var avatar = userAvatars.FirstOrDefault(x => x.UserId == article.CreatedById);
if (avatar != null)
{
article.CreatedByPhotoCode = avatar.Code;
}
}
return(articlePageList);
}
protected void LoadArticles()
{
string country = CountriesDropDownList.SelectedValue.Replace("'", "''");
string searchText = SearchTextBox.Text.Replace("'", "''");
ArticleFilter articleFilter = new ArticleFilter(CountriesDropDownList.SelectedValue, Convert.ToInt32(CategoriesDropDownList.SelectedValue));
if (!String.IsNullOrWhiteSpace(searchText))
{
articleFilter.SearchText = searchText;
}
List <Article> articles = ArticlesManager.Get(articleFilter);
ArticlesPlaceHolder.Controls.Clear();
for (int i = 0; i < articles.Count; i++)
{
ArticlesPlaceHolder.Controls.Add(GetArticleHTML(articles[i]));
}
}
