public async Task <IActionResult> Index([Bind("Title,Body")] PostValidation post)
{
if (ModelState.IsValid)
{
post.UserId = _homePageHelper.UserId;
post.Id = _homePageHelper.SelectedPostId;
var json = JsonSerializer.Serialize(post);
using (HttpResponseMessage response = await _httpClass.ApiClient.PostAsJsonAsync("api/posts/updatepost", json))
{
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("Index", "Home", new { userId = _userId }));
}
else
{
Console.WriteLine(response.ReasonPhrase);
return(RedirectToAction("Index", "PostDetails", new
{
id = post.Id,
userId = _homePageHelper.UserId,
title = post.Title,
body = post.Body,
createdAt = post.CreatedAt
}));
}
}
}
else
{
return(View(post));
}
}
public ResultModel Validate()
{
var validate = new PostValidation().Validate(this);
return(new ResultModel()
{
ResultNo = validate.IsValid ? 1 : 0,
Message = validate.IsValid ? "Success" : string.Join(",", validate.Errors?.Select(x => x.ErrorMessage))
});
}
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
var validDate = PostValidation.PostDateValidation(Date);
if (validDate == false)
{
yield return(new ValidationResult("Enter a valid date",
new[] { nameof(Date) }));
}
yield return(ValidationResult.Success);
}
public void PostDateValidation_ValidDate_ExpectedSuccess()
{
// Arrange
bool result = true;
DateTime testDate = DateTime.Today;
// Act
result = PostValidation.PostDateValidation(testDate);
// Assert
Assert.True(result);
}
public void PostDateValidation_FutureDate_ExpectedFail()
{
// Arrange
bool result = true;
DateTime testDate = DateTime.Now.AddDays(7);
// Act
result = PostValidation.PostDateValidation(testDate);
// Assert
Assert.False(result);
}
public IActionResult RedirectToDetails(int deleteIdx)
{
PostValidation newPost = _homePageHelper.PostList[deleteIdx];
return(RedirectToAction("Index", "PostDetails", new
{
id = newPost.Id,
userId = _homePageHelper.UserId,
title = newPost.Title,
body = newPost.Body,
createdAt = newPost.CreatedAt
}));
}
public IActionResult CreatePost(string title, string description)
{
var post = new Domain.Entities.Post.Post(title, description);
var validationResult = new PostValidation().Validate(post);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
var output = postAddUseCase.Add(post);
return(new OkObjectResult(post));
}
public void Shoud_Not_Add_Post_Without_Author()
{
var post = new Post();
post.Title = "Post Title";
post.Body = "Post body.";
post.IsPublished = true;
var postValidation = new PostValidation();
var postRepository = new FakePostRepository();
var postService = new PostService(postRepository, postValidation);
var result = postService.Add(post);
Assert.IsFalse(result.IsValid);
Assert.IsTrue(result.Errors.Count == 1);
Assert.IsTrue(result.Errors[0].PropertyName == "Author.Id");
}
public void Shoud_Not_Add_Post_Without_Author()
{
var post = new Post();
post.Title = "Post Title";
post.Body = "Post body.";
post.IsPublished = true;
var postValidation = new PostValidation();
var postRepository = new FakePostRepository();
var postService = new PostService(postRepository, postValidation);
var result = postService.Add(post);
Assert.IsFalse(result.IsValid);
Assert.IsTrue(result.Errors.Count == 1);
Assert.IsTrue(result.Errors[0].PropertyName == "Author.Id");
}
/// <summary>
/// Runs the rules.
/// </summary>
/// <param name="usingSession">using session.</param>
/// <param name="inContext">in context.</param>
/// <returns>the currently running task</returns>
public void RunRules(IContainSessionConfiguration usingSession, IContainSessionContext inContext, bool saveResults)
{
using (Timing.BeginScope("This processing run"))
{
if (RequiresReturnPeriod(usingSession, inContext))
{
throw new Exception("Please pick a return period if you wish to run the AEC rulebase");
}
Emitter.Publish("Commencing run...");
var providers = usingSession.InputDataSource.Providers
.Where(x => x.IsSelectedForProcessing);
Monitor.SetProviderCount(providers.Count());
//INTPUT FOR THE REFERECE DATA
PostValidation.TransformInput(inContext, usingSession.InputDataSource.OperatingYear);
providers.ForEach(usingProvider =>
{
Monitor.IncrementPosition();
Monitor.SetLearnerCounts(0, usingProvider.LearnerCount, 0);
var fileName = $"{usingProvider.ID}_{DateTime.Now:yyyyMMdd-HHmmss}.log";
var firstInRun = Monitor.ProviderPosition == 1;
using (Logging.BeginScope(fileName, firstInRun))
{
using (Timing.BeginScope($"This provider '{usingProvider.ID}'", x => GetProcessingAverage(usingProvider.LearnerCount, x)))
{
// start the log
StartLog(usingSession, usingProvider, inContext);
// writes current UKPRN
WriteOutUKPRN(usingProvider.ID, inContext);
// build
PrepareRun(usingSession, inContext, usingProvider.ID, firstInRun);
// validate
RunRulebaseSubset(TypeOfRulebaseOperation.Validation, usingSession.RulesToRun, inContext, usingProvider.ID);
// transform
TransformInput(inContext, usingSession.InputDataSource.OperatingYear, usingProvider);
// calculate
RunRulebaseSubset(TypeOfRulebaseOperation.Calculation, usingSession.RulesToRun, inContext, usingProvider.ID);
// complete
if (saveResults == true)
{
CompleteRun(usingSession, inContext, usingProvider.ID);
}
// report
RunReport(usingSession, inContext);
}
}
});
// reset the badges
Monitor.IncrementPosition();
Monitor.SetLearnerCounts(0, 0, 0);
Monitor.SetCaseCount(null, 0);
}
}
