private static void SelectedSubjectChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
UtilsViewModel utils = (UtilsViewModel)d;
utils.Teachers.Clear();
if (utils.SelectedClass != null)
{
if (utils.SelectedSubject != null)
{
foreach (TeacherViewModel teacher in MainViewModel.Instance.Parameters.Teachers.Where(t => t.Classes.Any(c => c.Id == utils.SelectedClass.Id) &&
t.Subjects.Any(s => s.Id == (utils.SelectedSubject?.ParentSubject?.Id ?? utils.SelectedSubject.Id))))
{
utils.Teachers.Add(teacher);
}
}
int idTeacher = MarkModel.Read(MainViewModel.Instance.SelectedYear, utils.SelectedPeriod.Id).FirstOrDefault(m => m.IdClass == utils.SelectedClass.Id && m.IdSubject == utils.SelectedSubject.Id)?.IdTeacher ?? 0;
if (idTeacher != 0)
{
utils.SelectedTeacher = MainViewModel.Instance.Parameters.Teachers.FirstOrDefault(t => t.Id == idTeacher);
}
else
{
utils.SelectedTeacher = utils.Teachers.FirstOrDefault();
}
utils.NbMarks = MarkModel.Read(MainViewModel.Instance.SelectedYear, utils.SelectedPeriod.Id).Count(m => m.IdClass == utils.SelectedClass.Id && m.IdSubject == utils.SelectedSubject.Id);
utils.ActualTeacher = utils.SelectedTeacher;
}
}
private void AffectTeacherMarksExecuted(object sender, ExecutedRoutedEventArgs e)
{
if (MessageBox.Show($"Voulez vous changer le professeur de ces {NbMarks} notes\r\n"
+ $"de {ActualTeacher.Title} {ActualTeacher.FirstName} {ActualTeacher.LastName}\r\n"
+ $"en {SelectedTeacher.Title} {SelectedTeacher.FirstName} {SelectedTeacher.LastName} ?", "Confirmation", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
{
List <MarkModel> clearMarks = new List <MarkModel>();
foreach (StudentViewModel student in MainViewModel.Instance.Parameters.Classes.FirstOrDefault(c => c.Id == SelectedClass.Id).Students)
{
clearMarks.Add(new MarkModel()
{
IdClass = SelectedClass.Id,
IdPeriod = SelectedPeriod.Id,
IdStudent = student.Id,
IdSubject = SelectedSubject.Id,
IdTeacher = ActualTeacher.Id,
});
}
MarkModel.Clear(clearMarks, MainViewModel.Instance.SelectedYear);
IEnumerable <MarkModel> marks = MarkModel.Read(MainViewModel.Instance.SelectedYear, SelectedPeriod.Id).Where(m => m.IdClass == SelectedClass.Id && m.IdSubject == SelectedSubject.Id);
foreach (MarkModel mark in marks)
{
mark.IdTeacher = SelectedTeacher.Id;
}
MarkModel.Save(marks, MainViewModel.Instance.SelectedYear);
MessageBox.Show("Changement de professeur réussi.", "Succés", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
public static void DeleteYear(int year)
{
TrimesterCommentModel.DeleteAll(year);
TrimesterSubjectCommentModel.DeleteAll(year);
SemiTrimesterCommentModel.DeleteAll(year);
PeriodCommentModel.DeleteAll(year);
MarkModel.DeleteAll(year);
TeacherClassModel.DeleteAll(year);
LevelSubjectModel.DeleteAll(year);
SubjectTeacherModel.DeleteAll(year);
SemiTrimesterModel.DeleteAll(year);
PeriodModel.DeleteAll(year);
StudentModel.DeleteAll(year);
ClassModel.DeleteAll(year);
LevelModel.DeleteAll(year);
SubjectModel.DeleteAll(year);
TeacherModel.DeleteAll(year);
YearParametersModel.DeleteAll(year);
YearModel.Delete(year);
MessageBox.Show("Suppresion de l'année réussie.", "Réussite", MessageBoxButton.OK, MessageBoxImage.Information);
MainViewModel.Instance.LoadYears();
MainViewModel.Instance.SelectedYear = year - 1;
}
public IActionResult Add(MarkModel model)
{
StudentModel student = StudentController.Find(model.Name, model.Surname);
StudySubjectModel subject = StudySubjectController.Find(model.Subject);
if (student == null)
{
ModelState.AddModelError("stu", "Student does not exist");
}
if (subject == null)
{
ModelState.AddModelError("sub", "Subject does not exist");
}
if (model.Mark > 10 || model.Mark < 1)
{
ModelState.AddModelError("mark", "Mark is out of range");
}
if (ModelState.IsValid)
{
Save(model);
return(RedirectToAction("Index"));
}
return(View(model));
}
public async Task SetRate(string articleId, int rate)
{
int doubleRate = rate;
var userId = (await GetCurrentUser()).Id;
ArticleModel article = _articleRepository.Get(new Guid(articleId));
MarkModel userMark = article.Marks
.FirstOrDefault(m => m.UserId == new Guid(userId));
if (userMark != null)
{
userMark.Value = rate;
_markRepository.Update(userMark);
}
else
{
MarkModel newMark = new MarkModel()
{
UserId = new Guid(userId),
ArticleId = new Guid(articleId),
Value = doubleRate
};
article.Marks.Add(newMark);
_articleRepository.Update(article);
}
}
public void Delete(Guid id)
{
MarkModel mark = Context.Marks.Find(id);
Context.Marks.Remove(mark);
Context.SaveChanges();
}
public HttpResponseMessage PutMark(int id, Mark markEntity)
{
if (id <= 0)
{
var errResponse = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest,
"The id of the mark must be positive");
return(errResponse);
}
try
{
var entity = this.markRepository.Update(id, markEntity);
var response = this.Request.CreateResponse(
HttpStatusCode.OK, MarkModel.CreateFromMarkEntity(entity));
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = entity.MarkId }));
return(response);
}
catch (DbUpdateConcurrencyException)
{
var errResponse = this.Request.CreateErrorResponse(HttpStatusCode.InternalServerError,
"The mark could not be updated because of a concurrency problem");
return(errResponse);
}
catch (NullReferenceException)
{
var errResponse = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest,
string.Format("A Mark entity with id={0} does not exist in the Database", id));
return(errResponse);
}
}
public HttpResponseMessage PostMark(Mark markEntity)
{
if (markEntity == null || markEntity.Subject == null || markEntity.Value == null)
{
var errResponse =
this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, "The mark is invalid");
return(errResponse);
}
try
{
var entity = this.markRepository.Add(markEntity);
var response = this.Request.CreateResponse(
HttpStatusCode.Created, MarkModel.CreateFromMarkEntity(markEntity));
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = entity.MarkId }));
return(response);
}
catch (DbUpdateConcurrencyException)
{
var errResponse = this.Request.CreateErrorResponse(HttpStatusCode.InternalServerError,
"The mark could not be added because of a concurrency problem");
return(errResponse);
}
}
public void TestAddCorrectMark()
{
bool isItemAdded = false;
var repository = Mock.Create <IRepository <Mark> >();
var markModel = new MarkModel()
{
Value = 5,
Subject = "Math"
};
var markEntity = new Mark()
{
Id = 1,
Value = markModel.Value,
Subject = markModel.Subject
};
Mock.Arrange(() => repository.Add(Arg.IsAny <Mark>()))
.DoInstead(() => isItemAdded = true)
.Returns(markEntity);
var controller = new MarkController(repository);
SetupController.Create(controller, "post", "mark");
var result = controller.Post(markEntity);
Assert.IsTrue(result.IsSuccessStatusCode);
Assert.IsTrue(isItemAdded);
}
public IActionResult Edits(int markId)
{
var Students = context.Students.Select(student => new StudentModel
{
StudentId = student.StudentId,
StudentName = student.StudentName,
Batch = student.Batch,
ContactNumber = student.ContactNumber
}).ToList();
ViewBag.Students = new SelectList(Students, "StudentId", "StudentName");
var Subjects = context.Subjects.Select(x => new SubjectModel
{
SubjectId = x.SubjectId,
SubjectName = x.SubjectName
}).ToList();
ViewBag.Subjects = new SelectList(Subjects, "SubjectId", "SubjectName");
MarkModel mark = context.Marks.Where(x => x.MarkId == markId).Select(x => new MarkModel()
{
MarkId = x.MarkId,
StudentId = x.StudentId,
Obtainedmark = x.Obtainedmark,
SubjectId = x.SubjectId,
}).FirstOrDefault();
return(View(mark));
}
public MarkModel GetMark(string markName)
{
MarkModel marks = null;
using (DBConnection dbConnection = new DBConnection())
{
try
{
SqlCommand command = new SqlCommand("SELECT * FROM Marks WHERE Mark_Name = @Mark_Name", dbConnection.myConnection);
command.Parameters.AddWithValue("Mark_Name", markName);
using (SqlDataReader reader = command.ExecuteReader())
{
if (reader.Read())
{
marks = new MarkModel(Convert.ToInt32(reader["Mark_Id"]), (string)reader["Mark_Name"], (string)reader["Description"]);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
return(marks);
}
public static List <MarkModel> GetAllMarks(string connectionString, UserModel utilizator)
{
List <MarkModel> marks = new List <MarkModel>();
using (SqlConnection con = new SqlConnection(connectionString))
{
con.Open();
string cmdText = "Select * from Evaluari";
using (SqlCommand cmd = new SqlCommand(cmdText, con))
{
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
MarkModel nota = new MarkModel();
if ((int)reader["IdElev"] == utilizator.IDUtilizator)
{
nota.Data = (DateTime)reader["DataEvaluare"];
nota.Nota = (int)reader["NotaEvaluare"];
marks.Add(nota);
}
MarkModel.ToateNotele.Add((int)reader["NotaEvaluare"]);
}
}
}
}
return(marks);
}
private void ComboBoxItem_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
MarkModel data = (MarkModel)((ComboBoxItem)sender).DataContext;
MarkDialog dialog = new MarkDialog(data);
dialog.ShowDialog();
}
public static void Save(MarkModel mark)
{
// to database
// MarkManager.Save(mark.ToData());
// without database
Marks.Add(mark);
}
public void EditMark([FromBody] MarkModel model)
{
if (Request.Cookies.ContainsKey("session"))
{
if (authService.GetUserPermissions(Request.Cookies["session"]).ToUpper() == "A")
{
marksService.EditMark(model);
}
}
}
public IActionResult Deletes(MarkModel mark)
{
Mark markRow = new Mark();
markRow = context.Marks.Where(x => x.MarkId == mark.MarkId).FirstOrDefault();
context.Marks.Remove(markRow);
context.SaveChanges();
return(RedirectToAction("Marks"));
}
public async Task <bool> GetAddMarkPost(MarkModel model, ITeacherSubjectRepository teacherSubject)
{
var teacSubj =
await teacherSubject.AllItems.FirstOrDefaultAsync(z => z.SubjectId == Int32.Parse(model.SubjectId));
Mark mark = new Mark {
StudentId = model.StudentId, TeacherSubjectId = teacSubj.Id, Value = Int32.Parse(model.Value)
};
return(await AddItemAsync(mark));
}
private void CalculateAverages(EntryMarksViewModel entryMarks)
{
if (entryMarks.SelectedClass != null && entryMarks.SelectedClass.SelectedStudent != null)
{
foreach (EntryMarksSubjectViewModel marksSubject in entryMarks.SelectedClass.SelectedStudent.MarksSubjects)
{
double average = MarkModel.ReadPeriodSubjectAverage(entryMarks.SelectedPeriod, entryMarks.SelectedClass.SelectedStudent.Student, marksSubject.Subject);
marksSubject.Average = average != double.MinValue ? average.ToString("0.0") : "";
}
}
}
public static TeacherViewModel GetTeacherFromClassAndSubject(ClassViewModel _class, SubjectViewModel subject, PeriodViewModel period)
{
TeacherViewModel teacher = MarkModel.ReadTeacherFromClassAndSubject(_class.Year, _class.Id, subject.Id, period.Id);
if (teacher == null)
{
teacher = MainViewModel.Instance.Parameters.Teachers.FirstOrDefault(t => t.Classes.Any(c => c.Id == _class.Id) && t.Subjects.Any(s => s.Id == subject.Id));
}
return(teacher);
}
public ActionResult ProjectDetails(int projectId)
{
var mark = _marksService.GetMarkByProject(projectId);
var viewMark = Mapper.Map <MarkModel>(mark);
if (viewMark == null)
{
viewMark = new MarkModel();
}
viewMark.ProjectId = projectId;
return(View(viewMark));
}
public IActionResult Marks_Details(int markId)
{
MarkModel mark = context.Marks.Where(x => x.MarkId == markId).Select(x => new MarkModel()
{
MarkId = x.MarkId,
SubjectId = x.SubjectId,
Obtainedmark = x.Obtainedmark,
StudentId = x.StudentId
}).FirstOrDefault();
return(View(mark));
}
public ActionResult StockDetails(int stockId)
{
var mark = _marksService.GetMarkByStock(stockId);
var viewMark = Mapper.Map <MarkModel>(mark);
if (viewMark == null)
{
viewMark = new MarkModel();
}
viewMark.StockId = stockId;
return(View(viewMark));
}
public ActionResult Save(MarkModel markModel)
{
var mark = Mapper.Map <Mark>(markModel);
var controllerRedirectName = markModel.ProjectId.HasValue ? "Projects" : "Stocks";
var expert = GetCurrentExpert();
mark.ExpertId = expert.Id;
var projects = _marksService.Save(mark);
return(RedirectToAction("Index", controllerRedirectName));
}
public IEnumerable <MarkModel> GetAll()
{
var entities = this.markRepository.GetAll();
List <MarkModel> models = new List <MarkModel>();
foreach (var entity in entities)
{
models.Add(MarkModel.CreateFromMarkEntity(entity));
}
return(models);
}
public async Task <IActionResult> AddMark([Bind("StudentId, SubjectId, Value")] MarkModel model)
{
if (ModelState.IsValid)
{
if (!await markRepository.GetAddMarkPost(model, teacherSubject))
{
return(NotFound());
}
return(RedirectToAction("Index", "Student"));
}
return(View(model));
}
internal override Task <object> GetInfo()
{
var item = Item;
MarkModel mark = new MarkModel
{
ID = item.ID,
ShortName = item.ShortName,
FullName = item.FullName
};
return(Task.FromResult((object)mark));
}
public bool RemoveMark(int id)
{
using (UserContext db = new UserContext())
{
MarkModel mm = db.MarkModels.Find(id);
if (mm == null)
{
return(false);
}
db.MarkModels.Remove(mm);
db.SaveChanges();
return(true);
}
}
public static IEnumerable <TeacherViewModel> GetTeachersFromClassAndSubject(ClassViewModel _class, SubjectViewModel subject, PeriodViewModel period)
{
TeacherViewModel teacher = MarkModel.ReadTeacherFromClassAndSubject(_class.Year, _class.Id, subject.Id, period.Id);
if (teacher == null)
{
return(MainViewModel.Instance.Parameters.Teachers.Where(t => t.Classes.Any(c => c.Id == _class.Id) && t.Subjects.Any(s => s.Id == subject.Id)));
}
return(new List <TeacherViewModel>()
{
teacher
});
}
private static void SelectedClassChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
UtilsViewModel utils = (UtilsViewModel)d;
utils.Subjects.Clear();
if (utils.SelectedClass != null)
{
foreach (int idSubject in MarkModel.Read(MainViewModel.Instance.SelectedYear, utils.SelectedPeriod.Id).Where(m => m.IdClass == utils.SelectedClass.Id).Select(m => m.IdSubject).Distinct())
{
utils.Subjects.Add(MainViewModel.Instance.Parameters.Subjects.FirstOrDefault(s => s.Id == idSubject));
}
}
utils.SelectedSubject = utils.Subjects.FirstOrDefault();
}
private void SelectionMark()
{
JournalsForm journal = new JournalsForm();
JournalsPresenter <Mark> presenter = new JournalsPresenter <Mark>(journal, new MarkJournal(journal.Grid));
journal.ShowDialog();
if (presenter.Info != null)
{
MarkModel mark = (MarkModel)presenter.Info;
_markID = mark.ID;
View.NameMark = mark.ShortName;
}
}
