public async Task <IActionResult> Add(AddArticleViewModel model)
{
if (!string.IsNullOrWhiteSpace(model.Title) && await articleService.ExistsAsync(model.Title))
{
ModelState.AddModelError(nameof(model.Title),
"Article with the same title already exists.");
}
if (!await destinationService.ExistsAsync(model.DestinationId))
{
ModelState.AddModelError(nameof(model.DestinationId), "Selected destination does not exist.");
}
if (!ModelState.IsValid)
{
model.Destinations = await GetDestinations();
return(View(model));
}
var authorId = userManager.GetUserId(User);
await articleService.AddAsync(
model.Title,
model.Content,
model.DestinationId,
authorId,
DateTime.UtcNow);
return(RedirectToAction(nameof(Add)));
}
public IActionResult AddArticle([FromForm] AddArticleViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var authorExists = authorService.VerifyIfAuthorExistsByEmail(model.Email);
if (authorExists)
{
MatchCollection extractedHashtags = tagService.FilterHashtags(model.Tags);
tagService.AddTags(extractedHashtags);
string imageUploadDirectory = Path.Combine(webHostEnvironment.WebRootPath, "ArticleImages");
articleService.AddArticle(model.Title, model.Content, model.Email, model.Image, imageUploadDirectory);
var recentlyCreatedArticle = articleService.GetNewestAddedArticle(model.Title, model.Content, model.Email);
foreach (var hashtag in extractedHashtags)
{
var tag = tagService.GetTagByName(hashtag.ToString());
articleTagsService.Add(tag, recentlyCreatedArticle);
}
}
var newestArticle = articleService.GetNewestAddedArticle(model.Title, model.Content, model.Email);
return(Redirect(Url.Action("ViewArticle", "Article", new { id = newestArticle.Id })));
}
public async Task <IActionResult> AddArticle(int articleId)
{
AddArticleViewModel addArticleViewModel = new AddArticleViewModel();
var categories = await _categoryManager.GetAllEntities().ToListAsync();
for (int i = 0; i < categories.Count; i++)
{
addArticleViewModel.CategoryViews.Add(new CategoryViewModel
{
CategoryName = categories[i].CategoryName,
ParentCategoryName = categories[i].ParentCategoryName,
Id = categories[i].Id
});
}
if (articleId == 0)
{
return(View("AddArticle", addArticleViewModel));
}
var article = _articleManager.LoadEntities(x => x.Id == articleId).FirstOrDefault();
if (article != null)
{
addArticleViewModel.Author = article.Author;
addArticleViewModel.content = article.Content;
addArticleViewModel.newsImg = article.ImageUrl;
addArticleViewModel.description = article.description;
addArticleViewModel.newsTop = article.IsTop.ToString();
addArticleViewModel.classify = article.Category;
addArticleViewModel.newsTime = article.AddTime;
addArticleViewModel.newsName = article.Title;
addArticleViewModel.articleId = article.Id.ToString();
addArticleViewModel.isTop = article.IsTop;
}
return(View("AddArticle", addArticleViewModel));
}
public ActionResult Add(AddArticleViewModel article)
{
if (article != null && ModelState.IsValid)
{
var dbArticle = Mapper.Map <Article>(article);
dbArticle.Author = this.UserProfile;
if (article.UploadedImage != null)
{
using (var memory = new MemoryStream())
{
article.UploadedImage.InputStream.CopyTo(memory);
var content = memory.GetBuffer();
dbArticle.Image = new Image
{ //TODO Fix the picture content(showing <Binary data>) in the DB
Content = content,
FileExtension = article.UploadedImage.FileName.Split(new[] { '.' }).Last()
};
}
}
this.Data.Articles.Add(dbArticle);
this.Data.SaveChanges();
return(RedirectToAction("All", "Articles"));
}
article.Categories = this.populator.GetCategories();
return(View(article));
}
public Article createArticle(AddArticleViewModel _article)
{
string[] tagArray = _article.Tags.Split('#').ToArray();
List <Tag> Tags = new List <Tag>();
Article newArticle = new Article
{
Title = _article.Title,
Text = _article.Text,
Published = DateTime.UtcNow
};
foreach (string tag in tagArray.Where(x => x != String.Empty))
{
Tags.Add(new Tag {
Name = tag, Articles = new List <Article> {
newArticle
}
});
}
newArticle.Tags = Tags;
return(newArticle);
}
public ActionResult AddArticle()
{
var teamsDb = this.teamService.GetAll();
var championshipsDb = this.championshipService.GetAll();
var teams = new List <SelectListItem>();
var championships = new List <SelectListItem>();
foreach (var team in teamsDb)
{
teams.Add(new SelectListItem()
{
Value = team.Id.ToString(),
Text = team.Name
});
}
foreach (var championship in championshipsDb)
{
championships.Add(new SelectListItem()
{
Text = championship.Name,
Value = championship.Id.ToString()
});
}
var viewModel = new AddArticleViewModel()
{
Championships = championships,
Teams = teams
};
return(this.View(viewModel));
}
public virtual async Task <ActionResult> Create(AddArticleViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(new JsonNetResult
{
Data = new
{
success = false,
View = this.RenderPartialViewToString(MVC.Article.Views._Create, viewModel)
}
});
}
viewModel.Brief = viewModel.Brief.ToSafeHtml();
viewModel.Content = viewModel.Content.ToSafeHtml();
var newArticle = await _articleService.Create(viewModel);
return(new JsonNetResult
{
Data = new
{
success = true,
View = this.RenderPartialViewToString(MVC.Article.Views._ArticleItem, newArticle)
}
});
}
public async Task <int> AddArticleAsync(AddArticleViewModel inputModel)
{
Article articleToAdd = mapper.Map <Article>(inputModel);
if (inputModel.Image != null)
{
if (inputModel.Image.ContentType.ToLower().Contains("image") && inputModel.Image.Length <= maxImageSize)
{
using (System.IO.Stream imageFileStream = inputModel.Image.OpenReadStream())
{
string imageUrl = await imagesService.UploadImageAsync(imageFileStream);
articleToAdd.Image = new Image {
Url = imageUrl
};
}
}
}
articleToAdd.AddedOn = DateTime.UtcNow;
dbContext.Articles.Add(articleToAdd);
await dbContext.SaveChangesAsync();
return(articleToAdd.Id);
}
public ActionResult Add()
{
AddArticleViewModel aavm = new AddArticleViewModel();
aavm.SideBarData = new SideBarViewModel();
aavm.SideBarData.CurrentIndex = 1;
aavm.CreateDate = DateTime.Now;
try
{
if (HttpContext.Session["Mail"].ToString() == null || HttpContext.Session["Mail"].ToString() != "*****@*****.**")
{
Response.Redirect("~");
}
}
catch (Exception ex)
{
Response.Write(ex.ToString());
Response.Redirect("~");
}
if (HttpContext.Session["User"] != null && Session["User"].ToString() != "")
{
aavm.NavStatusData = new NavStatusViewModel();
aavm.NavStatusData.LeftLink = "/User/Profile/" + HttpContext.Session["User"].ToString();
aavm.NavStatusData.LeftText = Session["User"].ToString();
aavm.NavStatusData.RightLink = "/User/Logout";
aavm.NavStatusData.RightText = "Log out";
}
return(View("Add", aavm));
}
public ActionResult CreateArticle(AddArticleViewModel model)
{
string filePath = ArticlesFileLocation + model.Title.Replace(' ', '-');
string userId = this.userProvider.UserId;
var user = this.userService.GetUserById(userId);
model.CreatorId = userId;
model.CreatorUsername = this.userProvider.Username;
model.CreatedOn = DateTime.Now;
model.ImagePath = this.fileProvider.SavePhotoToFileSystem(DefaultArticlePhoto, filePath);
if (!this.ModelState.IsValid)
{
model.Countries = this.GetAllCountries();
return(this.View(model));
}
var article = this.mappingService.Map <AddArticleViewModel, Article>(model);
article.Creator = user;
this.articleService.AddArticle(article);
return(this.Redirect(ArticleRedirect + article.Id));
}
public ActionResult ArticleSubmit(AddArticleViewModel addarticleViewModel, HttpPostedFileBase banner, int UserID)
{
var MaxId = articleManage.ArticleId(p => p.ID);
var articleID = MaxId + 1;
if (banner != null)
{
var bannerName = Path.Combine(Request.MapPath("/ArticleImg"), articleID + ".jpg");
if (System.IO.File.Exists(bannerName))
{
System.IO.File.Delete(bannerName);
}
banner.SaveAs(bannerName);
}
if (ModelState.IsValid)
{
Article article = new Article();
article.MovieID = addarticleViewModel.MovieID;
article.Title = addarticleViewModel.Title;
article.UserID = UserID;
article.Content = addarticleViewModel.Content;
article.Releasetime = DateTime.Now;
article.Auditstatus = Article.Status.待审核;
var _resp = articleManage.Add(article);
return(RedirectToAction("Index", "User"));
}
else
{
return(View(addarticleViewModel));
}
}
public RedirectResult AddArticle(AddArticleViewModel model, HttpPostedFileBase Photo)
{
string FolderPath = null;
if (Photo != null)
{
string ImageFileName = Path.GetFileName(Photo.FileName);
FolderPath = Path.Combine(Server.MapPath("~/Content/ArticlePictures/"), ImageFileName);
Photo.SaveAs(FolderPath);
}
Article article = new Article()
{
Name = model.Name,
Tags = model.Tags,
FullDescription = model.FullDescription,
Category = model.Category,
ShortDescription = model.ShortDescription
};
article.ImagePath = FolderPath;
article.Time = DateTime.Now;
article.UserMail = User.Identity.Name;
db.Articles.Add(article);
db.SaveChanges();
return(YourArticle(article));
}
public ActionResult CreateArticle()
{
AddArticleViewModel model = new AddArticleViewModel();
model.Countries = this.GetAllCountries();
return(this.View(model));
}
public ActionResult AddArticle()
{
AddArticleViewModel a = new AddArticleViewModel();
BlogContext blogContext = DbLogic.GetDB();
a.CategoryList = DbLogic.GetCategories(blogContext);
a.TagsList = DbLogic.GetTags(blogContext).ToList <Tag>();
return(View(a));
}
public ActionResult Add()
{
var addArticleViewModel = new AddArticleViewModel
{
Categories = this.populator.GetCategories()
};
return(View(addArticleViewModel));
}
public virtual ActionResult Create(Guid applicantId)
{
var viewModel = new AddArticleViewModel
{
ApplicantId = applicantId
};
return(PartialView(MVC.Article.Views._Create, viewModel));
}
public IActionResult AddArticle()
{
var model = new AddArticleViewModel
{
Categories = LoadCategories(),
Author = LoadAdmins()
};
return(View(model));
}
public async Task <IActionResult> Add()
{
var vm = new AddArticleViewModel
{
Categories = await GetUICategories(),
AuthorId = await userService.GetCurrentUserId()
};
return(View(vm));
}
public async Task <IActionResult> AddArticle(AddArticleViewModel model)
{
var article = new Article(model.Title, model.Content, model.Author);
await articleRepository.AddArticleAsync(article);
var searchModel = mapper.Map <SearchEngine.SearchModels.Article>(article);
var indexResponse = await elasticClient.IndexDocumentAsync(searchModel);
return(Ok());
}
public ActionResult AddArticle()
{
AddArticleViewModel avm = new AddArticleViewModel()
{
MaxCoAuthors = 7,
CoAuthorsCounter = 2,
ArticleName = null
};
return(View(avm));
}
public async Task <IActionResult> AddArticle([FromBody] AddArticleViewModel addArticleViewModel)
{
if (addArticleViewModel == null)
{
return(Json("失败"));
}
Article article;
if (addArticleViewModel.articleId == "")
{
var author = await _userManager.FindByNameAsync(addArticleViewModel.authorName);
if (author != null)
{
article = new Article
{
Title = addArticleViewModel.newsName,
AddTime = addArticleViewModel.newsTime,
Content = addArticleViewModel.content,
description = addArticleViewModel.description,
Category = addArticleViewModel.classify,
IsTop = addArticleViewModel.newsTop == "true" ? true : false,
ImageUrl = addArticleViewModel.newsImg,
UserId = author.Id,
Author = author,
Sort = "置顶",
CategoryId = 2,
};
_articleManager.AddEntity(article);
return(Json("添加成功"));
}
}
else
{
article = _articleManager.LoadEntities(x => x.Id == Convert.ToInt32(addArticleViewModel.articleId)).FirstOrDefault();
if (article == null)
{
return(Json("失败"));
}
article.Title = addArticleViewModel.newsName;
article.Content = addArticleViewModel.content;
article.description = addArticleViewModel.description;
article.Category = addArticleViewModel.classify;
article.IsTop = addArticleViewModel.newsTop == "true" ? true : false;
article.ImageUrl = addArticleViewModel.newsImg;
var result = _articleManager.EditEntity(article);
if (result)
{
return(Json("修改成功"));
}
}
return(Json("失败"));
}
public async Task <IActionResult> AddNewDraft(AddArticleViewModel model)
{
if (ModelState.IsValid)
{
var userId = httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
ViewBag.ArticleCategories = editorService.GetUserCategories(httpContextAccessor);
model.CreatorId = userId;
editorService.AddNewDraft(model);
return(RedirectToAction("AllDrafts"));
}
return(View(model));
}
public ActionResult AddArticle(AddArticleViewModel article)
{
if (!ModelState.IsValid)
{
GetArticlesAndTags();
return(View(article));
}
var articleImages = new List <ArticleImages>();
foreach (var image in article.Images)
{
if (image != null)
{
string imagePath = Guid.NewGuid().ToString().Substring(0, 10) + "_" + System.IO.Path.GetFileName(image.FileName);
articleImages.Add(new ArticleImages {
ImagePath = imagePath
});
WebImage img = new WebImage(image.InputStream);
img.Resize(1600, 600);
img.Save(Server.MapPath("~/Content/images/articles/" + imagePath));
}
}
using (var context = new DataContext())
{
var articleSave = new Article
{
Title = article.Title,
Slug = article.Title.GenerateSlug(),
Description = article.Description,
Text = article.Text,
Create = DateTime.Now,
ArticleImages = articleImages,
ArticleTags = article.ArticleTags != null?context.ArticleTags.Where(a => article.ArticleTags.Contains(a.Id)).ToList() : null
};
if (article.SimilarArticles != null && article.SimilarArticles.Count() > 0)
{
foreach (var similar in article.SimilarArticles)
{
context.SimilarArticles.Add(new SimilarArticle {
Article = articleSave, SimilarArticleId = similar
});
}
}
context.Articles.Add(articleSave);
context.SaveChanges();
}
return(Redirect("/admin/articles"));
}
public ActionResult AddArticle(AddArticleViewModel _article)
{
if (repository.GetArticles().Any(a => a.Title == _article.Title))
{
ViewBag.Message = "Error: Article with such name has been added";
}
else
{
repository.AddArticle(manager.createArticle(_article));
}
return(View("Index", manager.GetMostPopularTags()));
}
public string AddArticles(AddArticleViewModel addarticles)
{
AddArticleViewModel ad = new AddArticleViewModel();
addarticles.Name = ad.Name;
addarticles.Faculty = ad.Faculty;
addarticles.Title = ad.Title;
addarticles.Description = ad.Description;
addarticles.Document = ad.Document;
addarticles.Image = ad.Image;
return(AddArticles(ad));
}
public void AddArticle(string currentUserId, AddArticleViewModel aavm, string fileName, byte[] file)
{
Customer customer = this.Context.Customers.First(c => c.User.Id == currentUserId);
Article article = Mapper.Instance.Map <Article>(aavm);
article.PublishDate = DateTime.Now;
article.Publisher = customer;
string newFileName = new Random().Next() + "_" + fileName;
article.ImageFileName = newFileName;
this.Context.Articles.Add(article);
this.Context.SaveChanges();
Upload(new DropboxClient("mQ4aAGajcfAAAAAAAAAAEcVfYBCEdnqccMa1IOiDpmOYVO6GkdprCUTg5p3GWMih"), $"/Articles/{customer.User.UserName}", newFileName, file);
}
public IActionResult AddArticle(AddArticleViewModel model)
{
var article = new Article()
{
ArticleContent = model.ArticleContent,
ArticleTitle = model.ArticleTitle,
AdminId = model.AdminId,
CategoryId = model.CategoryId,
PublishDate = DateTime.Now,
Thumbnail = model.FormFiles.GetBytes(),
Views = model.Views
};
_articleService.Add(article);
return(RedirectToAction("Articles"));
}
public void AddArticle(AddArticleViewModel model)
{
var validator = ValidationFactory.CreateValidator <AddArticleViewModel>("Group1");
ValidationResults results = validator.Validate(model);
if (results.IsValid)
{
var article = new Article
{
Abstract = model.Abstract,
AddedBy = model.AddedBy,
Body = model.Body
};
_articlesRepository.InsertArticle(article);
_unitOfWork.Commit();
}
}
public IActionResult AddArticle(AddArticleViewModel model)
{
try
{
if (ModelState.IsValid)
{
var article = _mapper.Map <Article>(model);
_articlesRepository.InsertArticle(article);
_unitOfWork.Commit();
}
return(RedirectToAction(nameof(this.ManageArticles)));
}
catch
{
return(View());
}
}
public async Task <ActionResult> Add(AddArticleViewModel model)
{
if (ModelState.IsValid)
{
Article article = new Article
{
CategoryId = model.CategoryId,
DatePublication = DateTime.Now,
Title = model.Title,
FullText = model.Fulltext
};
db.Articles.Add(article);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(model));
}
public AddArticleWithReferencesPageViewModel(WizardViewModel parent)
: base(parent)
{
AddArticleDataContext = new AddArticleViewModel(parent);
IEnumerable<Article> articles = CentralRepository.Instance.GetArticles();
ArticlesToChooseFrom = CollectionViewSource.GetDefaultView(articles);
_selectedArticles = new ObservableCollection<Article>();
SelectedArticles = CollectionViewSource.GetDefaultView(_selectedArticles);
MoveReferenceUpCommand = new DelegateCommand(MoveReferenceUp);
MoveReferenceDownCommand = new DelegateCommand(MoveReferenceDown);
RemoveReferenceCommand = new DelegateCommand(RemoveReference);
ShouldExportToInvenio = false;
AddArticleDataContext.EditedArticleChanged += AddArticleDataContext_EditedArticleChanged;
}
private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
_viewModel = (AddArticleViewModel)DataContext;
}