public async Task <ActionResult <StudentSubject> > PostStudentSubject(StudentSubject studentSubject)
{
_context.StudentSubjects.Add(studentSubject);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetStudentSubject", new { id = studentSubject.Id }, studentSubject));
}
public IActionResult PostStudentSubject([FromQuery] int Id, int Subj_Id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
StudentSubject studentSubject = new StudentSubject();
studentSubject.Id = Id;
studentSubject.Subj_Id = Subj_Id;
_context.StudentsSubjects.Add(studentSubject);
try
{
_context.SaveChanges();
}
catch (DbUpdateException)
{
if (StudentSubjectExists(studentSubject.Subj_Id, studentSubject.Id))
{
return(new StatusCodeResult(StatusCodes.Status409Conflict));
}
else
{
throw;
}
}
return(CreatedAtAction("GetStudentSubject", new { id = studentSubject.Id }, studentSubject));
}
private void FindStudent()
{
var studentsVM = new StudentsViewModel();
StudentSubject studentSubjectMVM = new StudentSubject();
studentsVM.GetStudents();
CurrentStudentMVM = studentsVM.StudentsListNou.FirstOrDefault(x => x.Dni == DniMGVM);
if (CurrentStudentMVM != null)
{
DniMGVM = CurrentStudentMVM.Dni;
NameMGVM = CurrentStudentMVM.Name;
ErrorsList = new List <ErrorMessage>();
GetSubjectsToStudent();
}
else
{
NameMGVM = "Student no Existe";
Student student = new Student();
CurrentStudentMVM = student;
ErrorsList = new List <ErrorMessage>();
GetSubjectsToStudent();
DniMGVM = "";
}
}
/*
* Lấy danh sách các học sinh trong một môn thi của kì thi từ sql server
*/
public List <StudentSubject> GetStudentOfSubject(int subjectid, out string out_mess)
{
List <StudentSubject> data = new List <StudentSubject>();
out_mess = "";
try
{
conn.Open();
SqlCommand cmd = new SqlCommand("SHOW_STUDENT_OF_SUBJECT", conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@IN_SUBJECT_ID", SqlDbType.Int);
cmd.Parameters["@IN_SUBJECT_ID"].Value = subjectid;
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
var ext = new StudentSubject
(
reader[0].ToString(),
reader[1].ToString(),
Convert.ToInt32(reader[3]),
Convert.ToBoolean(reader[2])
);
data.Add(ext);
}
}
catch (Exception ex)
{
out_mess = ex.Message;
return(null);
}
return(data);
}
public async Task <IActionResult> Edit(int id, [Bind("StudentSubjectId")] StudentSubject studentSubject)
{
if (id != studentSubject.StudentSubjectId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(studentSubject);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentSubjectExists(studentSubject.StudentSubjectId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(studentSubject));
}
public void CreateStudentSubjectList(List <Subject> subjectsList, Student student)
{
List <StudentSubject> studentSubjects = new List <StudentSubject>();
foreach (Subject subject in subjectsList)
{
StudentSubject studentSubject = new StudentSubject()
{
StudentID = student.ID,
SubjectID = subject.ID,
};
db.StudentSubjects.Add(studentSubject);
db.SaveChanges();
}
//testing the db
List <StudentSubject> testStudentSubjectList = db.StudentSubjects.ToList();
int count = 0;
foreach (StudentSubject whatever in testStudentSubjectList)
{
if (whatever.StudentID == student.ID)
{
count++;
}
}
}
} //end function
public StudentSubject StudentSubjectSelectByID(int intSubjectID)
{
try
{
string sp_name = "StudentSubjectSelectByID";
comStudentSubject.Parameters.AddWithValue("SubjectID", intSubjectID);
ConnectAndExecute(sp_name); //no parameter will send to stored procedure
if (dsStudentSubject.Tables[0].Rows.Count == 1)
{
DataRow drStudentSubject = dsStudentSubject.Tables[0].Rows[0];
StudentSubject objStudentSubject = new StudentSubject();
objStudentSubject.SubjectID = Convert.ToInt64(drStudentSubject["SubjectID"]);
objStudentSubject.SubjectName = Convert.ToString(drStudentSubject["SubjectName"]);
objStudentSubject.Remarks = Convert.ToString(drStudentSubject["Remarks"]);
objStudentSubject.InsertDataTime = Convert.ToDateTime(drStudentSubject["InsertDataTime"]);
objStudentSubject.InsertByID = Convert.ToInt64(drStudentSubject["InsertByID"]);
objStudentSubject.IsEnabeled = Convert.ToBoolean(drStudentSubject["IsEnabeled"]);
objStudentSubject.LastUpdateTime = Convert.ToDateTime(drStudentSubject["LastUpdateTime"]);
objStudentSubject.LastUpdateID = Convert.ToInt64(drStudentSubject["LastUpdateID"]);
return(objStudentSubject);
}
return(null);
}
catch (Exception ex)
{
SetError(ex.Message);
return(null);
} //end try
} //end function
public void DeleteStudentSubjectById(int id)
{
StudentSubject studentSubject = db.StudentSubjects.Find(id);
db.StudentSubjects.Remove(studentSubject);
db.SaveChanges();
}
public StudentSubject SaveStudentSubjectGrade(StudentSubject studentSubject)
{
var studentSubjectInDB = db.StudentSubjects.Single
(s => s.StudentSubjectID == studentSubject.StudentSubjectID);
if (studentSubject.Grade == Grade.A)
{
studentSubjectInDB.Grade = Grade.A;
}
else if (studentSubject.Grade == Grade.B)
{
studentSubjectInDB.Grade = Grade.B;
}
else if (studentSubject.Grade == Grade.C)
{
studentSubjectInDB.Grade = Grade.C;
}
else if (studentSubject.Grade == Grade.D)
{
studentSubjectInDB.Grade = Grade.D;
}
db.SaveChanges();
return(studentSubjectInDB);
}
public async Task <bool> AddLectorAsync(int subjectId, int semesterId, string email)
{
var lector = this.userRepository
.All()
.FirstOrDefault(u => u.Email == email && u.Role == "Lector");
if (lector == null)
{
return(false);
}
var userSubject = new StudentSubject
{
StudentId = lector.Id,
SubjectId = subjectId,
};
await this.userSubjectRepository.AddAsync(userSubject);
await this.userSubjectRepository.SaveChangesAsync();
var userSemester = new StudentSemester
{
StudentId = lector.Id,
SemesterId = semesterId,
};
await this.userSemesterRepository.AddAsync(userSemester);
await this.userSemesterRepository.SaveChangesAsync();
return(true);
}
public ActionResult PostStudentSubject([FromBody] StudentSubject studentSubject)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_unitOfWork.StudentSubjectRepository.Create(studentSubject);
try
{
_unitOfWork.Save();
}
catch (DbUpdateException)
{
if (StudentSubjectExists(studentSubject.StudentId))
{
return(new StatusCodeResult(StatusCodes.Status409Conflict));
}
else
{
throw;
}
}
return(CreatedAtAction("GetStudentSubject", new { id = studentSubject.StudentId }, studentSubject));
}
public ActionResult PutStudentSubject([FromRoute] int id, [FromBody] StudentSubject studentSubject)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != studentSubject.StudentId)
{
return(BadRequest());
}
_unitOfWork.StudentSubjectRepository.Update(studentSubject);
try
{
_unitOfWork.Save();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentSubjectExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Description,SubjectId,Dificult,IsConcluded")] StudentSubject studentSubject)
{
if (id != studentSubject.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(studentSubject);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentSubjectExists(studentSubject.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["SubjectId"] = new SelectList(_context.Subjects, "Id", "Id", studentSubject.SubjectId);
return(View(studentSubject));
}
public void AddSubjectToListVM()
{
Subject subject = new Subject();
Student student = new Student();
StudentSubject studentSubjectMVM = new StudentSubject();
subject = CurrentSubjectMVM;
student = CurrentStudentMVM;
if (CurrentStudentMVM != null)
{
studentSubjectMVM.StudentId = student.Id;
if (CurrentSubjectMVM != null)
{
studentSubjectMVM.SubjectId = subject.Id;
}
}
studentSubjectMVM.Save();
ErrorsList = studentSubjectMVM.CurrentValidation.Errors.Select(x => new ErrorMessage()
{
Message = x
}).ToList(); //Nou
if (CurrentStudentMVM != null)
{
GetSubjectsToStudent();
}
}
private void FindStudentSEVM()
{
var studentsVM = new StudentsViewModel();
StudentSubject studentSubjectMVM = new StudentSubject();
studentsVM.GetStudents();
CurrentStudentSEVM = studentsVM.Students.FirstOrDefault(x => x.Dni == DniS);
if (CurrentStudentSEVM != null)
{
DniS = CurrentStudentSEVM.Dni;
NameS = CurrentStudentSEVM.Name;
GetStudentExamsSEVM();
}
else
{
MessageBox.Show("Este estudiante no existe.");
//Student student = new Student();
//_ = CurrentStudentSEVM == student;
//StudentExamsListSEVM = new List<StudentExam>();
DniS = "";
}
}
public IHttpActionResult GetMateria(int user_id, int materia_id)
{
Student student = this.studentService.GetStudent(user_id);
StudentSubject subjectStatus = this.studentSubjectService.GetSubjectStatus(student, materia_id);
return(Ok(subjectStatus));
}
public void AddSubjectToListVM()
{
Subject subject = new Subject();
Student student = new Student();
StudentSubject studentSubjectMVM = new StudentSubject();
subject = CurrentSubjectMVM;
student = CurrentStudentMVM;
studentSubjectMVM.StudentId = student.Id;
studentSubjectMVM.SubjectId = subject.Id;
ManagementErrorMGVM = "";
SubjectsByStudentList = studentSubjectMVM.StudentBySubjects(studentSubjectMVM.StudentId);
if (SubjectsByStudentList != null && SubjectsByStudentList.Any(x => x.SubjectId == subject.Id))
{
ManagementErrorMGVM = "El alumno ya tiene la asignatura";
}
else
{
var error = studentSubjectMVM.Save();
if (error.IsSuccess == false)
{
ManagementErrorMGVM = error.ToString();
}
else
{
var repo = StudentSubject.DepCon.Resolve <IRepository <StudentSubject> >();
SubjectsByStudentList = studentSubjectMVM.StudentBySubjects(studentSubjectMVM.StudentId);
}
}
}
private void FindStudentSVM()
{
ErrorsSVM = "";
var studentsVM = new StudentsViewModel();
StudentSubject studentSubjectMVM = new StudentSubject();
studentsVM.GetStudents();
CurrentStudentSVM = studentsVM.StudentsListNou.FirstOrDefault(x => x.Dni == DniSVM);
if (CurrentStudentSVM != null)
{
DniSVM = CurrentStudentSVM.Dni;
NameSVM = CurrentStudentSVM.Name;
GetSubjectsNameEV();
}
else
{
ErrorsSVM = "Student no Existe";
Student student = new Student();
CurrentStudentSVM = student;
GetSubjectsNameEV();
DniSVM = "";
NameSVM = "";
}
}
public void CreateStudentSubject()
{
var _historic = _context.StudentSubjects.ToList().Count;
if (_historic > 0)
{
throw new System.Exception("There are already registered subjects. Please, reload database scripts.");
}
var _students = _context.Students.ToList();
var _subjects = _context.Subjects.ToList();
foreach (Student _student in _students)
{
foreach (Subject _subject in _subjects)
{
StudentSubject _studentSubject = new StudentSubject();
_studentSubject.StudentId = _student.Id;
_studentSubject.SubjectId = _subject.Id;
_studentSubject.Grade = GenerateRandomGrade();
_context.Add(_studentSubject);
}
_context.SaveChanges();
}
}
private void AddSubjectToListVM()
{
Subject subject = new Subject();
Student student = new Student();
StudentSubject studentSubjectMVM = new StudentSubject();
subject = CurrentSubject;
student = CurrentStudent;
if (CurrentStudent != null)
{
studentSubjectMVM.StudentId = student.Id;
if (CurrentSubject != null)
{
studentSubjectMVM.SubjectId = subject.Id;
}
GetSubjectsToStudent();
}
else
{
MessageBox.Show("No existe este estudiante");
}
studentSubjectMVM.Save();
}
public IHttpActionResult PostStudentSubject(StudentSubject studentSubject)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.StudentSubject.Add(studentSubject);
try
{
db.SaveChanges();
}
catch (DbUpdateException)
{
if (StudentSubjectExists(studentSubject.StdId))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = studentSubject.StdId }, studentSubject));
}
public void TranslateStudentSubjectToStudentSubjectBDO(StudentSubject ss, StudentSubjectBDO ssbdo)
{
ssbdo.FirstEntered = ss.FirstEntered;
ssbdo.FirstLocked = ss.FirstLocked;
ssbdo.FirstPeriodicRating = ss.FirstPeriodicRating;
ssbdo.FourthEntered = ss.FourthEntered;
ssbdo.FourthLocked = ss.FourthLocked;
ssbdo.FourthPeriodicRating = ss.FourthPeriodicRating;
ssbdo.LockFirst = ss.LockFirst;
ssbdo.LockFourth = ss.LockFourth;
ssbdo.LockSecond = ss.LockSecond;
ssbdo.LockThird = ss.LockThird;
ssbdo.Remarks = ss.Remarks;
ssbdo.SecondEntered = ss.SecondEntered;
ssbdo.SecondLocked = ss.SecondLocked;
ssbdo.SecondPeriodicRating = ss.SecondPeriodicRating;
ssbdo.ThirdEntered = ss.ThirdEntered;
ssbdo.ThirdLocked = ss.ThirdLocked;
ssbdo.ThirdPeriodicRating = ss.ThirdPeriodicRating;
ssbdo.StudentEnrSubCode = ss.StudentEnrSubCode;
ssbdo.StudentEnrSubCode = ss.StudentEnrSubCode;
ssbdo.StudentSubjectsID = ss.StudentSubjectsID;
ssbdo.StudentSY = ss.StudentSY;
ssbdo.SubjectAssignments = ss.SubjectAssignments;
ssbdo.SubjectCode = ss.SubjectCode;
}
public void DelSubjectToListVM()
{
StudentSubject studentSubjectMVM = new StudentSubject();
if (CurrentStudentSubjectMVM == null)
{
studentSubjectMVM.Delete();
ErrorsList = studentSubjectMVM.CurrentValidation.Errors.Select(x => new ErrorMessage()
{
Message = x
}).ToList();
}
else
{
ErrorsList = new List <ErrorMessage>();
studentSubjectMVM = CurrentStudentSubjectMVM;
studentSubjectMVM.Delete();
ErrorsList = studentSubjectMVM.CurrentValidation.Errors.Select(x => new ErrorMessage()
{
Message = x
}).ToList();
SubjectsByStudentList = studentSubjectMVM.StudentBySubjects(studentSubjectMVM.StudentId);
GetSubjectsToStudent();
}
}
public async Task <IActionResult> Edit([Bind("StudentId,SubjectId,DateInscription,Year")] StudentSubject StudentSubject)
{
//if (id != StudentSubject.StudentId)
//{
// return NotFound();
//}
if (ModelState.IsValid)
{
try
{
this.databaseContext.Update(StudentSubject);
await this.databaseContext.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentSubjectExists(StudentSubject.StudentId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["StudentId"] = new SelectList(this.databaseContext.Students, "Id", "Name", StudentSubject.StudentId);
ViewData["SubjectId"] = new SelectList(this.databaseContext.Subjects, "Id", "Name", StudentSubject.SubjectId);
return(View(StudentSubject));
}
private void btnSave_Click(object sender, EventArgs e)
{
StudentSubject studentSubject = new StudentSubject();
studentSubject.SubjectID = Convert.ToInt64(txtSubjectName.Tag);
studentSubject.SubjectName = txtSubjectName.Text;
studentSubject.InsertByID = Convert.ToInt32(this.Tag);
studentSubject.InsertDataTime = System.DateTime.Now;
studentSubject.LastUpdateID = Convert.ToInt32(this.Tag);
studentSubject.LastUpdateTime = System.DateTime.Now;
studentSubject.IsEnabeled = chkIsEnabled.Checked;
studentSubject.Remarks = txtRemarks.Text;
Int64 subjec_id = StudentSubjectController.InsertUpdateStudentSubject(studentSubject);
txtSubjectName.Tag = subjec_id;
if (subjec_id > 0)
{
SuccessMessage.SHowDialog("Record Entered Successfully");
}
else
{
ErrorMessage.SHowDialog("Degree Not Added Successfully");
}
}
public async Task <IActionResult> PutStudentSubject(Guid id, StudentSubject studentSubject)
{
if (id != studentSubject.Id)
{
return(BadRequest());
}
_context.Entry(studentSubject).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentSubjectExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Edit(int id, [Bind("StudSubjectId,StudId,SubjectId")] StudentSubject studentSubject)
{
if (id != studentSubject.StudSubjectId)
{
return(RedirectToAction("Index", "Errors"));
}
if (ModelState.IsValid)
{
try
{
_context.Update(studentSubject);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentSubjectExists(studentSubject.StudSubjectId))
{
return(RedirectToAction("Index", "Errors"));
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["StudId"] = new SelectList(_context.Student, "StudId", "StudId", studentSubject.StudId);
ViewData["SubjectId"] = new SelectList(_context.Subject, "SubjectId", "SubjectName", studentSubject.SubjectId);
return(View(studentSubject));
}
public ActionResult Create(ExamResultVM examResult)
{
if (ModelState.IsValid)
{
StudentSubject studentSubject = db.StudentSubjects.FirstOrDefault(s =>
s.StudentId == examResult.StudentId && s.SubjectId == examResult.SubjectId);
if (studentSubject != null)
{
ExamResult result = new ExamResult()
{
StudentId = examResult.StudentId,
SubjectId = examResult.SubjectId,
//Status = "Pass"
};
db.ExamResults.Add(result);
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "You have to assign subject first!!");
ViewBag.StudentId = new SelectList(db.Students, "Id", "Student_Id");
ViewBag.SubjectId = db.Subjects.ToList();
return(View(examResult));
}
}
//ViewBag.StudentSubjectId = new SelectList(db.StudentSubjects, "Id", "Id", examResult.StudentSubjectId);
ViewBag.StudentId = new SelectList(db.Students, "Id", "Student_Id");
ViewBag.SubjectId = db.Subjects.ToList();
return(View(examResult));
}
public IHttpActionResult PutStudentSubject(int id, StudentSubject studentSubject)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != studentSubject.Id)
{
return(BadRequest());
}
db.Entry(studentSubject).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentSubjectExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public static void SeedData(FacultadContext context)
{
context.Database.Migrate();
if (!context.Careers.Any())
{
context.Careers.AddRange(
new Career()
{
Name = "Engineering", ObtainedTitle = "Software Engineering"
},
new Career()
{
Name = "Medicine", ObtainedTitle = "Doctor"
}
);
}
if (!context.Subjects.Any())
{
context.Subjects.AddRange(
new Subject()
{
Name = "Math", Workload = 8
},
new Subject()
{
Name = "Pathology", Workload = 10
}
);
}
if (!context.Students.Any())
{
context.Students.AddRange(
new Student()
{
Name = "Juan Carlos Paez", Address = "San Martin 234"
},
new Student()
{
Name = "Julieta Fox", Address = "San Juan 234"
}
);
}
context.SaveChanges();
if (!context.StudentSubjects.Any())
{
var newStudentSubject = new StudentSubject()
{
IdCareer = context.Careers.FirstOrDefault().IdCareer,
IdStudent = context.Students.FirstOrDefault().IdStudent,
IdSubject = context.Subjects.FirstOrDefault().IdSubject,
Status = "InProgress",
Average = 7
};
context.Add(newStudentSubject);
}
context.SaveChanges();
}
public List<StudentSubject> GetStudentSubjects(string studentIdSy)
{
List<StudentSubject> ss = new List<StudentSubject>();
List<StudentSubjectBDO> ssbdo = new List<StudentSubjectBDO>();
ssbdo= ssl.GetStudentSubjects(studentIdSy);
foreach(StudentSubjectBDO s in ssbdo) {
StudentSubject ssub = new StudentSubject();
TranslateStuSubjectsBDOToStuSubjects(s, ssub);
ss.Add(ssub);
}
return ss;
}
public void TranslateStuSubjectsToStuSubjectsBDO(StudentSubject s, StudentSubjectBDO sbdo)
{
sbdo.StudentSY = s.StudentSY;
sbdo.SubjectCode = s.SubjectCode;
sbdo.StudentSubjectsID = s.StudentSubjectsID;
sbdo.StudentEnrSubCode = s.StudentEnrSubCode;
sbdo.Remarks = s.Remarks;
sbdo.FirstPeriodicRating = s.FirstPeriodicRating;
sbdo.SecondPeriodicRating = s.SecondPeriodicRating;
sbdo.ThirdPeriodicRating = s.ThirdPeriodicRating;
sbdo.FourthPeriodicRating = s.FourthPeriodicRating;
sbdo.SubjectAssignments = s.SubjectAssignments;
sbdo.FirstEntered = s.FirstEntered;
sbdo.FirstLocked = s.FirstLocked;
sbdo.FourthEntered = s.FourthEntered;
sbdo.FourthLocked = s.FourthLocked;
sbdo.LockFirst = s.LockFirst;
sbdo.LockFourth = s.LockFourth;
sbdo.LockSecond = s.LockSecond;
sbdo.LockThird = s.LockThird;
sbdo.SecondEntered = s.SecondEntered;
sbdo.SecondLocked = s.SecondLocked;
sbdo.ThirdEntered = s.ThirdEntered;
sbdo.ThirdLocked = s.ThirdLocked;
}
private void cbEditor_ValueChanged(object sender, EventArgs e)
{
StudentSchedule sa = new StudentSchedule();
int i = gvSchedule.CurrentRow.Index;
string subass=gvSchedule.Rows[i].Cells["SubjectAssignments"].Value.ToString();
int index = ControlSchedule.FindIndex(item => item.SubjectAssignments == subass);
ControlSchedule[index].Selected = false;
sa = ControlSchedule[index];
RadCheckBoxEditor cbEditor = sender as RadCheckBoxEditor;
StudentSubject ss = new StudentSubject()
{
StudentSY = controlStudentId + SY,
SubjectCode = sa.SubjectCode,
SubjectAssignments = sa.SubjectAssignments,
StudentEnrSubCode = controlStudentId + SY + sa.SubjectCode,
LockFirst = false,
LockSecond = false,
LockThird = false,
LockFourth = false,
FirstPeriodicRating = 0.00,
SecondPeriodicRating = 0.00,
ThirdPeriodicRating = 0.00,
FourthPeriodicRating = 0.00
};
if ((Telerik.WinControls.Enumerations.ToggleState)cbEditor.Value == Telerik.WinControls.Enumerations.ToggleState.Off)
{
sa.Selected = false;
AddFromControl.Add(sa);
subjects.Add(ss);
Schedules.Remove(sa);
}
else if ((Telerik.WinControls.Enumerations.ToggleState)cbEditor.Value == Telerik.WinControls.Enumerations.ToggleState.On)
{
sa.Selected = false;
RemoveFromControl.Add(sa);
bool cont = ExistingSchedule.Contains(sa);
if (cont) {
int ind = ExistingSchedule.FindIndex(item => item.SubjectAssignments == sa.SubjectAssignments);
StudentSubject sti = new StudentSubject()
{
StudentSY = controlStudentId + SY,
SubjectCode = ExistingSchedule[ind].SubjectCode,
SubjectAssignments = ExistingSchedule[ind].SubjectAssignments,
StudentEnrSubCode = controlStudentId + SY + ExistingSchedule[ind].SubjectCode,
LockFirst = false,
LockSecond = false,
LockThird = false,
LockFourth = false,
FirstPeriodicRating = 0.00,
SecondPeriodicRating = 0.00,
ThirdPeriodicRating = 0.00,
FourthPeriodicRating = 0.00
};
ExistingSchedRemove.Add(sti);
}
else
subjects.Remove(ss);
AddFromAll.Add(sa);
}
}
private void cbEditor1_ValueChanged(object sender, EventArgs e)
{
StudentSchedule sa = new StudentSchedule();
int i = gvAllSchedules.CurrentRow.Index;
string subass = gvAllSchedules.Rows[i].Cells["SubjectAssignments"].Value.ToString();
int index = Schedules.FindIndex(item => item.SubjectAssignments == subass);
Schedules[index].Selected = false;
sa = Schedules[index];
RadCheckBoxEditor cbEditor1 = sender as RadCheckBoxEditor;
StudentSubject ss = new StudentSubject()
{
StudentSY = controlStudentId + SY,
SubjectCode = sa.SubjectCode,
SubjectAssignments = sa.SubjectAssignments,
StudentEnrSubCode = controlStudentId + SY + sa.SubjectCode,
LockFirst = false,
LockSecond = false,
LockThird = false,
LockFourth = false,
FirstPeriodicRating = 0.00,
SecondPeriodicRating = 0.00,
ThirdPeriodicRating = 0.00,
FourthPeriodicRating = 0.00
};
if ((Telerik.WinControls.Enumerations.ToggleState)cbEditor1.Value == Telerik.WinControls.Enumerations.ToggleState.On)
{
//foreach (StudentSchedule sc in ControlSchedule) {
// // if (sc.TimeslotInfo.Contains(sa.TimeslotInfo))
//}
sa.Selected = false;
AddFromControl.Add(sa);
subjects.Add(ss);
Schedules.Remove(sa);
}
else if ((Telerik.WinControls.Enumerations.ToggleState)cbEditor1.Value == Telerik.WinControls.Enumerations.ToggleState.Off)
{
sa.Selected = false;
ControlSchedule.Remove(sa);
subjects.Remove(ss);
AddFromAll.Add(sa);
}
}
private void frmControlSubjects_Load(object sender, EventArgs e)
{
RegistrationServiceClient registrationService = new RegistrationServiceClient();
string message = String.Empty;
ControlStudent = registrationService.GetStudent(controlStudentId,ref message);
StudentEnrollment enrStudent = new StudentEnrollment();
SY = GlobalClass.currentsy;
enrStudent = registrationService.GetStudentEnrolled(controlStudentId,SY);
EnrolMe.StudentSY = controlStudentId + SY;
int prev =Int32.Parse(SY.Substring(0,4));
prev--;
int sy = Int32.Parse(SY.Substring(5, 4));
sy--;
string prevSY = prev.ToString() + "-" + sy.ToString();
string prevRecord = controlStudentId + prevSY;
FailedSubjects = new List<StudentSubject>(registrationService.GetFailedSubjects(prevRecord));
StudentSubs = new List<StudentSubject>(registrationService.GetStudentSubjects(EnrolMe.StudentSY));
Schedules = new List<StudentSchedule>(registrationService.GetSubjectSchedules(SY));
if (StudentSubs.Count > 0)
{
ExistingSchedule = new List<StudentSchedule>(registrationService.GetStudentExistingSchedule(StudentSubs.ToArray(), SY));
}
if (ExistingSchedule.Count > 0) {
foreach (StudentSchedule ss in ExistingSchedule) {
int index = Schedules.FindIndex(item => item.SubjectAssignments == ss.SubjectAssignments);
Schedules.RemoveAt(index);
//StudentSubject s = new StudentSubject()
//{
// StudentSY = controlStudentId + SY,
// SubjectCode = ss.SubjectCode,
// SubjectAssignments = ss.SubjectAssignments,
// StudentEnrSubCode = controlStudentId + SY + ss.SubjectCode,
// LockFirst = false,
// LockSecond = false,
// LockThird = false,
// LockFourth = false,
// FirstPeriodicRating = 0.00,
// SecondPeriodicRating = 0.00,
// ThirdPeriodicRating = 0.00,
// FourthPeriodicRating = 0.00
//};
//subjects.Add(s);
}
}
gvAllSchedules.DataSource = Schedules;
gvFail.DataSource = FailedSubjects;
if (ControlStudent.UnitsFailedLastYear == 0 && StudentSubs.Count == 0)
{
int sectionCode = (int)enrStudent.GradeSectionCode;
Schedule = new List<StudentSchedule>(registrationService.GetSubjectsOfSection(sectionCode, SY));
foreach (StudentSchedule sch in Schedule) {
StudentSubject ss = new StudentSubject()
{
StudentSY = controlStudentId + SY,
SubjectCode = sch.SubjectCode,
SubjectAssignments = sch.SubjectAssignments,
StudentEnrSubCode = controlStudentId + SY + sch.SubjectCode,
LockFirst = false,
LockSecond = false,
LockThird = false,
LockFourth = false,
FirstPeriodicRating = 0.00,
SecondPeriodicRating = 0.00,
ThirdPeriodicRating = 0.00,
FourthPeriodicRating = 0.00
};
subjects.Add(ss);
}
ControlSchedule = Schedule;
GlobalClass.gvDatasource = 1;
gvSchedule.DataSource = ControlSchedule;
gvSchedule.ReadOnly = false;
}
else if (StudentSubs.Count > 0)
{
GlobalClass.gvDatasource = 2;
ControlSchedule = ExistingSchedule;
gvAllSchedules.ReadOnly = false;
gvSchedule.ReadOnly = false;
// btnSelect.Enabled = true;
gvSchedule.DataSource = ControlSchedule;
}
else if (ControlStudent.UnitsFailedLastYear > 0)
{
GlobalClass.gvDatasource = 3;
gvAllSchedules.ReadOnly = false;
gvSchedule.ReadOnly = false;
}
txtSection.Text = ControlStudent.Section;
txtSY.Text = SY;
txtGradeLevel.Text = ControlStudent.GradeLevel;
txtStudentId.Text = ControlStudent.StudentId;
txtStudentName.Text = ControlStudent.LastName + "," + ControlStudent.FirstName + " " + ControlStudent.MiddleName;
txtPrevGPA.Text = ControlStudent.Average.ToString();
txtUnitsFailed.Text = ControlStudent.UnitsFailedLastYear.ToString();
}
public List<StudentSubject> GetFailedSubjects(string IDSy)
{
List<StudentSubject> subs = new List<StudentSubject>();
List<StudentSubjectBDO> subsbdo = new List<StudentSubjectBDO>();
subsbdo= ssl.GetFailedSubjects(IDSy);
foreach (StudentSubjectBDO ssb in subsbdo) {
StudentSubject ss = new StudentSubject();
TranslateStuSubjectsBDOToStuSubjects(ssb, ss);
subs.Add(ss);
}
return subs;
}
public void TranslateStuSubjectsBDOToStuSubjects(StudentSubjectBDO sbdo, StudentSubject s)
{
SubjectService ss = new SubjectService();
Subject sub = new Subject();
ss.TranslateSubjectBDOToSubject(sbdo.Subject, sub);
s.SubjectCode = sbdo.SubjectCode;
s.Description = sub.Description;
RegistrationService rs = new RegistrationService();
StudentEnrollment se = new StudentEnrollment();
rs.TranslatEnrolBDOToEnrol(sbdo.StudentEnrollment, se);
s.StudentEnr = se;
s.StudentSY = sbdo.StudentSY;
s.StudentId = se.StudentId;
s.StudentName = se.StudentName;
s.StudentSubjectsID = sbdo.StudentSubjectsID;
s.StudentEnrSubCode = sbdo.StudentEnrSubCode;
s.Remarks = sbdo.Remarks;
s.FirstPeriodicRating = sbdo.FirstPeriodicRating;
s.SecondPeriodicRating = sbdo.SecondPeriodicRating;
s.ThirdPeriodicRating = sbdo.ThirdPeriodicRating;
s.FourthPeriodicRating = sbdo.FourthPeriodicRating;
s.Description = sub.Description;
s.SubjectAssignments = sbdo.SubjectAssignments;
s.FirstEntered = sbdo.FirstEntered;
s.FirstLocked = sbdo.FirstLocked;
s.FourthEntered = sbdo.FourthEntered;
s.FourthLocked = sbdo.FourthLocked;
s.LockFirst = sbdo.LockFirst;
s.LockFourth = sbdo.LockFourth;
s.LockSecond = sbdo.LockSecond;
s.LockThird = sbdo.LockThird;
s.SecondEntered = sbdo.SecondEntered;
s.SecondLocked = sbdo.SecondLocked;
s.ThirdEntered = sbdo.ThirdEntered;
s.ThirdLocked = sbdo.ThirdLocked;
s.FinalRating = (double)sbdo.FourthPeriodicRating;
if (s.FinalRating > 90)
s.Proficiency = "O";
else if (s.FinalRating >= 85)
s.Proficiency = "VS";
else if (s.FinalRating >= 80)
s.Proficiency = "S";
else if (s.FinalRating >= 75)
s.Proficiency = "FS";
else if (s.FinalRating <= 74)
s.Proficiency = "D";
}
