public async Task <ActionResult <ModuleDTO> > PostModule(ModuleDTO model)
{
try
{
if (model == null)
{
return(BadRequest("No entity provided"));
}
var id = await _crudService.CreateAsync <ModuleDTO, Module>(model);
if (id < 1)
{
return(BadRequest("Unable to add the entity"));
}
var dto = await _crudService.GetSingleAsync <Module, ModuleDTO>(s => s.Id.Equals(id), true);
if (dto == null)
{
return(BadRequest("Cannot create entity"));
}
var uri = _linkGenerator.GetPathByAction("GetSingleModule", "Modules", new { id });
return(Created(uri, dto));
}
catch
{
return(StatusCode(StatusCodes.Status500InternalServerError,
"Server Failure!"));
}
}
public async Task <IActionResult> JobOpportunities(JobApplicationViewModel model)
{
var rechaptchaCheck = await CheckRecaptcha(model.RechaptchaToken);
if (!rechaptchaCheck.success)
{
return(Json(Result.Create(model, "Invalid ReCaptcha", 500)));
}
var mappedModel = _mapper.Map <JobApplication>(model);
var result = Result.Create(mappedModel, 500);
//MvcCaptcha mvcCaptcha = new MvcCaptcha("FormCaptcha");
//string userInput = HttpContext.Request.Form["CaptchaCode"];
//string validatingInstanceId = HttpContext.Request.Form[mvcCaptcha.ValidatingInstanceKey];
//if (mvcCaptcha.Validate(userInput, validatingInstanceId))
//{
// // or you can use static Validate method of MvcCaptcha class (i.e.MvcCaptcha.Validate("FormCaptcha", userInput, validatingInstanceId); )
// MvcCaptcha.ResetCaptcha("FormCaptcha");
//}
//else
//{
// result = Result.Create(mappedModel, "Invalid Captcha", 500);
// return Json(result);
//}
if (ModelState.IsValid)
{
if (Request.Form.Files.Count != 0)
{
mappedModel.ResumePath = SaveFile();
}
result = await _jobApplicationCrudService.CreateAsync(mappedModel);
}
return(Json(result));
}
public async Task <IActionResult> GetLastNewsWithEmail(NewsLetter model)
{
model.CreateDate = DateTime.Now;
var result = await _newsLetterCrudService.CreateAsync(model);
return(Json(result));
}
public async Task <IActionResult> ContactUs(ContactUs model)
{
var result = Result.Create(model, 500);
var rechaptchaCheck = await CheckRecaptcha(Request.Form["RechaptchaToken"]);
if (!rechaptchaCheck.success)
{
return(Json(Result.Create(model, "Invalid ReCaptcha", 500)));
}
//MvcCaptcha mvcCaptcha = new MvcCaptcha("FormCaptcha");
//string userInput = HttpContext.Request.Form["CaptchaCode"];
//string validatingInstanceId = HttpContext.Request.Form[mvcCaptcha.ValidatingInstanceKey];
//if (mvcCaptcha.Validate(userInput, validatingInstanceId))
//{
// // or you can use static Validate method of MvcCaptcha class (i.e.MvcCaptcha.Validate("FormCaptcha", userInput, validatingInstanceId); )
// MvcCaptcha.ResetCaptcha("FormCaptcha");
//}
//else
//{
// result = Result.Create(model, "Invalid Captcha", 500);
// return Json(result);
//}
if (ModelState.IsValid)
{
model.CreateDate = DateTime.Now;
result = await _contactUsCrudService.CreateAsync(model);
}
return(Json(result));
}
public virtual async Task <TDto> CreateAsync(TDto dto)
{
var entity = _mapper.Map <TEntity>(dto);
var createdEntity = await _service.CreateAsync(entity);
await _repository.SaveChangesAsync();
return(_mapper.Map <TDto>(createdEntity));
}
public override async Task <T2> CreateAsync(T2 entity)
{
// create hook when a new entity is created
var createdEntity = await base.CreateAsync(entity);
var createdHook = await _hookService.CreateAsync(new Hook {
Name = "Test1",
URL = "about:blank",
EntityId = createdEntity.Id.ToString(),
EntityName = typeof(T2).FullName
});
return(createdEntity);
}
public async Task <IActionResult> Create(Student student)
{
if (ModelState.IsValid)
{
student = await studentService.CreateAsync(student);
if (student == null)
{
return(RedirectToAction("List"));
}
return(RedirectToAction("View", new { student.Id }));
}
else
{
return(View("Edit", student));
}
}
public async Task <IActionResult> Create(Course course)
{
if (ModelState.IsValid)
{
course = await courseService.CreateAsync(course);
if (course == null)
{
return(RedirectToAction("List"));
}
return(RedirectToAction("View", new { course.Id }));
}
else
{
return(View("Edit", course));
}
}
public async Task <IActionResult> Create(Teacher teacher)
{
if (ModelState.IsValid)
{
teacher = await teacherService.CreateAsync(teacher);
if (teacher == null)
{
return(RedirectToAction("List"));
}
return(RedirectToAction("View", new { teacher.Id }));
}
else
{
return(View("Edit", teacher));
}
}
public async Task <IActionResult> AddEdit(HomeSlide homeSlide)
{
try
{
if (ModelState.IsValid)
{
var _homeSlide = _mapper.Map <HomeSlide>(homeSlide);
var dbSlide = await _homeSlideService.GetAsync(x => x.Id == homeSlide.Id, new string[] { });
if (dbSlide?.Data != null)
{
_homeSlide.CreateDate = dbSlide.Data.CreateDate;
_homeSlide.SlidePath = dbSlide.Data.SlidePath;
}
else
{
_homeSlide.CreateDate = DateTime.Now;
}
if (Request.Form.Files.Count > 0)
{
_homeSlide.SlidePath = SaveFile(_hostingEnvironment.ContentRootPath, "homeSlider");
}
if (homeSlide.Id == 0)
{
homeSlide.UserId = CurrentUser.UserId;
}
var result = _homeSlide.Id == 0
? await _homeSlideService.CreateAsync(homeSlide)
: await _homeSlideService.EditAsync(homeSlide);
return(Json(result));
}
}
catch (Exception ex)
{
return(Json(Result.Create(false, ex.Message, 500)));
}
return(Json(Result.Create(false, 500)));
}
public async Task <ActionResult <DownloadDTO> > PostDownload(DownloadDTO model)
{
try
{
if (model == null)
{
return(BadRequest("No entity provided"));
}
var exist = await _crudService.AnyAsync <Course>(c => c.Id.Equals(model.CourseId));
var exist1 = await _crudService.AnyAsync <Module>(m => m.Id.Equals(model.ModuleId));
if (!exist && !exist1)
{
return(NotFound("Cant find related id in VideoDTO"));
}
var id = await _crudService.CreateAsync <DownloadDTO, Download>(model);
if (id < 1)
{
return(BadRequest("Unable to add the entity"));
}
var Dto = await _crudService.GetSingleAsync <Download, DownloadDTO>(s => s.Id.Equals(id), true);
if (Dto == null)
{
return(BadRequest("Cannot create entity"));
}
var uri = _linkGenerator.GetPathByAction("GetSingleDownload", "Downloads", new { id });
return(Created(uri, Dto));
}
catch
{
return(StatusCode(StatusCodes.Status500InternalServerError,
"Server Failure!"));
}
}
/// <summary>
/// Creates the asynchronous.
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public virtual async Task <T2> CreateAsync(T2 entity)
{
var createdEntity = await _service.CreateAsync(entity);
var historicalEvent = new HistoricalEvent
{
Action = HistoricalActions.Create.ToString(),
Changeset = new HistoricalChangeset()
{
ObjectDelta = new T2().DetailedCompare(entity)
},
EntityId = entity.Id.ToString(),
EntityName = entity.GetType().FullName
};
await _repository.CreateAsync <Guid, HistoricalEvent>(historicalEvent);
await _repository.SaveChangesAsync();
return(createdEntity);
}
public virtual async Task <ActionResult <T2> > Create([FromBody] T2 entity)
{
var createdEntity = await _service.CreateAsync(entity);
return(CreatedAtAction(nameof(GetById), new { id = createdEntity.Id }, createdEntity));
}
public async Task <IActionResult> Create([FromBody] T entity) => Ok(await _service.CreateAsync(entity));
public virtual async Task <ActionResult <int> > PostAsync([FromBody] TDto createModel, CancellationToken cancellationToken = default)
{
var id = await _crudService.CreateAsync(createModel);
return(Ok(id));
}
public async Task <IHttpActionResult> CreateAsync([FromBody] TDto dto) => await ExecuteAsync(async() => await _crudService.CreateAsync(dto));
public virtual async Task <T> CreateAsync(T entity) => await _service.CreateAsync(entity);
public async Task <IActionResult> Post(Order entity)
{
var result = await _service.CreateAsync(entity);
return(CreatedAtRoute("GetOrderRoute", new { id = result.Id }, result));
}
private static async Task CreateTeachers(ICrudService <Teacher> teacherService, UserManager <User> userManager)
{
Teacher Fahim = new Teacher()
{
Name = "Fahim",
Gender = Gender.Male,
YearsTaught = 2,
Status = TeacherStatus.Adjunct
};
await teacherService.CreateAsync(Fahim);
User teacher1 = new User
{
UserName = "******",
Email = "*****@*****.**",
Teacher = Fahim,
EmailConfirmed = true
};
await userManager.CreateAsync(teacher1, "Test1234");
await userManager.AddToRoleAsync(teacher1, "Teacher");
Teacher Beatty = new Teacher()
{
Name = "Beatty",
Gender = Gender.Male,
YearsTaught = 6,
Status = TeacherStatus.FullTime
};
await teacherService.CreateAsync(Beatty);
User teacher2 = new User
{
UserName = "******",
Email = "*****@*****.**",
Teacher = Beatty,
EmailConfirmed = true
};
await userManager.CreateAsync(teacher2, "Test1234");
await userManager.AddToRoleAsync(teacher2, "Teacher");
Teacher Lamb = new Teacher()
{
Name = "Lamb",
Gender = Gender.Male,
YearsTaught = 4,
Status = TeacherStatus.FullTime
};
await teacherService.CreateAsync(Lamb);
User teacher3 = new User
{
UserName = "******",
Email = "*****@*****.**",
Teacher = Lamb,
EmailConfirmed = true
};
await userManager.CreateAsync(teacher3, "Test1234");
await userManager.AddToRoleAsync(teacher3, "Teacher");
Teacher Ray = new Teacher()
{
Name = "Ray",
Gender = Gender.Male,
YearsTaught = 1,
Status = TeacherStatus.FullTime
};
await teacherService.CreateAsync(Ray);
User teacher4 = new User
{
UserName = "******",
Email = "*****@*****.**",
Teacher = Ray,
EmailConfirmed = true
};
await userManager.CreateAsync(teacher4, "Test1234");
await userManager.AddToRoleAsync(teacher4, "Teacher");
}
public async Task <T2> CreateAsync(T2 entity) => await _service.CreateAsync(entity);
private static async Task CreateStudents(ICrudService <Student> studentService, UserManager <User> userManager)
{
Student JohnDoe = new Student()
{
Name = "John Doe",
Gender = Gender.Male,
Cohort = 31,
Degree = Degree.BSCS,
GraduationDate = new DateTime(2018, 9, 15)
};
await studentService.CreateAsync(JohnDoe);
User student1 = new User
{
UserName = "******",
Email = "*****@*****.**",
Student = JohnDoe,
EmailConfirmed = true
};
await userManager.CreateAsync(student1, "Test1234");
await userManager.AddToRoleAsync(student1, "Student");
Student BrandonSlade = new Student()
{
Name = "Brandon Slade",
Gender = Gender.Male,
Cohort = 31,
Degree = Degree.BSGD,
GraduationDate = new DateTime(2018, 9, 15)
};
await studentService.CreateAsync(BrandonSlade);
User student2 = new User
{
UserName = "******",
Email = "*****@*****.**",
Student = BrandonSlade,
EmailConfirmed = true
};
await userManager.CreateAsync(student2, "Test1234");
await userManager.AddToRoleAsync(student2, "Student");
Student Justin = new Student()
{
Name = "Justin",
Gender = Gender.Male,
Cohort = 31,
Degree = Degree.BSGD,
GraduationDate = new DateTime(2018, 9, 15)
};
await studentService.CreateAsync(Justin);
User student3 = new User
{
UserName = "******",
Email = "*****@*****.**",
Student = Justin,
EmailConfirmed = true
};
await userManager.CreateAsync(student3, "Test1234");
await userManager.AddToRoleAsync(student3, "Student");
Student Mary = new Student()
{
Name = "Mary",
Gender = Gender.Female,
Cohort = 33,
Degree = Degree.BSWD,
GraduationDate = new DateTime(2018, 9, 15)
};
await studentService.CreateAsync(Mary);
User student4 = new User
{
UserName = "******",
Email = "*****@*****.**",
Student = Mary,
EmailConfirmed = true
};
await userManager.CreateAsync(student4, "Test1234");
await userManager.AddToRoleAsync(student4, "Student");
Student LazySue = new Student()
{
Name = "Lazy Sue",
Gender = Gender.Female,
Cohort = 32,
Degree = Degree.BSTM,
GraduationDate = new DateTime(2019, 9, 15)
};
await studentService.CreateAsync(LazySue);
User student5 = new User
{
UserName = "******",
Email = "*****@*****.**",
Student = LazySue,
EmailConfirmed = true
};
await userManager.CreateAsync(student5, "Test1234");
await userManager.AddToRoleAsync(student5, "Student");
Student Damian = new Student()
{
Name = "Damian",
Gender = Gender.Male,
Cohort = 32,
Degree = Degree.BSWD,
GraduationDate = new DateTime(2018, 9, 15)
};
await studentService.CreateAsync(Damian);
User student6 = new User
{
UserName = "******",
Email = "*****@*****.**",
Student = Damian,
EmailConfirmed = true
};
await userManager.CreateAsync(student6, "Test1234");
await userManager.AddToRoleAsync(student6, "Student");
Student Robert = new Student()
{
Name = "Robert",
Gender = Gender.Male,
Cohort = 33,
Degree = Degree.BSCS,
GraduationDate = new DateTime(2020, 9, 15)
};
await studentService.CreateAsync(Robert);
User student7 = new User
{
UserName = "******",
Email = "*****@*****.**",
Student = Robert,
EmailConfirmed = true
};
await userManager.CreateAsync(student7, "Test1234");
await userManager.AddToRoleAsync(student7, "Student");
}
