public virtual async ValueTask <IActionResult> Post([FromBody] TV model)
{
if (ModelState.IsValid)
{
(bool succeeded, T t, string error) = await _repo.Add(_mapper.Map <TV, T>(model));
if (succeeded)
{
return(Ok(_mapper.Map <T, TD>(t)));
}
return(BadRequest(new { Message = error }));
}
return(BadRequest(new { Errors = ModelState.Values.SelectMany(e => e.Errors).ToList() }));
}
public async ValueTask <IActionResult> Post([FromBody] CategoryBase model)
{
if (ModelState.IsValid)
{
var checker = await _repo.Item().Where(c => c.Name.Equals(model.Name, StringComparison.OrdinalIgnoreCase)).FirstOrDefaultAsync();
if (checker != null)
{
return(BadRequest(new ErrorDTO {
Message = "Category already exists"
}));
}
Category category = model.Convert <CategoryBase, Category>(_mapper);
(bool succeeded, Category addedCategory, string error) = await _repo.Add(category);
if (succeeded)
{
return(Ok(addedCategory.Convert <Category, CategoryBase>(_mapper)));
}
return(BadRequest(new ErrorDTO {
Message = error
}));
}
return(BadRequest(new ErrorDTO {
Errors = ModelState.Values.SelectMany(e => e.Errors).ToList()
}));
}
public async ValueTask <IActionResult> Post([FromBody] ContractorBase model)
{
if (ModelState.IsValid)
{
var checker = await _repo.Item().Where(c => c.PM == model.PM && c.Organization == model.Organization).FirstOrDefaultAsync();
if (checker != null)
{
return(BadRequest(new ErrorDTO {
Message = "Contractor already exists"
}));
}
Contractor contractor = model.Convert <ContractorBase, Contractor>(_mapper);;
(bool succeeded, Contractor addedContractor, string error) = await _repo.Add(contractor);
if (succeeded)
{
return(Ok(addedContractor.Convert <Contractor, ContractorBase>(_mapper)));
}
return(BadRequest(new ErrorDTO {
Message = error
}));
}
return(BadRequest(new ErrorDTO {
Errors = ModelState.Values.SelectMany(e => e.Errors).ToList()
}));
}
public async ValueTask <IActionResult> Post([FromBody] BaseCheck model)
{
if (ModelState.IsValid)
{
var checker = await _repo.Item().Where(c => c.Name == model.Name && c.CategoryId == model.CategoryId).FirstOrDefaultAsync();
if (checker != null)
{
return(BadRequest(new ErrorDTO {
Message = "Check already exists"
}));
}
Check check = model.Convert <BaseCheck, Check>(_mapper);
(bool succeeded, Check addedCheck, string error) = await _repo.Add(check);
if (succeeded)
{
return(Ok(addedCheck.Convert <Check, BaseCheck>(_mapper)));
}
return(BadRequest(new ErrorDTO {
Message = error
}));
}
return(BadRequest(new ErrorDTO {
Errors = ModelState.Values.SelectMany(e => e.Errors).ToList()
}));
}
public async ValueTask <IActionResult> Post([FromBody] SponsorBase model)
{
if (ModelState.IsValid)
{
var checker = await _repo.Item().Where(c => c.Name == model.Name).FirstOrDefaultAsync();
if (checker != null)
{
return(BadRequest(new ErrorDTO {
Message = "Sponsor already exists"
}));
}
Sponsor sponsor = model.Convert <SponsorBase, Sponsor>(_mapper);
(bool succeeded, Sponsor addedSponsor, string error) = await _repo.Add(sponsor);
if (succeeded)
{
return(Ok(addedSponsor.Convert <Sponsor, SponsorBase>(_mapper)));
}
return(BadRequest(new ErrorDTO {
Message = error
}));
}
return(BadRequest(new ErrorDTO {
Errors = ModelState.Values.SelectMany(e => e.Errors).ToList()
}));
}
public async ValueTask <IActionResult> Post([FromBody] Option model, bool isCorrect)
{
if (ModelState.IsValid)
{
(bool succeeded, Option option, string error) = await _repo.Add(model);
if (succeeded)
{
if (isCorrect)
{
try
{
var quiz = await _quiz.FindOne(c => c.Id == model.PracticeId && !c.Deleted);
quiz.AnswerId = option.Id;
var _ = await _quiz.Update(quiz);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
return(Ok(option));
}
return(BadRequest(new { Message = error }));
}
return(BadRequest(new { Errors = ModelState.Values.SelectMany(e => e.Errors).ToList() }));
}
public ActionResult Create([Bind(Include = "Id,Name,CategoryId,ManufacturerId")] Model model)
{
if (ModelState.IsValid)
{
_modelManager.Add(model);
return(RedirectToAction("Index"));
}
ViewBag.CategoryId = new SelectList(_modelManager.GetCategories(), "Id", "Name");
ViewBag.ManufacturerId = new SelectList(_modelManager.GetManufacturer(), "Id", "Name");
return(View(model));
}
public async ValueTask <IActionResult> Post([FromBody] Donation model)
{
if (ModelState.IsValid)
{
(bool succeeded, Donation addedDonation, string error) = await _repo.Add(model);
if (succeeded)
{
return(Ok(addedDonation));
}
return(BadRequest(new { Message = error }));
}
return(BadRequest(new { Errors = ModelState.Values.SelectMany(e => e.Errors).ToList() }));
}
public async ValueTask <IActionResult> Post([FromBody] QuizViewModel model)
{
if (ModelState.IsValid)
{
(bool succeeded, Quiz quiz, string error) = await _repo.Add(_mapper.Map <QuizViewModel, Quiz>(model));
if (succeeded)
{
return(Ok(quiz));
}
return(BadRequest(new { Message = error }));
}
return(BadRequest(new { Errors = ModelState.Values.SelectMany(e => e.Errors).ToList() }));
}
public async ValueTask <IActionResult> Post([FromBody] News model)
{
if (ModelState.IsValid)
{
model.DatePosted = DateTime.Now;
(bool succeeded, News addedNews, string error) = await _repo.Add(model);
if (succeeded)
{
return(Ok(addedNews));
}
return(BadRequest(new { Message = error }));
}
return(BadRequest(new { Errors = ModelState.Values.SelectMany(e => e.Errors).ToList() }));
}
public async ValueTask <IActionResult> Post([FromBody] ConfessionViewModel model)
{
if (ModelState.IsValid)
{
Confession confession = model.Convert <ConfessionViewModel, Confession>(_mapper);
(bool succeeded, Confession addedConfession, string error) = await _repo.Add(confession);
if (succeeded)
{
return(Ok(addedConfession));
}
return(BadRequest(new { Message = error }));
}
return(BadRequest(new { Errors = ModelState.Values.SelectMany(e => e.Errors).ToList() }));
}
public async ValueTask <IActionResult> Post([FromBody] ParishViewModel model)
{
if (ModelState.IsValid)
{
Parish parish = model.Convert <ParishViewModel, Parish>(_mapper);
(bool succeeded, Parish addedParish, string error) = await _repo.Add(parish);
if (succeeded)
{
return(await Get(addedParish.Id));
}
return(BadRequest(new { Message = error }));
}
return(BadRequest(new { Errors = ModelState.Values.SelectMany(e => e.Errors).ToList() }));
}
public async ValueTask <IActionResult> Post([FromBody] MassViewModel model)
{
if (ModelState.IsValid)
{
Mass mass = model.Convert <MassViewModel, Mass>(_mapper);
(bool succeeded, Mass addedMass, string error) = await _repo.Add(mass);
if (succeeded)
{
return(Ok(addedMass));
}
return(BadRequest(new { Message = error }));
}
return(BadRequest(new { Errors = ModelState.Values.SelectMany(e => e.Errors).ToList() }));
}
public async ValueTask <IActionResult> Post([FromBody] DeaneryViewModel model)
{
if (ModelState.IsValid)
{
Deanery deanery = model.Convert <DeaneryViewModel, Deanery>(_mapper);
(bool succeeded, Deanery addedDeanery, string error) = await _repo.Add(deanery);
if (succeeded)
{
return(await Get(addedDeanery.Id));
}
return(BadRequest(new { Message = error }));
}
return(BadRequest(new { Errors = ModelState.Values.SelectMany(e => e.Errors).ToList() }));
}
public async ValueTask <IActionResult> Post([FromBody] DonorCreateViewModel model)
{
if (ModelState.IsValid)
{
Donor donor = model.Convert <DonorCreateViewModel, Donor>(_mapper);
donor.DateDonated = DateTime.Now;
(bool succeeded, Donor addedDonor, string error) = await _repo.Add(donor);
if (succeeded)
{
return(Ok(addedDonor));
}
return(BadRequest(new { Message = error }));
}
return(BadRequest(new { Errors = ModelState.Values.SelectMany(e => e.Errors).ToList() }));
}
public async ValueTask <IActionResult> Post([FromBody] CommentViewModel model)
{
if (ModelState.IsValid)
{
Comment comment = model.Convert <CommentViewModel, Comment>(_mapper);
comment.DatePosted = DateTime.Now;
(bool succeeded, Comment addedComment, string error) = await _repo.Add(comment);
if (succeeded)
{
return(Ok(addedComment.Convert(_mapper)));
}
return(BadRequest(new ErrorDTO {
Message = error
}));
}
return(base.BadRequest(ShowError()));
}
public async ValueTask <IActionResult> Post([FromBody] UserCheckBase model)
{
if (ModelState.IsValid)
{
UserCheckList userCheck = model.Convert <UserCheckBase, UserCheckList>(_mapper);
(bool succeeded, UserCheckList addedUserCheck, string error) = await _repo.Add(userCheck);
if (succeeded)
{
return(Ok(addedUserCheck.Convert <UserCheckList, UserCheckBase>(_mapper)));
}
return(BadRequest(new ErrorDTO {
Message = error
}));
}
return(BadRequest(new ErrorDTO {
Errors = ModelState.Values.SelectMany(e => e.Errors).ToList()
}));
}
public async ValueTask <IActionResult> Post([FromBody] ProjectViewModel model)
{
if (ModelState.IsValid)
{
Project project = model.Convert <ProjectViewModel, Project>(_mapper);
project.Slug = $"{project.Title.Trim().Replace(" ", "-")}-{DateTime.Now.ToString("MM-dd-yyyy")}";
(bool succeeded, Project addedProject, string error) = await _repo.Add(project);
if (succeeded)
{
return(Ok(addedProject.ConvertToBaseOnly(_mapper)));
}
return(BadRequest(new ErrorDTO {
Message = error
}));
}
return(BadRequest(new ErrorDTO {
Errors = ModelState.Values.SelectMany(e => e.Errors).ToList()
}));
}
private async Task AddUserCoursesAsync(int uid)
{
string cca = "CREATIVE AND CULTURAL ART";
string jmaths = "Mathematics";
string fmaths = "Further Mathematics";
string chemistry = "Chemistry";
var getDefaultUserCourses = await _course.Item()
.Where(c => c.Name.ToLower() == cca.ToLower() ||
(c.Name.ToLower() == jmaths.ToLower() && c.StudyLevel == StudyLevel.Junior) ||
c.Name.ToLower() == fmaths.ToLower() ||
c.Name.ToLower() == chemistry.ToLower())
.Select(c => new { c.Id })
.ToListAsync();
var userCoursesToAdd = getDefaultUserCourses
.Select(gd => new UserCourse {
CourseId = gd.Id, UserId = uid
}).ToList();
var _ = await _usercourse.Add(userCoursesToAdd);
}
public ActionResult Create(Model model)
{
ViewBag.ManufacturerList = GetManufacturers();
ViewBag.CategoryList = GetCategories();
if (ModelState.IsValid && model != null)
{
ModelState.Clear();
try
{
var modelList = _modelManager.GetAll(c => true);
int modelExist = modelList
.Where(c => c.ManufacuturerId == model.ManufacuturerId)
.Where(c => c.CategoryId == model.CategoryId)
.Where(c => c.Name == model.Name)
.Count();
if (modelExist > 0)
{
model.Name = null;
ModelState.AddModelError("Name",
"Model already exists.");
}
else
{
if (_modelManager.Add(model))
{
ViewBag.Msg = "model added successfully!";
return(View());
}
}
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
}
return(View(model));
}
public async ValueTask <IActionResult> Post([FromBody] ImageVM modelVm)
{
if (ModelState.IsValid)
{
var model = _mapper.Map <ImageVM, Image>(modelVm);
(bool succeeded, Image img, string error) = await _repo.Add(model);
if (succeeded)
{
if (modelVm.SuggestedTags != null && modelVm.SuggestedTags.Length > 0)
{
var stags = modelVm.SuggestedTags.Select(st => st.ToLower());
var checkTags = _tag.Item().Where(t => stags.Contains(t.Name.ToLower())).Select(i => i).ToList();
var noTags = modelVm.SuggestedTags.Where(st => !checkTags.Any(ct => ct.Name.ToLower() == st.ToLower()));
var newTags = noTags.Select(tag => new Tag {
Name = tag
});
if (newTags.Count() > 0)
{
var(tagSucceeded, _, tagError) = await _tag.Add(newTags);
if (tagSucceeded)
{
var newTagNames = newTags.Select(n => n.Name.ToLower());
var tags = await _tag.Item().Where(n => newTagNames.Contains(n.Name.ToLower())).ToListAsync();
checkTags.AddRange(tags);
}
}
var imageTags = checkTags.Select(ct => new ImageTag {
ImageId = img.Id, TagId = ct.Id
});
var _ = await _imgTag.Add(imageTags);
}
return(Ok(img));
}
return(BadRequest(new { Message = error }));
}
return(BadRequest(new { Errors = ModelState.Values.SelectMany(e => e.Errors).ToList() }));
}
