public async Task UpdateAsync(ArticleUpdateViewModel eventVM)
{
var currentArticle = await db.Articles.FindAsync(eventVM.Id).ConfigureAwait(false);
var updateAuthors = currentArticle.Authors.ToList();
// Manager da rimuovere o già presenti
foreach (var a in currentArticle.Authors)
{
var findAuthor = updateAuthors.Find(x => x.Id == a.Id);
if (findAuthor == null)
{
currentArticle.RemoveAuthor(a.Id);
}
else
{
updateAuthors.Remove(findAuthor);
}
}
// Manager da aggiungere
foreach (var a in updateAuthors)
{
var person = await db.People.FindAsync(a.Id).ConfigureAwait(false);
currentArticle.AddAuthor(person.ToOwned());
}
db.Articles.Update(currentArticle);
await db.SaveChangesAsync().ConfigureAwait(false);
}
public async Task <IActionResult> Update(int id, [FromBody] ArticleUpdateViewModel request)
{
if (request == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(new MyUnprocessableEntityObjectResult(ModelState));
}
var article = await _articleRepository.GetArticleByIdAsync(id);
if (article == null)
{
return(NotFound());
}
article.LastModified = DateTime.Now;
_mapper.Map(request, article);
if (!await _unitOfWork.SaveAsync())
{
throw new Exception("Faild");
}
return(NoContent());
}
public async Task <ArticleUpdateViewModel> GetById(string id)
{
var currentArticle = await db.Articles.FindAsync(id).ConfigureAwait(false);
if (currentArticle == null)
{
throw new ArgumentOutOfRangeException($"Community {id} not exists");
}
ArticleUpdateViewModel authorVM = new ArticleUpdateViewModel
{
Name = currentArticle.Name,
Confirmed = currentArticle.Confirmed,
Id = currentArticle.Id,
Url = currentArticle.Url,
PublishDate = currentArticle.PublishDate,
Authors = currentArticle.Authors.Select(t => new PersonUpdateViewModel
{
Id = t.Id,
Name = t.Name,
Surname = t.Surname,
Picture = t.Picture,
MVP_Code = t.MVP_Code
})
};
return(authorVM);
}
public async Task <IActionResult> Update(int id, ArticleUpdateViewModel model)
{
if (ModelState.IsValid)
{
var article = new UpdateArticle
{
Id = id,
Title = model.Title,
Content = model.Content
};
if (model.Picture != null)
{
using (var memoryStream = new MemoryStream())
{
await model.Picture.CopyToAsync(memoryStream);
article.Picture = memoryStream.ToArray();
}
}
var accessToken = HttpContext.User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.UserData)?.Value;
var result = await _articleService.UpdateAsync(accessToken, article);
if (result == SystemResponse.Success)
{
return(RedirectToAction("GetDetails", new { id = id }));
}
}
return(View(model));
}
public async Task <IActionResult> UpdateArticle(ArticleUpdateViewModel articleUpdateViewModel)
{
//Need to move business
var result = await _articleService.GetById(articleUpdateViewModel.Id);
if (result.Data == null)
{
ModelState.AddModelError(string.Empty, "Category is not found.");
return(RedirectToAction("ArticleListView"));
}
var imagePath = Path.Combine(_webHostEnvironment.WebRootPath, "uploads", result.Data.ImageUrl);
if (System.IO.File.Exists(imagePath))
{
System.IO.File.Delete(imagePath);
}
string wwwRootPath = _webHostEnvironment.WebRootPath;
string fileName = Path.GetFileNameWithoutExtension(articleUpdateViewModel.FileImageUrl.FileName);
string extension = Path.GetExtension(articleUpdateViewModel.FileImageUrl.FileName);
string path = Path.Combine(wwwRootPath + "/uploads/", fileName + extension);
using (var fileStream = new FileStream(path, FileMode.Create))
{
await articleUpdateViewModel.FileImageUrl.CopyToAsync(fileStream);
}
result.Data.ImageUrl = articleUpdateViewModel.FileImageUrl.FileName;
//result.Data.ImageUrl = articleUpdateViewModel.ImageUrl;
result.Data.SeoUrl = articleUpdateViewModel.SeoUrl;
result.Data.Body = articleUpdateViewModel.Body;
result.Data.Title = articleUpdateViewModel.Title;
foreach (var item in result.Data.ArticleCategoryRelations)
{
item.IsDeleted = true;
item.DeletedDate = DateTime.Now;
}
result.Data.ArticleCategoryRelations.Add(new ArticleCategoryRelation
{
CategoryId = articleUpdateViewModel.SelectedCategoryId,
CreatedDate = DateTime.Now,
Id = Guid.NewGuid(),
ArticleId = result.Data.Id
});
await _articleService.Update(result.Data);
return(RedirectToAction("ArticleList"));
}
public async Task <IActionResult> Update(ArticleUpdateViewModel articleUpdateViewModel)
{
if (ModelState.IsValid)
{
bool isNewThumbnailUploaded = false;
var oldThumbnail = articleUpdateViewModel.Thumbnail;
if (articleUpdateViewModel.ThumbnailFile != null)
{
var uploadedImageResult = await ImageHelper.Upload(articleUpdateViewModel.Title,
articleUpdateViewModel.ThumbnailFile, PictureType.Post);
articleUpdateViewModel.Thumbnail = uploadedImageResult.ResultStatus == ResultStatus.Success
? uploadedImageResult.Data.FullName
: "postImages/defaultThumbnail.jpg";
if (oldThumbnail != "postImages/defaultThumbnail.jpg")
{
isNewThumbnailUploaded = true;
}
}
var articleUpdateDto = Mapper.Map <ArticleUpdateDto>(articleUpdateViewModel);
var result = await _articleService.UpdateAsync(articleUpdateDto, LoggedInUser.UserName);
if (result.ResultStatus == ResultStatus.Success)
{
if (isNewThumbnailUploaded)
{
ImageHelper.Delete(oldThumbnail);
}
_toastNotification.AddSuccessToastMessage(result.Message, new ToastrOptions
{
Title = "Başarılı İşlem"
});
return(RedirectToAction("Index", "Article"));
}
else
{
ModelState.AddModelError(" ", result.Message);
}
}
var categories = await _categoryService.GetAllByNoneDeletedAndActiveAsync();
articleUpdateViewModel.Categories = categories.Data.Categories;
return(View(articleUpdateViewModel));
}
public async Task <string> RunOrchestrator(
[OrchestrationTrigger] IDurableOrchestrationContext context)
{
var vm = context.GetInput <ArticleViewModel>();
string id = await context.CallActivityAsync <string>(ConfirmationTask.CreateArticle, vm);
var vmUpdate = ArticleUpdateViewModel.Create(vm);
vmUpdate.Id = id;
var activateSendMail = new ActivateArticleSendMail {
Data = vmUpdate, InstanceId = context.InstanceId
};
await context.CallActivityAsync(ConfirmationTask.SendMailArticle, activateSendMail);
await HumanInteractionArticle(context, vmUpdate);
return(id);
}
public async Task <IActionResult> Update(int id)
{
var result = await _articleService.GetByIdAsync(id);
if (result == null)
{
return(View());
}
var article = new ArticleUpdateViewModel
{
Id = result.Id,
Title = result.Title,
Content = result.Content
};
return(View(article));
}
public IActionResult UpdateArticle(ArticleUpdateViewModel article)
{
var dbArticle = _db.Articles.Find(article.Id);
if (article.Description != dbArticle.Description)
{
dbArticle.Description = article.Description;
}
if (article.Name != dbArticle.Name)
{
dbArticle.Name = article.Name;
}
if (article.Theme != dbArticle.Theme)
{
dbArticle.Theme = article.Theme;
}
dbArticle.Date = DateTime.Now;
_db.SaveChanges();
ViewBag.List = Theme.ListOfTheme;
return(View(dbArticle));
}
public async Task <bool> HumanInteractionArticle(IDurableOrchestrationContext context, ArticleUpdateViewModel vm)
{
using (var timeoutCts = new CancellationTokenSource())
{
DateTime expiration = context.CurrentUtcDateTime.AddDays(6);
Task timeoutTask = context.CreateTimer(expiration, timeoutCts.Token);
bool authorized = false;
for (int retryCount = 0; retryCount <= 3; retryCount++)
{
Task <bool> challengeResponseTask = context.WaitForExternalEvent <bool>(ConfirmationTask.ConfirmArticleHuman);
Task winner = await Task.WhenAny(challengeResponseTask, timeoutTask);
if (winner == challengeResponseTask)
{
// We got back a response! Compare it to the challenge code.
if (challengeResponseTask.Result)
{
vm.Confirmed = challengeResponseTask.Result;
await context.CallActivityAsync(ConfirmationTask.ApproveCancelArticleOnCosmos, vm);
break;
}
}
else
{
// Timeout expired
break;
}
}
if (!timeoutTask.IsCompleted)
{
// All pending timers must be complete or canceled before the function exits.
timeoutCts.Cancel();
}
return(authorized);
}
}
public async Task ApproveCancelArticleOnCosmos([ActivityTrigger] ArticleUpdateViewModel vm, ILogger log)
{
await articleService.UpdateAsync(vm).ConfigureAwait(false);
}
