public async Task <IActionResult> PutClassSubject(int id, ClassSubject classSubject)
{
if (id != classSubject.Id)
{
return(BadRequest());
}
_context.Entry(classSubject).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClassSubjectExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <ClassSubject> > PostClassSubject(ClassSubject classSubject)
{
_context.ClassSubjects.Add(classSubject);
await _context.SaveChangesAsync();
return(Created("", classSubject));
}
public ActionResult Edit(int id = 0)
{
var instuteID = Convert.ToInt32(Membership.GetUser().PasswordQuestion);
ClassSubject subject = rep.GetById(id);
if (subject == null || subject.Deleted == true || subject.InstituteID != instuteID)
{
return(HttpNotFound());
}
var data = db.Class.Where(x => x.Deleted == false).Where(x => x.InstituteID == instuteID);
ViewBag.ClassId = new SelectList(data, "Id", "Name", subject.ClassId);
var classSubject = new ClassSubjectVM()
{
ClassId = subject.ClassId,
Id = subject.Id,
SubjectNames = subject.SubjectNames
};
classSubject.SubjectBooks = subject.SubjectBook.ToList();
return(View(classSubject));
}
public async Task <IActionResult> Create(ClassSubject classSubject)
{
if (ModelState.IsValid)
{
var classname = _context.ClassTbls.Where(c => c.ClassTblId == classSubject.ClassTblId).SingleOrDefault();
var subjectname = _context.Subjects.Where(c => c.SubjectId == classSubject.SubjectId).SingleOrDefault();
if (classname != null)
{
classSubject.Name = subjectname.Name + "-" + classname.Name;
var model = _context.ClassSubjects.Where(s => s.Name.Trim() == classSubject.Name.Trim()).FirstOrDefault();
if (model != null)
{
ViewData["ClassTblId"] = new SelectList(_context.ClassTbls, "ClassTblId", "Name", classSubject.ClassTblId);
ViewData["SubjectId"] = new SelectList(_context.Subjects, "SubjectId", "Name", classSubject.SubjectId);
ModelState.AddModelError(string.Empty, "Class-Subject already exists.Please select another Class-Subject Combination.");
return(View(classSubject));
}
_context.Add(classSubject);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
ViewData["ClassTblId"] = new SelectList(_context.ClassTbls.Where(c => c.IsActive == true), "ClassTblId", "ClassTblId", classSubject.ClassTblId);
ViewData["SubjectId"] = new SelectList(_context.Subjects, "SubjectId", "SubjectId", classSubject.SubjectId);
return(View(classSubject));
}
public ActionResult Create([Bind(Include = "ClassSubjectID,ClassID,SubjectID")] ClassSubject classSubject)
{
var classSubjectObject = db.ClassSubjects.FirstOrDefault(item => item.ClassID == classSubject.ClassID && item.SubjectID == classSubject.SubjectID);
if (ModelState.IsValid && classSubjectObject == null)
{
db.ClassSubjects.Add(classSubject);
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
var subjects = db.Subjects.ToList();
var subjectWithTeacherList = new List <Object>();
foreach (Subject subject in subjects)
{
subjectWithTeacherList.Add(new { value = subject.SubjectID, text = subject.Name + " " + "(" + subject.Teacher.Name + " " + subject.Teacher.Surname + ")" });
}
ViewBag.SubjectWithTeacherList = subjectWithTeacherList;
ViewBag.ErrorMessage = "Przedmiot isniteje już w danej klasie!";
}
ViewBag.ClassID = new SelectList(db.Classes, "ClassID", "Name", classSubject.ClassID);
ViewBag.SubjectID = new SelectList(db.Subjects, "SubjectID", "Name", classSubject.SubjectID);
return(View(classSubject));
}
private void Remove()
{
if (Index >= 0)
{
ClassSubject.RemoveAt(Index);
}
}
private void Load()
{
string pathToCsv = "";
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "Файл csv|*.csv";
if (openFileDialog.ShowDialog() == true)
{
pathToCsv = openFileDialog.FileName;
}
if (File.Exists(pathToCsv))
{
char[] delimiters = new char[] { ';' };
using (StreamReader reader = new StreamReader(pathToCsv, System.Text.Encoding.Default))
{
while (true)
{
string line = reader.ReadLine();
if (line == null)
{
break;
}
string[] parts = line.Split(delimiters);
bool exist = false;
foreach (var subject in ClassSubject)
{
if (subject.NameOfSubject.Equals(parts[0].Trim(' ')))
{
exist = true;
}
}
if (!exist)
{
Department Department = null;
foreach (var dep in departments)
{
if (dep.NameOfDepartment.Equals(parts[1].Trim(' ')))
{
Department = dep;
}
}
if (Department != null)
{
Subject subject = new Subject
{
NameOfSubject = parts[0].Trim(' '),
Department = Department
};
if (RequestToDataBase.Instance.requestInsertIntoSubject(subject))
{
ClassSubject.Add(subject);
}
}
}
}
}
}
}
protected override PowerPlannerSending.BaseItem serialize()
{
ClassSubject into = new ClassSubject();
base.serialize(into);
return(into);
}
public ActionResult DeleteConfirmed(int id)
{
ClassSubject classSubject = db.ClassSubjects.Find(id);
db.ClassSubjects.Remove(classSubject);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public JsonResult DelSubject(string idsubject)
{
db.Configuration.ProxyCreationEnabled = false;
ClassSubject obj = db.Subject.Find(idsubject);
db.Subject.Remove(obj);
return(Json(db.SaveChanges(), JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult <IEnumerable <object> > > GetSubjectNameById(ClassSubject classSubject)
{
var q = await _context
.ClassSubjects
.Where(entry => entry.Id == classSubject.Id)
.Select(entry => entry.Subject.Name)
.ToListAsync();
return(q);
}
public Trainer(string firstName, string lastName, string userName, string password, ClassSubject teachingSubject) : base(firstName, lastName, userName, password)
{
FirstName = firstName;
LastName = lastName;
UserName = userName;
Password = password;
Role = Role.Trainer;
TeachingSubject = TeachingSubject;
}
private void Remove()
{
if (Index >= 0)
{
if (RequestToDataBase.Instance.requestDeleteFromSubject(ClassSubject, Index))
{
ClassSubject.RemoveAt(Index);
}
}
}
public ActionResult DeleteConfirmed(int Id)
{
var instuteID = Convert.ToInt32(Membership.GetUser().PasswordQuestion);
ClassSubject subject = rep.GetById(Id);
if (subject == null || subject.Deleted == true || subject.InstituteID != instuteID)
{
return(HttpNotFound());
}
rep.Delete(Id);
return(RedirectToAction("Index"));
}
public void SaveSubjects(IEnumerable <Subject> list, int classId, int userId)
{
Query("Delete from ClassSubject where ClassID = " + classId);
foreach (var item in list)
{
ClassSubject newObj = new ClassSubject()
{
SubjectID = item.SubjectID, ClassID = classId, created_by = userId, updated_by = userId
};
Insert(newObj);
}
}
// GET: ClassSubjects/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ClassSubject classSubject = db.ClassSubjects.Find(id);
if (classSubject == null)
{
return(HttpNotFound());
}
return(View(classSubject));
}
//----------------------------Json Result -----------------------------
//POST:Edit subject
public JsonResult EditSubject(ClassSubject s)
{
var query = from cs in db.Subject
where cs.IDSubject == s.IDSubject
select cs;
foreach (ClassSubject obj in query)
{
obj.IDSubject = s.IDSubject;
obj.SubjectName = s.SubjectName;
obj.IDClass = s.IDClass;
}
return(Json(db.SaveChanges(), JsonRequestBehavior.AllowGet));
}
private AbsenceBranch GetStudentAbsenceBySubject(ClassSubject przedmiot, List <SchoolStudent> StudentAllocation, List <SchoolLesson> LessonByClass, List <StudentAbsence> AbsenceByStudent, List <SchoolSubjectGroup> lstSubjectGroup)
{
AbsenceBranch StudentAbsenceBySubject = new AbsenceBranch();
var lstAbsenceByStudent = AbsenceByStudent.Where(x => x.SubjectID == przedmiot.SubjectID).ToList();
var Absencja = ComputeAbsence(StudentAllocation, lstAbsenceByStudent, LessonByClass, przedmiot, lstSubjectGroup);
StudentAbsenceBySubject.Level = 2;
StudentAbsenceBySubject.Label = przedmiot.SubjectName;
StudentAbsenceBySubject.LessonCount = Absencja.LessonCount;
StudentAbsenceBySubject.JustifiedAbsenceCount = Absencja.JustifiedCount;
StudentAbsenceBySubject.UnjustifiedAbsenceCount = Absencja.UnjustifiedCount;
return(StudentAbsenceBySubject);
}
public async Task <int> UpdateClassSubject(ClassSubject objClassSubject)
{
try
{
_lmsDbContext.ClassSubject.Update(objClassSubject);
await _lmsDbContext.SaveChangesAsync();
return(1);
}
catch (Exception ex)
{
return(-1);
}
}
private void Add()
{
var context = new SubjectVM(departments.ToArray());
var wins = new NewSubject()
{
DataContext = context
};
wins.ShowDialog();
System.Console.WriteLine(context.Subject != null);
if (context.Subject != null)
{
ClassSubject.Add(context.Subject);
}
}
public async Task <IActionResult> AddClassSubject(AssignSubjectViewModel objAssignSubjectVM)
{
if (ModelState.IsValid)
{
List <string> lstSubject = Request.Form["lstSubject"].ToList();
var ClassSection = await _AssignSubjectRepository.GetClassSectionById(objAssignSubjectVM.Class_Id, objAssignSubjectVM.Section_Id);
if (ClassSection != null)
{
int result = 0;
if (lstSubject.Count > 0)
{
foreach (var objSubject in lstSubject)
{
var ClassSubject = new ClassSubject
{
ClassSection_Id = ClassSection.ClassSection_id,
Subject_Id = Convert.ToInt32(objSubject)
};
result = await _AssignSubjectRepository.AddClassSubject(ClassSubject);
}
if (result > 0)
{
TempData["Success"] = "Assign Subject To Class Successfully";
return(RedirectToAction("Index", "assignSubject", new { area = "admin" }));
}
else
{
TempData["Error"] = "Assign Subject To Class Failed";
return(RedirectToAction("Index", "assignSubject", new { area = "admin" }));
}
}
}
else
{
TempData["Error"] = "Kindly First Assign Section To Class";
return(RedirectToAction("Index", "assignSubject", new { area = "admin" }));
}
}
return(View());
}
public async Task <CreateClassSubjectItemDto> Handle(CreateClassSubjectItemCommand request, CancellationToken cancellationToken)
{
var courseClass = await context.CourseClasses
.Include(cc => cc.Location)
.SingleOrDefaultAsync(l => l.Id.Equals(request.CourseClassId));
if (courseClass == null)
{
throw new EntityNotFoundException(nameof(CourseClass), request.CourseClassId);
}
var subjectAssignment = await context.SubjectAssignments
.Include(sa => sa.Instructor)
.ThenInclude(i => i.LocationInstructors)
.ThenInclude(li => li.Location)
.SingleOrDefaultAsync(l => l.Id.Equals(request.SubjectAssignmentId));
if (subjectAssignment == null)
{
throw new EntityNotFoundException(nameof(SubjectAssignment), request.SubjectAssignmentId);
}
var locationInstructorEntity = subjectAssignment.Instructor.LocationInstructors
.SingleOrDefault(li => li.LocationId.Equals(courseClass.LocationId));
if (locationInstructorEntity == null)
{
throw new InvalidAppOperationException("Cannot assign instructor to class because instructor is not assigned to the given location");
}
var entity = new ClassSubject()
{
Title = request.Title,
CourseClass = courseClass,
SubjectAssignment = subjectAssignment,
};
context.ClassSubjects.Add(entity);
await context.SaveChangesAsync(cancellationToken);
return(new CreateClassSubjectItemDto
{
Id = entity.Id
});
}
public IEnumerable <ClassSubject> AddSubjectToClass(int classId, List <ClassSubjectModel> subjectIds)
{
var origin = repository.Get(classId);
var rs = new List <ClassSubject>();
//add subject to class
subjectIds.ForEach(i =>
{
var found = origin.ClassSubjects.Where(cs => cs.SubjectId == i.SubjectId).FirstOrDefault();
if (found == null)
{
var classSubject = new ClassSubject
{
Id = 0,
Status = (int)ClassSubjectEnums.STATUS_ACTIVE,
ClassId = classId,
SubjectId = i.SubjectId,
Teacher = i.TeacherId
};
origin.ClassSubjects.Add(classSubject);
rs.Add(classSubject);
}
else
{
if (found.Status == (int)ClassSubjectEnums.STATUS_DISABLE)
{
rs.Add(found);
}
found.Status = (int)ClassSubjectEnums.STATUS_ACTIVE;
found.Teacher = i.TeacherId;
}
});
repository.Update(origin);
//update transcript of class
var subjectRepository = new SubjectRepository();
rs.ForEach(cs =>
{
cs.Subject = subjectRepository.Get(cs.SubjectId);
});
var transcriptService = new TranscriptService();
transcriptService.AddSubjectToClassTranscript(classId, rs);
return(rs);
}
public async Task <IActionResult> Edit(int id, ClassSubject classSubject)
{
if (id != classSubject.ClassSubjectId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var classname = _context.ClassTbls.Where(c => c.ClassTblId == classSubject.ClassTblId).SingleOrDefault();
var subjectname = _context.Subjects.Where(c => c.SubjectId == classSubject.SubjectId).SingleOrDefault();
if (classname != null)
{
classSubject.Name = subjectname.Name + "-" + classname.Name;
var model = _context.ClassSubjects.Where(s => s.Name.Trim() == classSubject.Name.Trim() && s.ClassSubjectId != id).ToList();
if (model.Count != 0)
{
ViewData["ClassTblId"] = new SelectList(_context.ClassTbls, "ClassTblId", "Name", classSubject.ClassTblId);
ViewData["SubjectId"] = new SelectList(_context.Subjects, "SubjectId", "Name", classSubject.SubjectId);
ModelState.AddModelError(string.Empty, "Class-Subject already exists.Please select another Class-Subject Combination.");
return(View(classSubject));
}
try
{
_context.Update(classSubject);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClassSubjectExists(classSubject.ClassSubjectId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
}
ViewData["ClassTblId"] = new SelectList(_context.ClassTbls, "ClassTblId", "Name", classSubject.ClassTblId);
ViewData["SubjectId"] = new SelectList(_context.Subjects, "SubjectId", "Name", classSubject.SubjectId);
return(View(classSubject));
}
public async Task <IActionResult> EditClassSubject(AssignSubjectViewModel objClassSubjectModel)
{
if (ModelState.IsValid)
{
//get values of class subject
AssignSubjectViewModel objAssignSubject = await _AssignSubjectRepository.GetClassSubjectById(objClassSubjectModel.ClassSubject_Id);
//get class section id
var ClassSection = await _AssignSubjectRepository.GetClassSectionById(objClassSubjectModel.Class_Id, objClassSubjectModel.Section_Id);
if (ClassSection != null)
{
//assign new values to class subject
ClassSubject objSubject = new ClassSubject();
objSubject.ClassSubject_Id = objAssignSubject.ClassSubject_Id;
objSubject.ClassSection_Id = ClassSection.ClassSection_id;
objSubject.Subject_Id = objClassSubjectModel.Subject_Id;
int result = await _AssignSubjectRepository.UpdateClassSubject(objSubject);
if (result == 1)
{
TempData["Success"] = "Class Subject Updated Successfully ";
return(RedirectToAction("Index", "assignSubject", new { area = "admin" }));
}
else
{
TempData["Error"] = "Updating Class Subject Failed";
return(RedirectToAction("Index", "assignSubject", new { area = "admin" }));
}
}
else
{
TempData["Error"] = "Class Section Didn't Find";
return(RedirectToAction("Index", "assignSubject", new { area = "admin" }));
}
}
return(View());
}
private void Add()
{
var context = new SubjectVM(departments.ToArray());
var wind = new NewSubject()
{
DataContext = context
};
wind.ShowDialog();
if (wind.DialogResult == true)
{
if (context.Subject != null)
{
if (RequestToDataBase.Instance.requestInsertIntoSubject(context.Subject))
{
ClassSubject.Add(context.Subject);
}
}
}
}
public ActionResult Edit(ClassSubjectVM ClassSubject)
{
var instuteID = Convert.ToInt32(Membership.GetUser().PasswordQuestion);
ClassSubject subject = rep.GetById(ClassSubject.Id);
if (subject == null || subject.Deleted == true || subject.InstituteID != instuteID)
{
return(HttpNotFound());
}
if (ModelState.IsValid)
{
rep.Update(ClassSubject);
return(RedirectToAction("Index"));
}
var data = db.Class.Where(x => x.Deleted == false).Where(x => x.InstituteID == instuteID);
ViewBag.ClassId = new SelectList(data, "Id", "Name");
return(View(ClassSubject));
}
public IHttpActionResult AssignSubjectToClass(ClassSubjectDto classSubject)
{
var classes = _context.Classes.Single(c => c.Id == classSubject.ClassId);
var subjects = _context.Subjects.Where(m => classSubject.SubjectIds.Contains(m.Id)).ToList();
foreach (var subject in subjects)
{
var classSubjects = new ClassSubject
{
Class = classes,
Subject = subject
};
_context.ClassSubjects.Add(classSubjects);
}
_context.SaveChanges();
return(Ok());
}
public ClassSubject Add(ClassSubjectVM entity)
{
var instuteID = Convert.ToInt32(Membership.GetUser().PasswordQuestion);
var classsubject = new ClassSubject()
{
InstituteID = instuteID,
ClassId = entity.ClassId,
SubjectNames = entity.SubjectNames
};
using (var Transaction = db.Database.BeginTransaction())
{
try
{
db.ClassSubject.Add(classsubject);
db.SaveChanges();
if (entity.SubjectBooks != null)
{
foreach (var item in entity.SubjectBooks)
{
if (!string.IsNullOrWhiteSpace(item.Name))
{
item.ClassSubjectID = classsubject.Id;
db.SubjectBook.Add(item);
}
}
db.SaveChanges();
}
Transaction.Commit();
}
catch (Exception ex)
{
Transaction.Rollback();
}
}
return(classsubject);
}
public async Task <Subject> AddSubjectToClassAsync(Guid ClassId, Guid SubjectId)
{
var classRes = await _dataContext.Classes
.Include(c => c.Subjects).ThenInclude(s => s.Subject)
.SingleOrDefaultAsync(c => c.Id == ClassId);
var subject = await _dataContext.Subjects.FindAsync(SubjectId);
if (classRes == null || subject == null)
{
return(null);
}
List <Guid> ids = new List <Guid>();
foreach (var sub in classRes.Subjects)
{
ids.Add(sub.SubjectId);
}
if (ids.Contains(subject.Id))
{
return(null);
}
ClassSubject classSubject = new ClassSubject()
{
ClassId = ClassId,
SubjectId = SubjectId,
};
await _dataContext.ClassSubjects.AddAsync(classSubject);
await _dataContext.SaveChangesAsync();
return(await _dataContext.Subjects.FindAsync(classSubject.SubjectId));
}
