public virtual async Task Parse(Source source)
{
Source = source;
Logger.LogInformation($"Starting parse {source.Title}");
var rss = await GetSource(source.SourceUrl);
var items = GetRssItems(rss);
foreach (var item in items)
{
if (await Contains(item.Link))
{
continue;
}
var article = ToArticle(item, source);
if (!await DownloadHtml(article, source))
{
continue;
}
ArticleOverride(article);
article.IsClean = IsClean(article);
await Repository.AddArticle(article);
}
}
public IActionResult PostNews([FromBody] Article post)
{
if (ModelState.IsValid)
{
var latestPosts = articleRepo.Articles.OrderByDescending(x => x.DatePosted).Take(15).ToList();
foreach (var p in latestPosts)
{
if (p.Guid == post.Guid)
{
post.Id = p.Id;
articleRepo.EditArticle(post);
return(Ok());
}
}
post.DatePosted = DateTime.Now;
articleRepo.AddArticle(post);
return(Ok());
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> AddArticle([FromBody] Article model)
{
if (ModelState.IsValid)
{
try
{
var ArticleId = await ArticleRepository.AddArticle(model);
if (ArticleId > 0)
{
return(Ok(ArticleId));
}
else
{
return(NotFound());
}
}
catch (Exception)
{
return(BadRequest());
}
}
return(BadRequest());
}
public async Task <IActionResult> Post(ArticleAddDto article)
{
var art_model = _mapper.Map <Article>(article);
await _repository.AddArticle(art_model);
return(Ok());
}
public async Task <IActionResult> ArticlePost([FromBody] ArticleViewModel articleVm)
{
var contct = new Article();
contct.AddToArticle(articleVm);
var dr = await _articleRepository.GetArticlesByCatSect(articleVm.articleCategoryID, articleVm.SectionID);
if (dr != null)
{
if (dr.Count() > 7)
{
throw new Exception("There is too many articles in this section already Delete some");
}
try
{
await _articleRepository.AddArticle(contct);
return(Ok());
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
return(Ok());
}
public void AddArticle(Article article)
{
if (article == null)
{
return;
}
var customProperties = new Dictionary <string, object>
{
[nameof(article.Title)] = article.Title,
[nameof(article.Author)] = article.Author,
[nameof(article.PublicationDate)] = article.PublicationDate
};
if (_authorRepository.IsBlackListedAuthor(article.Author))
{
throw BusinessValidationException.AuthorIsBlackListed(article.Author, customProperties);
}
if (_articleRepository.ArticleExists(article))
{
throw BusinessException.ArticleExists(article.Title, customProperties);
}
_articleRepository.AddArticle(article);
}
public Article AddArticle(string description, decimal price)
{
var article = new Article()
{
Description = description, Price = price, Status = "1"
};
return(repository.AddArticle(article));
}
public async Task <IActionResult> New(NewsViewModel model)
{
try
{
if (ModelState.IsValid)
{
var elections = await _electionsRepository.GetElectionsForNewsFeed();
var ballots = elections.Value.SelectMany(e => e.Ballots).ToList();
var selectedBallot = ballots
.FirstOrDefault(b => b.BallotId == model.SelectedElectionId);
if (selectedBallot == null)
{
selectedBallot = ballots.FirstOrDefault();
}
var pictures = new List <ArticlePicture>();
if (model.Pictures != null && model.Pictures.Count > 0)
{
var uniqueFileNames = await UploadedFiles(model);
foreach (var fileName in uniqueFileNames)
{
pictures.Add(new ArticlePicture
{
Url = $"{fileName}"
});
}
await _picturesRepository.RemovePictures(model.NewsId);
}
var newsFeed = new Article
{
Link = model.Link,
Embed = model.Embed,
Title = model.Title,
Body = model.Body,
BallotId = selectedBallot.BallotId,
ElectionId = selectedBallot.ElectionId,
Timestamp = DateTime.Now,
AuthorId = model.SelectedAuthorId.GetValueOrDefault(),
Pictures = pictures
};
newsFeed.Id = model.NewsId;
await _articleRepository.AddArticle(newsFeed);
return(RedirectToAction(nameof(Index)));
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
var newsFeedViewModel = await BuildEditNewsFeedViewModel();
return(View(newsFeedViewModel));
}
public IActionResult AddNewArticle(ArticlesViewModel articlesViewModel)
{
if (ModelState.IsValid)
{
_articleRepository.AddArticle(articlesViewModel);
}
return(RedirectToAction("Index"));
}
private void AddBook()
{
var book = new Book
{
Id = 1,
InternationalStandardBookNumber = "9780132350884",
Title = "Clean Code",
SubTitle = "A Handbook of Agile Software Craftsmanship",
Description = "Noted software expert Robert C. Martin presents a revolutionary paradigm with Clean Code: A Handbook of Agile Software Craftsmanship . Martin has teamed up with his colleagues from Object Mentor to distill their best agile practice of cleaning code “on the fly” into a book that will instill within you the values of a software craftsman and make you a better programmer–but only if you work at it.",
Publisher = new Publisher {
Id = 1,
Name = "Prentice Hall",
},
Authors = new List <Author> {
new Author {
Id = 1,
FullName = "Robert C. Martin",
Info = "aka. Oncle Bob",
},
new Author {
Id = 2,
FullName = "Dean Wampler",
Info = "",
},
},
Categories = new List <Category> {
new Category {
Id = 1,
Name = "Computers",
},
},
Language = new Language {
Name = "English"
},
};
_articles.AddArticle(book);
var article = _articles.FindArticleById(1);
Assert.True(article is Book);
var tmpBook = article as Book;
Assert.Equal(book.Id, tmpBook.Id);
Assert.Equal(book.Name, tmpBook.Name);
Assert.Equal(book.Title, tmpBook.Title);
Assert.Equal(book.SubTitle, tmpBook.SubTitle);
Assert.Equal(book.InternationalStandardBookNumber, tmpBook.InternationalStandardBookNumber);
Assert.Equal(book.Description, tmpBook.Description);
Assert.True(tmpBook.Publisher != null);
Assert.Equal(book.Publisher.Name, tmpBook.Publisher.Name);
Assert.True(tmpBook.Authors.Count == 2);
Assert.True(tmpBook.Categories.Count == 1);
Assert.True(tmpBook.Language != null);
Assert.Equal(book.Language.Name, tmpBook.Language.Name);
}
[Authorize] //accessed with admin only
//http://localhost:50357/api/article
public async Task <IActionResult> AddArticle(Article article)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
articleRepository.AddArticle(article);
await unitOfWork.Complete();//to save changes in database
return(Ok(article));
}
public async Task <IActionResult> AddNewArticle(AddArticleModel articleModel)
{
await _article.AddArticle(new Article
{
TextHtml = articleModel.TextHtml,
DateTime = DateTime.Now,
FKArticleType = articleModel.FKArticleType,
});
return(RedirectToAction("ShowAllArticle"));
}
/// <summary>
/// Dodaje na bazę przekazany artykuł
/// </summary>
public Article AddArticle(Article article)
{
_log.Debug("[AddArticle] Start - type '{0}' code = '{1}' author '{2}' title '{3}' length '{4}'",
article.TypeId, article.Code, article.Author, article.Title, article.Content.Length);
article.AddDate = DateTime.Now;
article.Author = _user?.Login ?? article.Author;
_articleRepo.AddArticle(article);
return(article);
}
public override async Task <AddArticleRequest> HandleAsync(AddArticleRequest command, CancellationToken cancellationToken = new CancellationToken())
{
var issue = await _issueRepository.GetIssue(command.LibraryId, command.PeridicalId, command.VolumeNumber, command.IssueNumber, cancellationToken);
if (issue == null)
{
throw new BadRequestException();
}
command.Result = await _articleRepository.AddArticle(command.LibraryId, command.PeridicalId, issue.Id, command.Article, cancellationToken);
return(await base.HandleAsync(command, cancellationToken));
}
public void TestAddArticle()
{
var tags = new List <string> {
"Travel"
};
var model = new ArticleFormViewModel {
Title = "Title", Text = "Text", Tags = tags
};
var article = _repository.AddArticle("1", model);
Assert.NotNull(article);
Assert.AreEqual("Title", article.Title);
}
public bool AddArticle(AddArticleModel articleModel)
{
try
{
_repository.AddArticle(articleModel.Article);
var articleId = (int)_repository.GetLastArticleId();
_repository.AddArticleAuthor(articleId, articleModel.AuthorId);
}
catch
{
return(false);
}
return(true);
}
public async Task <bool> AddArticle(Post article)
{
try
{
var status = await _articleRepository.AddArticle(article);
return(status);
}
catch (Exception ex)
{
new Logger().LogError(ModuleName, "AddArticle", "Error Adding Article" + ex + "\n");
throw;
}
}
public IActionResult CreateArticle([FromBody] ArticleForCreationDto articleForCreationDto)
{
var articleModel = _mapper.Map <Article>(articleForCreationDto);
_articleRepository.AddArticle(articleModel);
_articleRepository.Save();
var articleReturn = _mapper.Map <ArticleDto>(articleModel);
return(CreatedAtRoute(
"GetArticle",
new { articleId = articleReturn.Id },
articleReturn
));
}
public GenericResponse <TArticle> AddArticle(TArticle article)
{
try
{
if (article == null)
{
return(new GenericResponse <TArticle>("Article is empty"));
}
ArticleRepository.AddArticle(article);
return(new GenericResponse <TArticle>(article));
}
catch (Exception ex)
{
return(new GenericResponse <TArticle>(ex.Message));
}
}
public GraphQLSampleMutation(IArticleRepository articleRepository)
{
_articleRepository = articleRepository;
FieldAsync <ArticleType>(
"createArticle",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ArticleInputType> > {
Name = "article"
}),
resolve: async context =>
{
var article = context.GetArgument <Article>("article");
return(await context.TryAsyncResolve(
async c => await _articleRepository.AddArticle(article)));
});
}
public Article AddArticle(Article article)
{
try
{
return(_repo.AddArticle(article));
}
catch (SqlException sqlException)
{
Console.WriteLine(sqlException);
throw;
}
catch (InvalidCastException invalidCastException)
{
Console.WriteLine(invalidCastException);
throw;
}
}
public async Task <ActionResult <ArticleViewModel> > AddArticle(AddViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var article = _mapper.Map <Article>(model);
var newArticle = await _articleRepository.AddArticle(article);
if (newArticle == null)
{
return(BadRequest());
}
var newArticleResult = _mapper.Map <ArticleViewModel>(newArticle);
return(CreatedAtAction(nameof(AddArticle), new { id = newArticleResult.IdArticle }, newArticleResult));
}
public async Task <ActionResult <Article> > CreateArticle(Article article)
{
try
{
if (article == null)
{
return(BadRequest());
}
var createdArticle = await articleRepository.AddArticle(article);
return(CreatedAtAction(nameof(GetArticle),
new { id = createdArticle.IdArticle }, createdArticle));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError,
"Error creating new article record"));
}
}
public override async Task <UpdateArticleRequest> HandleAsync(UpdateArticleRequest command, CancellationToken cancellationToken = new CancellationToken())
{
var result = await _articleRepository.GetArticleById(command.LibraryId, command.PeriodicalId, command.VolumeNumber, command.IssueNumber, command.ArticleId, cancellationToken);
if (result == null)
{
var article = command.Article;
article.Id = default(int);
command.Result.Article = await _articleRepository.AddArticle(command.LibraryId, command.PeriodicalId, result.Id, article, cancellationToken);
command.Result.HasAddedNew = true;
}
else
{
await _articleRepository.UpdateArticle(command.LibraryId, command.PeriodicalId, command.VolumeNumber, command.IssueNumber, command.Article, cancellationToken);
command.Result.Article = command.Article;
}
return(await base.HandleAsync(command, cancellationToken));
}
public async Task <IActionResult> ArticlePost([FromBody] ArticleViewModel articleVm)
{
var contct = new Article();
var dr = await _articleRepository.GetArticlesByCatSect(articleVm.articleCategoryID, articleVm.SectionID);
if (dr == null)
{
throw new AppException(" invalid article ");
}
if (dr.Count() > 7)
{
throw new AppException("There is too many articles in this section already Delete some");
}
else
{
try
{
var dr2 = await _articleRepository.GetALL();
if (dr2.Any(a => a.Title.Equals(articleVm.Title, StringComparison.InvariantCultureIgnoreCase)))
{
throw new AppException("There is already an articles with the Title" + " " + contct.Title + " " + "Please change the title as two articles cannot have the same title");
}
contct.AddToArticle(articleVm);
await _articleRepository.AddArticle(contct);
return(Ok("Success"));
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
}
public async Task <IActionResult> AddArticle([FromForm] Article article)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (article.Image != null && article.Image.ContentType.Contains("image") && article.Image.Length < fileSize)
{
var image = await photoRepo.AddPhoto(article.Image);
article.PhotoId = image.PhotoId;
}
await repo.AddArticle(article);
return(new CreatedAtRouteResult(nameof(GetArticle), new { id = article.AuthorId }, article));
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, $"Error: {e.Message}"));
}
}
public async Task <int> Post([FromBody] Article article)
{
return(await _articleRepository.AddArticle(article));
}
public void AddArticle(Article article)
{
_repository.AddArticle(article);
}
public void Add(Article article)
{
_articleRepository.AddArticle(article);
}
/// <summary>
/// 增加文章
/// </summary>
/// <param name="articleModel"></param>
/// <returns></returns>
public long AddArticle(ArticleModel articleModel)
{
return(_articleRepository.AddArticle(articleModel));
}
