public ActionResult Create(ClassroomViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
var classroomRepository = new ClassroomRepository(_context);
classroomRepository.Create(viewModel.Name, viewModel.CourseIds);
_context.Save(_loggedUser);
TempData["MessageType"] = "success";
TempData["MessageTitle"] = Resource.ClassroomManagementToastrTitle;
TempData["Message"] = "Classroom added";
return(Redirect(TempData["BackURL"].ToString()));
}
catch (Exception ex)
{
TempData["MessageType"] = "error";
TempData["MessageTitle"] = Resource.ClassroomManagementToastrTitle;
TempData["Message"] = ex.Message;
}
}
var courseRepository = new CourseRepository(_context);
ViewBag.Courses = new SelectList(CourseViewModel.FromEntityList(courseRepository.ListActiveCourses(), 0),
"Id", "Name");
return(View(viewModel));
}
// GET: Classroom
public ActionResult IndexAdmin(string term, string searchFieldName, int page = 1)
{
var classroomRepository = new ClassroomRepository(_context);
ViewBag.SearchFields = new SelectList(new[] { "Name", "Course" });
return(View(ClassroomViewModel.FromEntityList(classroomRepository.Search(term, searchFieldName, page))));
}
public ActionResult DeliveryPlan(Guid classroomId)
{
var classroomRepository = new ClassroomRepository(_context);
var classroom = classroomRepository.GetById(classroomId);
return(View(classroom.Courses.OrderBy(x => x.Order).ToList()));
}
public ActionResult AddOrUpdate(ClassroomModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var isCreated = model.Id == Guid.Empty;
var classroom = new Classrooms();
if (!isCreated)
{
classroom = ClassroomRepository.GetById(model.Id);
}
classroom.Title = model.Title;
classroom.Establishment_Id = model.Establishment_Id;
classroom.Establishments = EstablishmentRepository.GetById(model.Establishment_Id);
classroom.User_Id = model.UserId;
classroom.Users = UserRepository.GetById(model.UserId);
classroom.Year_Id = model.YearId;
classroom.Years = YearRepository.GetById(model.YearId);
if (isCreated)
{
ClassroomRepository.Add(classroom);
}
ClassroomRepository.Save();
return(Redirect(Url.Action("Get", "Classroom", new { id = classroom.Id })));
}
// GET: Student/Create
public ActionResult Create()
{
var classroomRepository = new ClassroomRepository(_context);
ViewBag.Classrooms = new SelectList(classroomRepository.ListActiveClassrooms(), "Id", "Name");
return(View());
}
public HttpResponseMessage Book(Booking booking)
{
var context = new TimeTableContext(WebConfigurationManager.AppSettings["DbConnectionString"]);
var bookingRepository = new BookingRepository(context);
var classroomRepository = new ClassroomRepository(context);
var service = new BookingService(bookingRepository, classroomRepository);
booking.Owner = UserId;
var bookingService = service.BookRoom(booking, UserProfile);
switch (bookingService)
{
case BookingAvailability.Success:
return(Request.CreateResponse(HttpStatusCode.OK, booking));
case BookingAvailability.Booked:
return(Request.CreateResponse(HttpStatusCode.PreconditionFailed, "The room was already booked"));
case BookingAvailability.Scheduled:
return(Request.CreateResponse(HttpStatusCode.PreconditionFailed, "There was a normal lesson during the time you would like to reserve"));
case BookingAvailability.Maintenance:
return(Request.CreateResponse(HttpStatusCode.PreconditionFailed, "There is maintenance in this classroom during the time you would like to reserve."));
default:
return(null);
}
}
public ActionResult AddOrUpdate(PupilModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var isCreated = model.Id == Guid.Empty;
var pupil = new Pupils();
if (!isCreated)
{
pupil = PupilRepository.GetById(model.Id);
}
pupil.BirthdayDate = model.BirthdayDate;
pupil.Classrooms = ClassroomRepository.GetById(pupil.Classroom_Id);
pupil.Classroom_Id = model.ClassroomId;
pupil.FirstName = model.FirstName;
pupil.LastName = model.LastName;
pupil.Level_Id = model.LevelId;
pupil.Levels = LevelRepository.GetById(pupil.Level_Id);
pupil.Sex = (short)model.Sex;
pupil.State = model.State;
pupil.Tutor_Id = model.TutorId;
pupil.Tutors = TutorRepository.GetById(pupil.Tutor_Id);
if (isCreated)
{
PupilRepository.Add(pupil);
}
PupilRepository.Save();
return(Redirect(Url.Action("Get", "Pupil", new { id = pupil.Id })));
}
public HttpResponseMessage DeleteMaintenance(Guid bookingId)
{
var context = new TimeTableContext(WebConfigurationManager.AppSettings["DbConnectionString"]);
var userRepository = new UserRepository(context);
var bookingRepository = new BookingRepository(context);
var classroomRepository = new ClassroomRepository(context);
var bookingService = new BookingService(bookingRepository, classroomRepository);
var userService = new UserService(userRepository);
var user = userService.GetUserById(UserId);
if (user.Role != TimeTableRole.Management && user.Role != TimeTableRole.Admin && user.Role != TimeTableRole.Fit)
{
return(Request.CreateResponse(HttpStatusCode.Unauthorized, "Insufficient permissions."));
}
var deletedBooking = bookingService.DeleteBooking(bookingId);
if (deletedBooking)
{
return(Request.CreateResponse(HttpStatusCode.OK));
}
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
public TeachersAssistantUnitOfWork(ICalendarBookingRepositoryMarker calendarBookingRepository,
IClassroomRepositoryMarker classroomRepositoryMarker,
IFreeDocumentRepositoryMarker freeDocumentRepositoryMarker,
IFreeDocumentStudentRepositoryMarker freeDocumentStudentRepositoryMarker,
IFreeVideoRepositoryMarker freeVideoRepositoryMarker,
IFreeVideoStudentRepositoryMarker freeVideoStudentRepositoryMarker,
IPaidDocuemtStudentRepositoryMarker paidDocuemtStudentRepositoryMarker,
IPaidDocumentRepositoryMarker paidDocumentRepositoryMarker,
IPaidVideoRepositoryMarker paidVideoRepositoryMarker,
IPaidVideoStudentRepositoryMarker paidVideoStudentRepositoryMarker,
IStudentRepositoryMarker studentRepositoryMarker,
IStudentTypeRepositoryMarker studentTypeRepositoryMarker,
ISubjectRepositoryMarker subjectRepositoryMarker,
ITeacherRepositoryMarker teacherRepositoryMarker,
IBookingTimeRepositoryMarker bookingTimeRepositoryMarker)
{
_calendarBookingRepository = calendarBookingRepository as CalendarBookingRepository;
_classroomRepository = classroomRepositoryMarker as ClassroomRepository;
_freeDocumentRepository = freeDocumentRepositoryMarker as FreeDocumentRepository;
_freeDocumentStudentRepository = freeDocumentStudentRepositoryMarker as FreeDocumentStudentRepository;
_freeVideoRepository = freeVideoRepositoryMarker as FreeVideoRepository;
_freeVideoStudentRepository = freeVideoStudentRepositoryMarker as FreeVideoStudentRepository;
_paidDocuemtStudentRepository = paidDocuemtStudentRepositoryMarker as PaidDocuemtStudentRepository;
_paidDocumentRepository = paidDocumentRepositoryMarker as PaidDocumentRepository;
_paidVideoRepository = paidVideoRepositoryMarker as PaidVideoRepository;
_paidVideoStudentRepository = paidVideoStudentRepositoryMarker as PaidVideoStudentRepository;
_studentRepository = studentRepositoryMarker as StudentRepository;
_studentTypeRepository = studentTypeRepositoryMarker as StudentTypeRepository;
_subjectRepository = subjectRepositoryMarker as SubjectRepository;
_teacherRepository = teacherRepositoryMarker as TeacherRepository;
_bookingTimeRepository = bookingTimeRepositoryMarker as BookingTimeRepository;
}
public UnitOfWork(SchoolDbContext schoolDbContext)
{
_schoolDbContext = schoolDbContext;
Student = new StudentRepository(_schoolDbContext);
Teacher = new TeacherRepository(_schoolDbContext);
Classroom = new ClassroomRepository(_schoolDbContext);
}
public ActionResult AddOrUpdate(EvaluationModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var isCreated = model.Id == Guid.Empty;
var evaluation = new Evaluations();
if (!isCreated)
{
evaluation = EvaluationRepository.GetById(model.Id);
}
evaluation.Date = model.Date;
evaluation.Classroom_Id = model.ClassroomId;
evaluation.Classrooms = ClassroomRepository.GetById(model.ClassroomId);
evaluation.User_Id = model.UserId;
evaluation.Users = UserRepository.GetById(model.UserId);
evaluation.TotalPoint = model.TotalPoint;
evaluation.Periods = PeriodRepository.GetById(model.PeriodId);
if (isCreated)
{
EvaluationRepository.Add(evaluation);
}
EvaluationRepository.Save();
return(Redirect(Url.Action("Get", "Evaluation", new { id = evaluation.Id })));
}
public ActionResult ListCourses(Guid id)
{
var classroomRepository = new ClassroomRepository(_context);
var classroom = classroomRepository.GetById(id);
return(Json(CourseViewModel.FromEntityList(classroom.Courses.ToList())));
}
public ActionResult Index()
{
var classroomRepository = new ClassroomRepository(_context);
var classrooms = classroomRepository.ListActiveClassrooms()
.Where(cr => cr.Courses.Any(c => c.Course.TeacherInCharge.Id == _loggedUser.Id));
return(View(classrooms));
}
public ActionResult Delete(string id)
{
var classroomRepository = new ClassroomRepository(_context);
classroomRepository.Delete(new Guid(id));
_context.Save(_loggedUser);
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
public UnitOfWork(SchoolContext context)
{
_context = context;
Classrooms = new ClassroomRepository(_context);
Students = new StudentRepository(_context);
Teachers = new TeacherRepository(_context);
}
public EvaluationController()
{
var entities = new Entities.Entities();
EvaluationRepository = new EvaluationRepository(entities);
ClassroomRepository = new ClassroomRepository(entities);
UserRepository = new UserRepository(entities);
PeriodRepository = new PeriodRepository(entities);
}
public PupilController()
{
var entities = new Entities.Entities();
PupilRepository = new PupilRepository(entities);
ClassroomRepository = new ClassroomRepository(entities);
LevelRepository = new LevelRepository(entities);
TutorRepository = new TutorRepository(entities);
}
public ClassroomController()
{
var entities = new Entities.Entities();
ClassroomRepository = new ClassroomRepository(entities);
EstablishmentRepository = new EstablishmentRepository(entities);
UserRepository = new UserRepository(entities);
YearRepository = new YearRepository(entities);
}
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
var classroomRepository = new ClassroomRepository(new Entities.Entities());
var classroom = classroomRepository.GetByTitle(Title);
if (classroom.Any(c => c.Establishment_Id == Establishment_Id && c.Id != Id))
{
yield return(new ValidationResult("Cette classe est déjà présente dans l'établissement", new[] { "Title", "Establishments" }));
}
}
public HttpResponseMessage Find(int start, int end, int dayofweek)
{
var context = new TimeTableContext(WebConfigurationManager.AppSettings["DbConnectionString"]);
var classroomRepository = new ClassroomRepository(context);
var service = new TimeTableService(classroomRepository);
var emptyRooms = service.FindEmpty(start, end, dayofweek);
return(Request.CreateResponse(HttpStatusCode.OK, emptyRooms));
}
public HttpResponseMessage GetScheduleForClass(string classCode, int week)
{
var context = new TimeTableContext(WebConfigurationManager.AppSettings["DbConnectionString"]);
var repository = new ClassroomRepository(context);
var service = new TimeTableService(repository);
var room = service.GetClassScheduleByCodeAndWeek(classCode, week);
return(Request.CreateResponse(HttpStatusCode.OK, room));
}
public AddressesService(
ClassroomRepository classroomRepository,
SeatingMapper seatingMapper)
{
this.classroomRepository = classroomRepository ??
throw new ArgumentNullException(nameof(classroomRepository));
this.seatingMapper = seatingMapper ??
throw new ArgumentNullException(nameof(seatingMapper));
}
public HttpResponseMessage GetAvailableWeeksHttpResponseMessage()
{
var context = new TimeTableContext(WebConfigurationManager.AppSettings["DbConnectionString"]);
var repository = new ClassroomRepository(context);
var service = new TimeTableService(repository);
var weeks = service.GetAvailableWeeks();
return(Request.CreateResponse(HttpStatusCode.OK, weeks));
}
public HttpResponseMessage GetBookingsPerRoomPerWeek(string roomCode, int week)
{
var context = new TimeTableContext(WebConfigurationManager.AppSettings["DbConnectionString"]);
var bookingRepository = new BookingRepository(context);
var classroomRepository = new ClassroomRepository(context);
var service = new BookingService(bookingRepository, classroomRepository);
var bookings = service.GetBookingsPerRoomPerWeek(roomCode, week);
return(Request.CreateResponse(HttpStatusCode.OK, bookings));
}
public HttpResponseMessage Filter(int guests, int startBlock, int endBlock, int week, int weekDay)
{
var context = new TimeTableContext(WebConfigurationManager.AppSettings["DbConnectionString"]);
var bookingRepository = new BookingRepository(context);
var classroomRepository = new ClassroomRepository(context);
var service = new BookingService(bookingRepository, classroomRepository);
var bookingService = service.Filter(guests, startBlock, endBlock, week, weekDay);
return(Request.CreateResponse(HttpStatusCode.OK, bookingService));
}
public ActionResult GetByFilter(string filter)
{
filter = filter.ToUpper();
return(Json(ClassroomRepository.All()
.Where(c =>
c.Title.ToUpper().Contains(filter) ||
c.Years.Year.ToString().Contains(filter) ||
c.Establishments.Name.ToUpper().Contains(filter) ||
c.Users.FirstName.ToUpper().Contains(filter) ||
c.Users.LastName.ToUpper().Contains(filter))
.Select(c => c.Id), JsonRequestBehavior.AllowGet));
}
public ActionResult Delete(Guid id)
{
var classroom = ClassroomRepository.GetById(id);
if (classroom.Pupils.Count() > 0)
{
return(Redirect(Url.Action("GetAll", "Classroom")));
}
ClassroomRepository.Delete(id);
ClassroomRepository.Save();
return(Redirect(Url.Action("GetAll", "Classroom")));
}
public HttpResponseMessage GetAllClassrooms()
{
var context = new TimeTableContext(WebConfigurationManager.AppSettings["DbConnectionString"]);
var repository = new ClassroomRepository(context);
var service = new ClassroomService(repository);
var rooms = service.GetAllClassrooms();
return(rooms == null
? Request.CreateResponse(HttpStatusCode.NoContent)
: Request.CreateResponse(HttpStatusCode.OK, rooms));
}
public HttpResponseMessage Scrape(int week)
{
var context = new TimeTableContext(WebConfigurationManager.AppSettings["DbConnectionString"]);
var scraperRepository = new ScraperRepository(context);
var classroomRepository = new ClassroomRepository(context);
var bookingRepository = new BookingRepository(context);
var classRepository = new ClassRepository(context);
var scraperService = new ScraperService(scraperRepository, classroomRepository, classRepository, bookingRepository);
Task.Run(() => scraperService.Scrape(week));
return(Request.CreateResponse(HttpStatusCode.OK));
}
public ActionResult AddOrUpdate(Guid?id, Guid?establishmentId)
{
var model = new ClassroomModel();
if (id.HasValue)
{
model = ClassroomModel.ToModel(ClassroomRepository.GetById(id.Value));
}
if (establishmentId.HasValue)
{
model.Establishment_Id = establishmentId.Value;
}
return(View(model));
}
