// GET: /Eval/CreateEvaluation
public ActionResult CreateEvaluation(Guid?classroom, Guid?periode, Guid?user)
{
EvaluationModels model;
using (EvaluationRepository repository = new EvaluationRepository())
{
IQueryable <Periods> periodes = repository.GetPeriodes();
IQueryable <Classrooms> classes = repository.GetClasses();
IQueryable <Users> users = repository.GetUsers();
model = new EvaluationModels
{
mode = -1,
periodes = getListPeriodes(periodes),
classes = getListClasses(classes),
users = getListUsers(users)
};
if (classroom != null)
{
model.classroomId = (Guid)classroom;
}
if (periode != null)
{
model.periodId = (Guid)periode;
}
if (user != null)
{
model.userId = (Guid)user;
}
}
return(View(model));
}
public ActionResult ReadEvaluation(Guid id)
{
EvaluationModels model;
using (EvaluationRepository repository = new EvaluationRepository())
{
Evaluations x = repository.GetEvaluationById(id);
if (x == null)
{
return(HttpNotFound());
}
IQueryable <Results> r = repository.GetResultsByEvalId(id);
int valuate = 1;
if (r.Count() == 0)
{
valuate = 0;
}
model = new EvaluationModels
{
id = x.Id,
classroomId = x.Classroom_Id,
userId = x.User_Id,
periodId = x.Period_Id,
date = x.Date,
totalPoint = x.TotalPoint,
classroomName = x.Classrooms.Title,
userName = x.Users.UserName,
periodName = x.Periods.Begin.ToShortDateString() + " - " + x.Periods.End.ToShortDateString(),
isValuate = valuate,
resultats = getListResultats(r)
};
}
return(View(model));
}
public ActionResult DeleteEvaluation(Guid id)
{
EvaluationModels model;
using (EvaluationRepository repository = new EvaluationRepository())
{
Evaluations x = repository.GetEvaluationById(id);
if (x == null)
{
return(HttpNotFound());
}
model = new EvaluationModels
{
id = x.Id,
classroomId = x.Classroom_Id,
userId = x.User_Id,
periodId = x.Period_Id,
date = x.Date,
totalPoint = x.TotalPoint,
};
}
return(View("DeleteEvaluation", model));
}
public ActionResult SaisirResultats(Guid idEval)
{
ListeResultatsModels model = new ListeResultatsModels();
using (EvaluationRepository repo = new EvaluationRepository())
{
Evaluations e = repo.GetEvaluationById(idEval);
if (e == null)
{
return(HttpNotFound());
}
IQueryable <Pupils> pupils = repo.GetPupilsByClassroom(repo.GetClassroomId(e));
EvaluationModels m = new EvaluationModels
{
id = e.Id,
classroomId = e.Classroom_Id,
eleves = getListPupils(pupils)
};
foreach (var eleve in m.eleves)
{
ResultatModels r = new ResultatModels
{
pupilId = eleve.id,
pupilName = eleve.firstName + " " + eleve.lastName,
evaluationId = m.id
};
model.resultats.Add(r);
}
}
model.mode = -1;
return(View(model));
}
public ActionResult Edit(int id, EditEvaluationsViewModel model)
{
var repository = new EvaluationRepository(context);
try
{
if (ModelState.IsValid)
{
var evaluationUpdate = MapperHelper.Map <Evaluation>(model);
repository.Update(evaluationUpdate);
context.SaveChanges();
var route = (new
{
controller = "Assignment",
action = "Index"
});
return(RedirectToRoute(route));
}
}
catch (Exception ex)
{
ViewBag.ErrorMessage = ex.Message;
return(View(model));
}
return(View(model));
}
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 EditEvaluation(Guid id)
{
EvaluationModels model;
using (EvaluationRepository repository = new EvaluationRepository())
{
Evaluations x = repository.GetEvaluationById(id);
IQueryable <Periods> periodes = repository.GetPeriodes();
IQueryable <Classrooms> classes = repository.GetClasses();
IQueryable <Users> users = repository.GetUsers();
if (x == null)
{
return(HttpNotFound());
}
model = new EvaluationModels
{
mode = 0,
id = x.Id,
classroomId = x.Classroom_Id,
userId = x.User_Id,
periodId = x.Period_Id,
date = x.Date,
totalPoint = x.TotalPoint,
periodes = getListPeriodes(periodes),
classes = getListClasses(classes),
users = getListUsers(users)
};
}
return(View("CreateEvaluation", model));
}
public EvaluationService(IEntityService entityService,
PersonRepository personRepository,
EvaluationRepository evaluationRepository)
{
_entityService = entityService;
_personRepository = personRepository;
_evaluationRepository = evaluationRepository;
}
public EnrollmentsController()
{
_termRepository = new TermRepository();
_enrollmentRepository = new EnrollmentRepository();
_evaluationRepository = new EvaluationRepository();
_offeringRepository = new OfferingRepository();
_scheduleRepository = new ScheduleRepository();
}
public ResultController()
{
var entities = new Entities.Entities();
ResultRepository = new ResultRepository(entities);
EvaluationRepository = new EvaluationRepository(entities);
PupilRepository = new PupilRepository(entities);
}
public EvaluationFacade(
EvaluationRepository evaluationRepository,
ProductRepository productRepository,
IMapper mapper)
{
this.evaluationRepository = evaluationRepository;
this.mapper = mapper;
this.productRepository = productRepository;
}
// GET: Evaluations/Edit/5
public ActionResult Edit(int id)
{
var repository = new EvaluationRepository(context);
var includes = new Expression <Func <Evaluation, object> >[] { x => x.AssignedCourse };
var evaluation = repository.QueryIncluding(x => x.AssignedCourseId == id, includes).FirstOrDefault();
var model = MapperHelper.Map <EditEvaluationsViewModel>(evaluation);
return(View(model));
}
public ActionResult DeleteEvaluation(EvaluationModels model)
{
using (EvaluationRepository repository = new EvaluationRepository())
{
repository.DeleteById(model.id);
repository.Save();
}
return(View("Index"));
}
public EvaluationController()
{
var entities = new Entities.Entities();
EvaluationRepository = new EvaluationRepository(entities);
ClassroomRepository = new ClassroomRepository(entities);
UserRepository = new UserRepository(entities);
PeriodRepository = new PeriodRepository(entities);
}
/// <summary>
/// Public constructor
/// </summary>
public EvaluationListModel()
{
if (_evaluationRepository == null)
{
_evaluationRepository = new EvaluationRepository();
}
AllEvaluations = new ObservableCollection <Evaluation>(_evaluationRepository.GetEvaluations());
_evaluationList = new ObservableCollection <Evaluation>(_evaluationRepository.GetEvaluations());
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
EventCategory = new EventCategoryRepository(context);
Evaluation = new EvaluationRepository(context);
UserInterestCateogry = new UserInterestCateogryRepository(context);
UserParticipantsEvent = new UserParticipantsEventRepository(context);
Event = new EventRepository(context);
}
public ActionResult GetByFilter(string filter)
{
return(Json(EvaluationRepository.All()
.Where(e =>
(e.Classrooms.Title.ToLower()
+ e.Date.ToString()
+ e.TotalPoint.ToString()
+ e.Users.LastName.ToLower()
+ e.Users.FirstName.ToLower()).Contains(filter.ToLower()))
.Select(e => e.Id), JsonRequestBehavior.AllowGet));
}
public ProductFacade(
ProductRepository productRepository,
EvaluationRepository evaluationRepository,
ManufacturerRepository manufacturerRepository,
CategoryRepository categoryRepository,
EvaluationFacade evaluationFacade,
IMapper mapper)
{
this.evaluationRepository = evaluationRepository;
this.productRepository = productRepository;
this.categoryRepository = categoryRepository;
this.manufacturerRepository = manufacturerRepository;
this.mapper = mapper;
this.evaluationFacade = evaluationFacade;
}
public ActionResult AddOrUpdate(Guid?Id, Guid?classroomId)
{
var model = new EvaluationModel();
model.Date = DateTime.Now;
if (Id.HasValue)
{
model = EvaluationModel.ToModel(EvaluationRepository.GetById(Id.Value));
}
if (classroomId.HasValue)
{
model.ClassroomId = classroomId.Value;
}
return(View(model));
}
public ActionResult EditEvaluation(EvaluationModels model)
{
using (EvaluationRepository repository = new EvaluationRepository())
{
Evaluations x = repository.GetEvaluationById(model.id);
x.Classroom_Id = model.classroomId;
x.User_Id = model.userId;
x.Period_Id = model.periodId;
x.Date = model.date;
x.TotalPoint = model.totalPoint;
if (ModelState.IsValid)
{
repository.Save();
}
return(RedirectToAction("ReadEvaluations"));
}
}
public PersonService(PersonRepository personRepository,
IEntityService entityService,
UsersRepository usersRepository,
JobRepository jobRepository,
LeaveService leaveService,
EvaluationRepository evaluationRepository,
EndorsementService endorsementService,
OrgGroupRepository orgGroupRepository)
{
_personRepository = personRepository;
_entityService = entityService;
_usersRepository = usersRepository;
_jobRepository = jobRepository;
_leaveService = leaveService;
_evaluationRepository = evaluationRepository;
_endorsementService = endorsementService;
_orgGroupRepository = orgGroupRepository;
}
public ActionResult EditerResultats(Guid idEval)
{
ListeResultatsModels model = new ListeResultatsModels();
using (EvaluationRepository repo = new EvaluationRepository())
{
Evaluations e = repo.GetEvaluationById(idEval);
if (e == null)
{
return(HttpNotFound());
}
IQueryable <Results> r = repo.GetResultsByEvalId(idEval);
List <ResultatModels> l = getListResultats(r);
foreach (var res in l)
{
model.add(res);
}
}
model.mode = 0;
return(View("SaisirResultats", model));
}
// GET: /Eval/ReadEvaluations
public ActionResult ReadEvaluations()
{
IList <EvaluationModels> models = new List <EvaluationModels>();
using (EvaluationRepository repository = new EvaluationRepository())
{
IQueryable <Evaluations> a = repository.All();
models = repository.All().Select(x => new EvaluationModels
{
id = x.Id,
classroomId = x.Classroom_Id,
userId = x.User_Id,
periodId = x.Period_Id,
date = x.Date,
totalPoint = x.TotalPoint,
classroomName = x.Classrooms.Title,
userName = x.Users.UserName
}).ToList();
}
return(View(models));
}
public ActionResult CreateEvaluation(EvaluationModels model)
{
if (ModelState.IsValid)
{
using (EvaluationRepository repository = new EvaluationRepository())
{
Evaluations a = new Evaluations
{
Id = Guid.NewGuid(),
Classroom_Id = model.classroomId,
User_Id = model.userId,
Period_Id = model.periodId,
Date = model.date,
TotalPoint = model.totalPoint,
};
repository.Add(a);
repository.Save();
}
return(RedirectToAction("ReadEvaluations"));
}
return(View(model));
}
public EvaluationBusiness(IServiceProvider provider, EvaluationRepository repository) : base(provider, repository)
{
this._repository = repository;
}
public EvaluationApplicationService(EvaluationRepository evaluationRepository, EvaluationExpirationRepository evaluationExpirationRepository) : base()
{
this.evaluationRepository = evaluationRepository;
this.evaluationExpirationRepository = evaluationExpirationRepository;
}
public ActionResult Get(Guid id)
{
var model = EvaluationModel.ToModel(EvaluationRepository.GetById(id));
return(View(model));
}
public ActionResult Delete(Guid id)
{
EvaluationRepository.Delete(id);
EvaluationRepository.Save();
return(Redirect(Url.Action("GetAll", "Evaluation")));
}
public ActionResult GetAll()
{
var models = EvaluationRepository.All().Select(a => EvaluationModel.ToModel(a));
return(View(models));
}
