public async Task <IActionResult> AddDepartment([Bind("DepartmentId,DepartmentName,DepartmentCode")] Department department)
{
if (ModelState.IsValid)
{
if (department.DepartmentId == 0)
{
if (DepartmentExist(department.DepartmentCode))
{
ViewData["Message"] = "Department code is already exist.";
return(View(department));
}
else
{
_context.Departments.Add(department);
}
}
else
{
_context.Update(department);
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
List <Department> departments = await _context.Departments.ToListAsync();
ViewData["Deparments"] = departments;
return(View());
}
public async Task <IActionResult> Edit(int id, [Bind("StudentId,Name,Address,Email,MatriNo")] Student student)
{
if (id != student.StudentId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(student);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentExists(student.Email))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(student));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,StudentID,Name,Period,InClass,TimeLastCheckedIn,TimeLastCheckedOut,AttendaceStatus")] Student student)
{
if (id != student.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
StudentDatabaseContext.Update(student);
await StudentDatabaseContext.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentExists(student.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(student));
}
public async Task <bool> UpdateAsync(Student student)
{
try
{
var originModel = _context.students
.Where(u => u.StudentId == student.StudentId)
.SingleOrDefault();
if (originModel == null)
{
return(false);
}
originModel.Name = student.Name;
originModel.LastName = student.LastName;
originModel.Bio = student.Bio;
_context.Update(originModel);
var saveSure = await _context.SaveChangesAsync();
return(saveSure == 1);
}
catch (Exception)
{
return(false);
}
}
public async Task <ActionResult <Student> > Update(Guid id, [Bind("FirstName,LastName, Program")] StudentBase studentBase)
{
Student student = new Student
{
FirstName = studentBase.FirstName,
LastName = studentBase.LastName,
Program = studentBase.Program
};
if (!StudentExists(id))
{
//student.ID = id;
//_context.Add(student);
//await _context.SaveChangesAsync();
//return CreatedAtAction(nameof(GetById), new { id = student.ID }, student);
return(NotFound());
}
Student dbStudent = await _context.Students.FindAsync(id);
dbStudent.FirstName = student.FirstName;
dbStudent.LastName = student.LastName;
dbStudent.Program = student.Program;
_context.Update(dbStudent);
await _context.SaveChangesAsync();
return(Ok(dbStudent));
}
public async Task <ActionResult <Student> > Update(Guid id, [Bind("FirstName,LastName,Program")] StudentBase studentBase)
{
Student student = new Student
{
FirstName = studentBase.FirstName,
LastName = studentBase.LastName,
Program = studentBase.Program
};
if (!StudentExists(id))
{
Response.StatusCode = 404;
return(View());
}
Student dbStudent = await _context.Student.FindAsync(id);
dbStudent.FirstName = student.FirstName;
dbStudent.LastName = student.LastName;
dbStudent.Program = student.Program;
_context.Update(dbStudent);
await _context.SaveChangesAsync();
return(Ok(dbStudent));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,FirstName,LastName,Age,Address,CourseId")] Student student)
{
if (id != student.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(student);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentExists(student.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CourseId"] = new SelectList(_context.Courses, "Id", "Id", student.CourseId);
return(View(student));
}
public bool UpdateStudent(int Id, Student currStudent)
{
var currStd = studentDBContext.Students.FirstOrDefault(std => std.Id == Id);
if (currStd == null)
{
return(false);
}
else
{
try
{
currStd.Name = currStudent.Name;
//currStd.Course = currStudent.Course;
studentDBContext.Update(currStd);
studentDBContext.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
//throw new NotImplementedException();
}
public async Task <IActionResult> Edit(int id, [Bind("Id,CourseName")] Course course)
{
if (id != course.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(course);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CourseExists(course.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(course));
}
public async Task <ActionResult <Student> > Update(Guid ID, [Bind("FirstName,LastName,Program")] StudentBase studentBase)
{
Student student = new Student
{
FirstName = studentBase.FirstName,
LastName = studentBase.LastName,
Program = studentBase.Program
};
if (!StudentExists(ID))
{
return(NotFound("Student not found"));
}
Student dbStudent = await _context.Students.FindAsync(ID);
dbStudent.FirstName = student.FirstName;
dbStudent.LastName = student.LastName;
dbStudent.Program = student.Program;
_context.Update(dbStudent);
await _context.SaveChangesAsync();
return(Ok(dbStudent));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ProductName,Stock")] Product product)
{
if (id != product.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(product);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductExists(product.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(product));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,UserName,Password")] User user)
{
if (id != user.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(user);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(user.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(user));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,Age,Course,Email,Contact")] Students students)
{
if (id != students.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(students);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentsExists(students.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(students));
}
public void ModifyStudent(Student student)
{
var st = _context.Student.FirstOrDefault(st => st.IndexNumber.Equals(student.IndexNumber));
if (st == null)
{
throw new Exception();
}
st.FirstName = student.FirstName != null ? student.FirstName : st.FirstName;
st.LastName = student.LastName != null ? student.LastName : st.LastName;
st.BirthDate = student.BirthDate != null ? student.BirthDate : st.BirthDate;
_context.Update(st);
_context.SaveChanges();
}
public async Task <IActionResult> AddOrEdit([Bind("Id,FullName,RegistrationNo,DepartmentId,Roll")] Student student)
{
if (ModelState.IsValid)
{
if (student.Id == 0)
{
_context.Add(student);
}
else
{
_context.Update(student);
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(student));
}
public async Task <IActionResult> AddOrEdit([Bind("Id,Name,Code")] Department department)
{
if (ModelState.IsValid)
{
if (department.Id == 0)
{
_context.Add(department);
}
else
{
_context.Update(department);
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(department));
}
public async Task <ActionResult <Student> > Update(Guid id, [Bind("FirstName, LastName, Program")] StudentBase studentBase)
{
if (!StudentExists(id))
{
StatusCodeResult temp = new NotFoundResult();
return(temp);
}
Student dbStudent = await _context.Students.FindAsync(id);
dbStudent.FirstName = studentBase.FirstName;
dbStudent.LastName = studentBase.LastName;
dbStudent.Program = studentBase.Program;
_context.Update(dbStudent);
await _context.SaveChangesAsync();
return(Ok(dbStudent));
}
public bool Update(Student model)
{
try
{
var originalModel = _context.Students.Single(x => x.StudentId == model.StudentId);
originalModel.Name = model.Name;
originalModel.LastName = model.LastName;
originalModel.Bio = model.Bio;
_context.Update(model);
_context.SaveChanges();
}
catch (System.Exception)
{
return(false);
}
return(true);
}
public async Task <ActionResult <Student> > Upsert(Guid id, [Bind("FirstName,LastName,Program")] StudentBase studentBase)
{
Student stu = new Student
{
FirstName = studentBase.FirstName,
LastName = studentBase.LastName,
Program = studentBase.Program
};
Student dbStu = await _context.Students.FindAsync(id);
dbStu.FirstName = stu.FirstName;
dbStu.LastName = stu.LastName;
dbStu.Program = stu.Program;
_context.Update(dbStu);
await _context.SaveChangesAsync();
return(Ok(dbStu));
}
public bool Update(Student model)
{
try
{
var originalModel = _studentDbContext.Student.Single(x =>
x.studentId == model.studentId
);
originalModel.name = model.name;
originalModel.lastName = model.lastName;
originalModel.bio = model.bio;
_studentDbContext.Update(originalModel);
_studentDbContext.SaveChanges();
}
catch (System.Exception)
{
return(false);
}
return(true);
}
public async Task <ActionResult <Student> > Update(Guid id, [Bind("FirstName,LastName,Program")] StudentBase studentBase)
{
Student student = new Student
{
FirstName = studentBase.FirstName,
LastName = studentBase.LastName,
Program = studentBase.Program
};
if (!_context.Students.Any(e => e.ID == id))
{
return(NotFound());
}
Student dbStudent = await _context.Students.FindAsync(id);
dbStudent.FirstName = student.FirstName;
dbStudent.LastName = student.LastName;
dbStudent.Program = student.Program;
_context.Update(dbStudent);
await _context.SaveChangesAsync();
return(Ok(dbStudent));
}
public void ModifyStudent(Student student)
{
db.Update(student);
db.SaveChanges();
}
