public async Task <IActionResult> Create(StudentForm model)
{
if (ModelState.IsValid)
{
string uniqueFileName = UploadedFile(model);
Student student = new Student
{
StudentId = model.Index,
FirstName = model.FirstName,
LastName = model.LastName,
EnrollmentDate = model.EnrollmentDate,
AcquiredCredits = model.AcquiredCredits,
CurrentSemestar = model.CurrentSemestar,
ProfilePicture = uniqueFileName,
EducationLevel = model.EducationLevel,
Enrollments = model.Courses
};
_context.Add(student);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public async Task <IActionResult> Create(TeacherCreateViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFileName = UploadedFile(model);
Teacher teacher = new Teacher
{
ID = model.ID,
firstName = model.firstName,
lastName = model.lastName,
degree = model.degree,
academicRank = model.academicRank,
officeNumber = model.officeNumber,
hireDate = model.hireDate,
profilePicture = uniqueFileName,
};
_context.Add(teacher);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", new { id = teacher.ID }));
}
return(View());
}
public async Task <IActionResult> Create([Bind("Name,Email,Street,City")] StudentAddViewModel viewModel)
{
if (ModelState.IsValid)
{
//Här använder vi oss av den statiska automapper
var student = Mapper.Map <Student>(viewModel);
//Har ersatts av Automapper
//var student = new Student
//{
// Name = viewModel.Name,
// Email = viewModel.Email,
// Address = new Address
// {
// Street = viewModel.Street,
// City = viewModel.City
// }
//};
_context.Add(student);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(viewModel));
}
// [ModelIsValidFilter]
public async Task <IActionResult> Create(StudentAddViewModel viewmodel)
{
if (ModelState.IsValid)
{
//var student = new Student
//{
// Avatar = faker.Internet.Avatar(),
// FirstName = viewmodel.FirstName,
// LastName = viewmodel.LastName,
// Email = viewmodel.Email,
// Adress = new Adress
// {
// Street = viewmodel.AdressStreet,
// City = viewmodel.AdressCity,
// ZipCode = viewmodel.AdressZipCode
// }
//};
var student = mapper.Map <Student>(viewmodel);
student.Avatar = faker.Internet.Avatar();
db.Add(student);
await db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(viewmodel));
}
public async Task <IActionResult> Create(int ScheduleId, [Bind("Id,LessonId,Num")] LessonToschedule lessonToschedule)
{
LessonToschedule lts = new LessonToschedule();
lts.LessonId = lessonToschedule.LessonId;
lessonToschedule.ScheduleId = ScheduleId;
lts.ScheduleId = ScheduleId;
lts.Num = lessonToschedule.Num;
// CHECK LESSONS FOR UNIQUENESS
var lessons = from l in _context.LessonToschedule
where l.ScheduleId == ScheduleId
select l.LessonId;
// CHECK LESSONS_NUM FOR UNIQUENESS
var l_nums = from l in _context.LessonToschedule
where l.ScheduleId == ScheduleId
select l.Num;
if (ModelState.IsValid && !lessons.Contains(lessonToschedule.LessonId) && !l_nums.Contains(lessonToschedule.Num) && lessonToschedule.Num > 0)
{
_context.Add(lts);
await _context.SaveChangesAsync();
return(RedirectToAction("Index", new { id = ScheduleId }));
}
return(RedirectToAction("Index", new { id = ScheduleId, error = "Не створено" }));
}
public async Task <IActionResult> PutTeacher(int id, Teacher teacher)
{
if (id != teacher.Id)
{
return(BadRequest());
}
_context.Entry(teacher).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TeacherExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutStudent(long id, Student student)
{
if (id != student.ID)
{
return(BadRequest());
}
_context.Entry(student).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <string> CreateUserRole(string userName, string password, string roleName)
{
var studentUser = new IdentityUser()
{
UserName = userName + roleName
};
try
{
await _userManager.CreateAsync(studentUser, password);
await _context.SaveChangesAsync();
await _userManager.AddToRoleAsync(studentUser, roleName);
await _context.SaveChangesAsync();
}
catch (Exception)
{
return(null);
}
var user = await _userManager.FindByNameAsync(userName + roleName);
return(user.Id);
}
public async Task <IHttpActionResult> PutCourseScheduled(int id, CourseScheduled courseScheduled)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != courseScheduled.CourseScheduledId)
{
return(BadRequest());
}
db.Entry(courseScheduled).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CourseScheduledExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> Create(
[Bind("LastName,FirstName,HireDate,OfficeAssignment")] Instructor instructor,
string[] selectedCourses)
{
if (selectedCourses != null)
{
instructor.CourseAssignments = new List <CourseAssignment>();
foreach (var course in selectedCourses)
{
var courseToAdd = new CourseAssignment
{
InstructorId = instructor.Id,
CourseId = int.Parse(course)
};
instructor.CourseAssignments.Add(courseToAdd);
}
}
if (ModelState.IsValid)
{
_context.Add(instructor);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
PopulateAssignedCourseData(instructor);
return(View(instructor));
}
public async Task <IActionResult> PutUniversityInfo(long id, UniversityInfo universityInfo)
{
if (id != universityInfo.Id)
{
return(BadRequest());
}
_context.Entry(universityInfo).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UniversityInfoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutCourse(int id, Course course)
{
if (id != course.CourseID)
{
return(BadRequest());
}
_context.Entry(course).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CourseExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutStudent([FromRoute] int id, [FromBody] Student student)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != student.Id)
{
return(BadRequest());
}
_context.Entry(student).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Create(StudentCreateViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFileName = UploadedFile(model);
Student student = new Student
{
ID = model.ID,
studentID = model.studentID,
firstName = model.firstName,
lastName = model.lastName,
enrollmentDate = model.enrollmentDate,
acquiredCredits = model.acquiredCredits,
currentSemestar = model.currentSemestar,
educationLevel = model.educationLevel,
profilePicture = uniqueFileName
};
_context.Add(student);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", new { ID = student.ID }));
}
return(View());
}
public async Task <IHttpActionResult> PutEnrollment(int id, Enrollment enrollment)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != enrollment.EnrollmentId)
{
return(BadRequest());
}
db.Entry(enrollment).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EnrollmentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task Delete(int id)
{
GroupModel group = _dbContext.Groups.FirstOrDefault(x => x.Id == id);
if (group != null)
{
_dbContext.Groups.Remove(group);
await _dbContext.SaveChangesAsync();
}
}
public virtual async Task <int> CreateAsync(T entity)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
await dbSet.AddAsync(entity);
return(await _ctx.SaveChangesAsync());
}
public async Task Delete(int id)
{
StudentModel student = _dbContext.Students.FirstOrDefault(x => x.Id == id);
if (student != null)
{
_dbContext.Students.Remove(student);
await _dbContext.SaveChangesAsync();
}
}
public async Task <ActionResult> CreateUniversity(University university)
{
_context.Universities.Add(university);
await _context.SaveChangesAsync();
return(Ok(university));
}
public async Task <IActionResult> Create([Bind("Id,StudentId,FirstName,LastName,EnrollmentDate,AcquiredCredits,CurrentSemester,EducationLevel")] Student student)
{
if (ModelState.IsValid)
{
_context.Add(student);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(student));
}
public async Task <IActionResult> Create([Bind("id,NumberCopies,Content,StudentMail")] Paper paper)
{
if (ModelState.IsValid)
{
_context.Add(paper);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(paper));
}
public async Task <IActionResult> Create([Bind("Id,Name,Author,Price")] Book book)
{
if (ModelState.IsValid)
{
_context.Add(book);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(book));
}
public async Task <IActionResult> Create([Bind("TypeOfDisciplineID,NameTypeOfDiscipline")] TypeOfDiscipline typeOfDiscipline)
{
if (ModelState.IsValid)
{
_context.Add(typeOfDiscipline);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(typeOfDiscipline));
}
public async Task <IActionResult> Create([Bind("ID,LastName,FirstMidName,HireDate")] Instructor instructor)
{
if (ModelState.IsValid)
{
_context.Add(instructor);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(instructor));
}
public async Task Add(string name, string lastName, int groupId)
{
var student = new Student();
student.Name = name;
student.LastName = lastName;
student.GroupId = groupId;
await _context.Students.AddAsync(student);
await _context.SaveChangesAsync();
}
public async Task <IActionResult> Create([Bind("Id,FirstName,LastName,Degree,AcademicRank,OfficeNumber,HireDate")] Teacher teacher)
{
if (ModelState.IsValid)
{
_context.Add(teacher);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(teacher));
}
public async Task <IActionResult> Create([Bind("FacultyID,NameFaculty")] Faculty faculty)
{
if (ModelState.IsValid)
{
_context.Add(faculty);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(faculty));
}
public async Task <IActionResult> Create([Bind("id,Studentid,Faculty,Course,Note")] StudentData studentData)
{
if (ModelState.IsValid)
{
_context.Add(studentData);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(studentData));
}
public async Task <IActionResult> Create([Bind("ID,LastName,FirstMidName,EnrollmentDate")] Student student)
{
if (ModelState.IsValid)
{
_context.Add(student);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(student));
}
public async Task <IActionResult> Create([Bind("Id,Title")] Course course)
{
if (ModelState.IsValid)
{
_context.Add(course);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(course));
}
