public void CreateEvent(CreateEventBindingModel model)
{
var newEvent = this.mapper.Map <EventuresEvent>(model);
this.db.Events.Add(newEvent);
this.db.SaveChanges();
}
public async Task CreateAsync(CreateEventBindingModel eventBindingModel, string teacherName)
{
EdumanUser Student = this.context.Users.FirstOrDefault(u =>
u.FirstName == eventBindingModel.StudentFirstName && u.LastName == eventBindingModel.StudentLastName && u.IsConfirmed);
EdumanUser Teacher =
this.context.Users.FirstOrDefault(u => u.UserName == teacherName);
if (Student == null || !(await userManager.IsInRoleAsync(Student, "Student")))
{
throw new Exception("The User is either non-existent or is not a student");
}
Event eventModel = new Event
{
Description = eventBindingModel.Description,
EventDate = eventBindingModel.EventDate,
StudentId = Student.Id,
TeacherId = Teacher.Id,
Type = eventBindingModel.Type
};
this.context.Events.Add(eventModel);
this.context.SaveChanges();
}
public async Task <IActionResult> Create(CreateEventBindingModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
if (!this.UserIsManager())
{
return(LocalRedirect("/main/home/index"));
}
string userId = await this.GetCurrentUserId();
var isCreated = this.service.CreateEvent(model, userId);
if (isCreated)
{
return(LocalRedirect("/manager/activities/index"));
}
ViewData["Msg"] = "Event Code is occupied";
return(this.View(model));
}
public async Task Details_DifferentUser_ShouldReturnNoData()
{
await roleManager.CreateAsync(new IdentityRole("Student"));
await roleManager.CreateAsync(new IdentityRole("Teacher"));
await roleManager.CreateAsync(new IdentityRole("Principal"));
EdumanUser student = new EdumanUser
{
UserName = "******",
FirstName = "Student",
LastName = "TestName",
IsConfirmed = true,
Id = "TestStudentId",
School = "TestSchool"
};
EdumanUser teacher = new EdumanUser
{
UserName = "******",
IsConfirmed = true,
Id = "TestTeacherId",
FirstName = "TeacherFirstName",
LastName = "TeacherLastName"
};
this.userManager.CreateAsync(student).GetAwaiter();
this.userManager.CreateAsync(teacher).GetAwaiter();
userManager.AddToRoleAsync(student, "Student").GetAwaiter();
userManager.AddToRoleAsync(teacher, "Teacher").GetAwaiter();
this.Context.SaveChanges();
CreateEventBindingModel model = new CreateEventBindingModel()
{
StudentFirstName = "Student",
StudentLastName = "TestName",
Description = "TestEventDescription",
EventDate = DateTime.Now,
Type = "TestType"
};
await eventService.CreateAsync(model, "teacherName");
var id = (eventService.GetAllAsync("TestStudentId").GetAwaiter().GetResult().FirstOrDefault()).Id;
var eventDetails = await eventService.GetEventDetails(id);
// Assert
Assert.AreEqual("Student", eventDetails.StudentFirstName);
Assert.AreEqual("TestName", eventDetails.StudentLastName);
Assert.AreEqual("TestEventDescription", eventDetails.Description);
Assert.AreEqual("TestSchool", eventDetails.School);
Assert.AreEqual("TeacherFirstName", eventDetails.TeacherFirstName);
Assert.AreEqual("TeacherLastName", eventDetails.TeacherLastName);
Assert.AreEqual("TestType", eventDetails.Type);
}
public IActionResult Create()
{
var model = new CreateEventBindingModel();
model.Code = "#1234";
return(View(model));
}
public async Task All_DifferentUser_ShouldReturnNoData()
{
await roleManager.CreateAsync(new IdentityRole("Student"));
await roleManager.CreateAsync(new IdentityRole("Teacher"));
await roleManager.CreateAsync(new IdentityRole("Principal"));
EdumanUser student = new EdumanUser
{
UserName = "******",
FirstName = "Student",
LastName = "TestName",
IsConfirmed = true,
Id = "TestStudentId"
};
EdumanUser anotherStudent = new EdumanUser
{
UserName = "******",
FirstName = "Student1",
LastName = "TestName1",
IsConfirmed = true,
Id = "TestStudentId1"
};
EdumanUser teacher = new EdumanUser
{
UserName = "******",
IsConfirmed = true,
Id = "TestTeacherId"
};
this.userManager.CreateAsync(student).GetAwaiter();
this.userManager.CreateAsync(anotherStudent).GetAwaiter();
this.userManager.CreateAsync(teacher).GetAwaiter();
userManager.AddToRoleAsync(student, "Student").GetAwaiter();
userManager.AddToRoleAsync(anotherStudent, "Student").GetAwaiter();
userManager.AddToRoleAsync(teacher, "Teacher").GetAwaiter();
this.Context.SaveChanges();
CreateEventBindingModel model = new CreateEventBindingModel()
{
StudentFirstName = "Student1",
StudentLastName = "TestName1",
Description = "TestEventDescription",
EventDate = DateTime.Now,
Type = "TestType"
};
await eventService.CreateAsync(model, "teacherName");
var count = (eventService.GetAllAsync("TestStudentId").GetAwaiter().GetResult()).Count;
// Assert
Assert.AreEqual(0, count);
}
public CreateEventBindingModel GetEventModel()
{
var eventModel = new CreateEventBindingModel()
{
Code = this.GetEventCode(),
StartDate = DateTime.Now,
EndDate = DateTime.Now.AddDays(7)
};
return(eventModel);
}
public IActionResult Create(CreateEventBindingModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
this.eventService.CreateEvent(model);
return(this.RedirectToAction("All", "Events"));
}
public async Task <IActionResult> Create(CreateEventBindingModel input)
{
if (!ModelState.IsValid)
{
return(this.View(input));
}
var serviceModel = AutoMapper.Mapper.Map <CreateEventServiceModel>(input);
await this.eventService.CreateEvent(serviceModel);
return(this.Redirect("All"));
}
public async Task <IActionResult> Create(CreateEventBindingModel createEventBindingModel)
{
try
{
await eventService.CreateAsync(createEventBindingModel, this.User.Identity.Name);
}
catch (Exception e)
{
if (e.Message == "The User is either non-existent or is not a student")
{
return(this.View("~/Views/Shared/NonExistentStudentPage.cshtml"));
}
}
return(this.RedirectToAction("Index", "Home"));
}
public IActionResult Create(CreateEventBindingModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View());
}
Event @event = this.mapper.Map <Event>(model);
this.eventsService.CreateEvent(@event);
this.logger.LogInformation($"Event created: {@event.Name}", @event);
return(this.RedirectToAction(nameof(All)));
}
public async Task Create_WithNonStudentUser_ShouldNotIncludeIntoDatabase()
{
await roleManager.CreateAsync(new IdentityRole("Student"));
await roleManager.CreateAsync(new IdentityRole("Teacher"));
await roleManager.CreateAsync(new IdentityRole("Principal"));
EdumanUser student = new EdumanUser
{
UserName = "******",
FirstName = "Student",
LastName = "TestName",
IsConfirmed = true,
Id = "TestStudentId"
};
EdumanUser teacher = new EdumanUser
{
UserName = "******",
IsConfirmed = true,
Id = "TestTeacherId"
};
this.userManager.CreateAsync(student).GetAwaiter();
this.userManager.CreateAsync(teacher).GetAwaiter();
userManager.AddToRoleAsync(student, "Principal").GetAwaiter();
userManager.AddToRoleAsync(teacher, "Teacher").GetAwaiter();
this.Context.SaveChanges();
CreateEventBindingModel model = new CreateEventBindingModel()
{
StudentFirstName = "Student",
StudentLastName = "TestName",
Description = "TestEventDescription",
EventDate = DateTime.Now,
Type = "TestType"
};
// Assert
var ex = Assert.ThrowsAsync <Exception>(() => eventService.CreateAsync(model, "teacherName"));
Assert.AreEqual(ex.Message, "The User is either non-existent or is not a student");
}
public IActionResult Create(CreateEventBindingModel model)
{
if (!this.ModelState.IsValid)
{
return(View(model));
}
var newEvent = this.mapper.Map <Event>(model);
var userId = this.userManager.GetUserId(User);
newEvent.CreatorId = userId;
this.db.Events.Add(newEvent);
this.db.SaveChanges();
return(LocalRedirect("/manager/activities/index"));
}
public bool CreateEvent(CreateEventBindingModel model, string userId)
{
var newEvent = this.mapper.Map <Event>(model);
var codeIsOccupied = this.db.Events.Any(e => e.Code == model.Code && e.IsDeleted == false);
if (codeIsOccupied)
{
return(false);
}
newEvent.CreatorId = userId;
this.db.Events.Add(newEvent);
this.db.SaveChanges();
return(true);
}
public void WithEmptyDb_ReturnsOneEvent()
{
var model = new CreateEventBindingModel()
{
Code = "1111",
Title = "Test",
StartDate = DateTime.Now,
EndDate = DateTime.Now,
};
string userId = "ABC";
this.service.CreateEvent(model, userId);
var db = this.emptyDb;
var dbEvents = this.emptyDb.Events.ToList();
Assert.AreEqual(1, dbEvents.Count);
}
public IActionResult Create(CreateEventBindingModel model)
{
if (this.ModelState.IsValid)
{
var @event = new Event
{
Name = model.Name,
Start = model.Start,
End = model.End,
Place = model.Place,
TotalTickets = model.TotalTickets,
TicketPrice = model.PricePerTicket
};
this.eventsService.CreateEvent(@event);
this.logger.LogInformation($"Event created: {@event.Name}", @event);
return(this.RedirectToAction(nameof(All)));
}
return(this.View());
}
public override void OnActionExecuting(ActionExecutingContext context)
{
this.model = context.ActionArguments.Values.OfType <CreateEventBindingModel>().Single();
}
