public ActionResult EditLesson(int courseInstanceId, int id, Lesson editedLesson)
{
Lesson lesson = db.Lesson.Where(l => l.ID == id).First();
if (lesson == null)
{
return(HttpNotFound());
}
CourseInstance courseInstance = db.CourseInstance.Where(c => c.ID == courseInstanceId).First();
if (courseInstance.BaseCourse.Teachers.Where(t => User.Identity.Name == t.UserName).FirstOrDefault() == null && !User.IsInRole("admin"))
{
ViewBag.Message = "У вас нет прав на редактирование этих материалов";
return(View("Error"));
}
lesson.Name = editedLesson.Name;
lesson.Description = editedLesson.Description;
lesson.Links = editedLesson.Links;
if (!ModelState.IsValid)
{
ViewBag.CourseId = courseInstanceId;
return(View(lesson));
}
db.SaveChanges();
return(RedirectToAction("CourseInstance", new { id = courseInstanceId }));
}
public ActionResult Create(int courseId, CourseInstanceCreateEdit newCourseInstance)
{
newCourseInstance.BaseCourse = db.Course.Where(c => c.ID == courseId).FirstOrDefault();
if (newCourseInstance.Year < 0 || newCourseInstance.BaseCourse == null)
{
return(View(newCourseInstance));
}
List <Person> studentsList = new List <Person>();
for (int i = 0; i < newCourseInstance.Chosen_Students.Count(); i++)
{
if (newCourseInstance.Chosen_Students[i])
{
string id = newCourseInstance.Students[i].Id;
Person student = db.Users.Where(p => p.Id == id).FirstOrDefault();
studentsList.Add(student);
}
}
var courseInstance = new CourseInstance {
Year = newCourseInstance.Year,
AdditionalDescription = newCourseInstance.AdditionalDescription,
BaseCourse = newCourseInstance.BaseCourse,
Place = newCourseInstance.Place,
Report_Date = newCourseInstance.Report_Date,
Students = studentsList,
};
db.CourseInstance.Add(courseInstance);
db.SaveChanges();
return(RedirectToAction("course", "Courses", new { id = courseId }));
}
public async Task <InstanceDto> AddIUniClass(InstanceDto instanceDto)
{
string attendenSubstring = Guid.NewGuid().ToString().Trim('-').Substring(0, 7);
switch (instanceDto.UniClassType)
{
case UniClassType.Course:
CourseInstance course = new CourseInstance()
{
Description = instanceDto.Description,
AttendenceCode = attendenSubstring,
Date = instanceDto.Date,
Name = instanceDto.Name,
ProfId = instanceDto.ProfId,
SubjectId = instanceDto.SubjectId,
UniClassType = UniClassType.Course
};
course = await Repository.InsertAsync(course);
return(ObjectMapper.Map <InstanceDto>((IUniClass)course));
break;
}
return(null);
}
public async Task CourseInstancesDetailsAsync_WithValidCourseInstance_ShouldReturnCorrectDetails()
{
// Arrange
const int expectedId = 1;
const string expecterName = "First course";
var courseInstance = new CourseInstance
{
Id = expectedId,
Name = expecterName
};
this.context.CourseInstances.Add(courseInstance);
await this.context.SaveChangesAsync();
this.courseInstancesRepositoryMock
.Setup(m => m.Details())
.Returns(this.context.CourseInstances)
.Verifiable();
var service = new AdminCourseInstancesService(this.courseInstancesRepositoryMock.Object, this.mapper);
// Act
var result = await service.CourseInstancesDetailsAsync <DetailsCourseInstanceViewModel>(expectedId);
// Assert
Assert.NotNull(result);
Assert.Equal(expectedId, result.Id);
Assert.Equal(expecterName, result.Name);
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
/// <summary>
/// Course department view page.
/// </summary>
/// <param name="Dept"></param>
/// <param name="Num"></param>
/// <param name="Sem"></param>
/// <param name="Year"></param>
/// <returns></returns>
public async Task <IActionResult> Course(string Dept, int?Num, string Sem, int?Year)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
if (Dept.Equals(null) || Num == null || Sem.Equals(null) || Year == null)
{
return(View("Error", new ErrorViewModel()
{
ErrorMessage = "Insufficient information to locate course."
}));
}
CourseInstance course = _context.CourseInstance.Where(c => c.Department == Dept && c.Number == Num &&
c.Semester == Sem && c.Year == Year)
.Include(c => c.CourseNotes)
.Include(c => c.LearningOutcomes)
.ThenInclude(lo => lo.EvaluationMetrics)
.ThenInclude(em => em.SampleFiles)
.Include(c => c.LearningOutcomes)
.ThenInclude(lo => lo.LONotes)
.FirstOrDefault();
if (course == null)
{
return(Forbid());
}
return(View("Course", course));
}
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CourseInstance course = this.Data.CourseInstances
.All(new string[] { "Course" }).Where(c => c.Id == id).FirstOrDefault();
if (course == null)
{
return(HttpNotFound());
}
PublicCourseModel courseModel = new PublicCourseModel()
{
Description = course.Course.Description,
Id = course.Id,
LecturerName = course.Course.Lecturer,
Title = course.Course.Title,
EnrolledCount = this.Data.CourseInstances
.All(new string[] { "Course" })
.Where(c => c.Course.Id == id)
.Count(),
StartDate = course.StartDate,
EndDate = course.EndDate
};
return(View(courseModel));
}
/// <summary>
/// Return a webpage containing information about the selected course.
/// </summary>
/// <param name="Dept"></param>
/// <param name="Num"></param>
/// <param name="Sem"></param>
/// <param name="Year"></param>
/// <returns></returns>
public async Task <IActionResult> Course(string Dept, int?Num, string Sem, int?Year)
{
if (Dept == null || Num == null || Sem.Equals(null) || Year == null)
{
return(View("Error", new ErrorViewModel()
{
ErrorMessage = "Insufficient information to locate course."
}));
}
//Retrieves the associated course, the user must be an instructor of the course, or the course must be archived.
CourseInstance course = _context.CourseInstance.Where(c => c.Department == Dept && c.Number == Num &&
c.Semester == Sem && c.Year == Year)
.Include(c => c.CourseNotes)
.Include(c => c.Instructors).ThenInclude(i => i.User)
.Include(c => c.LearningOutcomes).ThenInclude(lo => lo.EvaluationMetrics).ThenInclude(em => em.SampleFiles)
.Include(c => c.LearningOutcomes).ThenInclude(lo => lo.LONotes)
.Include(c => c.Status)
.Where(c => c.Instructors.Where(i => i.User.UserLoginEmail == User.Identity.Name).Any() || c.Status.Status == CourseStatusNames.Archived)
.FirstOrDefault();
if (course == null)
{
return(Forbid());
}
return(View("Course", course));
}
public FullOpportunityListModel(CourseInstance opportunity, DateTime?lastStartDate, Constants.OpportunityFilterDateStatus?opportunityDateStatus) : this()
{
this.OpportunityId = opportunity.CourseInstanceId;
this.CourseId = opportunity.CourseId;
this.Status = opportunity.RecordStatu.RecordStatusName;
this.RecordStatusId = opportunity.RecordStatusId;
this.CourseTitle = opportunity.Course.CourseTitle;
this.CourseDetails = this.CourseTitle;
if (opportunity.Course.LearningAim != null)
{
this.CourseDetails = String.IsNullOrWhiteSpace(opportunity.Course.LearningAim.Qualification) ?
String.Format("{0} | {1}", opportunity.Course.CourseTitle, opportunity.Course.LearningAim.LearningAimTitle) :
String.Format("{0} | {1} | {2}", opportunity.Course.CourseTitle, opportunity.Course.LearningAim.LearningAimTitle, opportunity.Course.LearningAim.Qualification);
}
//TODO - CHECK WITH STEVE WHETHER WE WANT LONG PRICE DISPLAYING
//Populate opportunity details
this.OpportunityDetails = opportunity.GetOpportunityDetails();
this.DateStatus = opportunityDateStatus;
this.StartDate = String.Join(", ", opportunity.CourseInstanceStartDates.Select(d => d.StartDate.ToShortDateString()));
this.LastUpdate = opportunity.ModifiedDateTimeUtc ?? opportunity.CreatedDateTimeUtc;
//We cannot enable automatic advance start dates functionality unless the opportunity has a single start date
this.CanAdvanceStartDate = opportunity.CourseInstanceStartDates != null && opportunity.CourseInstanceStartDates.Count == 1;
}
public async Task CreateCourseInstanceAsync_WithValidCourseInstance_ShouldAddCourseInstance()
{
// Arrange
const string name = "Course test";
const string slug = "course-test";
var courseInstance = new CourseInstance
{
Name = name,
Slug = slug
};
this.courseInstancesRepositoryMock
.Setup(x => x.AddAsync(courseInstance))
.Returns(Task.CompletedTask)
.Verifiable();
var service = new AdminCourseInstancesService(this.courseInstancesRepositoryMock.Object, this.mapper);
// Act
var result = await service.CreateCourseIntancesAsync(courseInstance);
// Assert
Assert.Equal(name, courseInstance.Name);
}
private async Task EndCourseAsync(int courseInstanceId)
{
CourseInstance courseInstance = await _context.FindAsync <CourseInstance>(courseInstanceId);
courseInstance.EndedAt = DateTime.Now;
await SaveChangesAsync();
}
public ActionResult EnrollUser(EnrollmentModel model)
{
if ((model.StartDate != null) && (model.EndDate != null) &&
(model.StartDate.Value.CompareTo(model.EndDate) > 0))
{
ModelState.AddModelError("EndDate", "Start date must preceed end date.");
return(View("Index", model));
}
var course = this.Data.Courses.GetById(model.CourseId);
var user = this.Data.Users.All().FirstOrDefault(u => u.Id == model.Id);
var courseInstance = new CourseInstance()
{
User = user,
Course = course,
Mark = null,
StartDate = model.StartDate,
EndDate = model.EndDate
};
this.Data.CourseInstances.Add(courseInstance);
this.Data.SaveChanges();
model.Message = "User enrolled";
return(View("Index", model));
}
/// <summary>
/// Sets the course status to in-review for the given course.
/// </summary>
/// <param name="courseId"></param>
/// <returns></returns>
public async Task <IActionResult> SetReviewCourse(int?courseId, string message)
{
if (courseId == null)
{
return(new JsonResult(new { success = false }));
}
CourseInstance course = await _context.CourseInstance.Include(c => c.Status)
.Include(c => c.Instructors).ThenInclude(i => i.User)
.Where(c => c.CourseInstanceId == courseId).FirstOrDefaultAsync();
CourseStatus inRev = _context.CourseStatus.Where(s => s.Status == CourseStatusNames.InReview).FirstOrDefault();
if (inRev == null)
{
return(new JsonResult(new { success = false }));
}
course.Status = inRev;
//Notify Instructors
foreach (Instructors inst in course.Instructors)
{
Notifications notify = new Notifications()
{
CourseInstance = course,
User = inst.User,
Text = "The course status was set to in-review. Chair message: " + message,
DateNotified = DateTime.Now,
Read = false
};
_context.Notifications.Add(notify);
}
_context.SaveChanges();
return(new JsonResult(new { success = true }));
}
/// <summary>
/// Sets the course status to approved for the given course.
/// </summary>
/// <param name="courseId"></param>
/// <returns></returns>
public async Task <IActionResult> ApproveCourse(int?courseId)
{
if (courseId == null)
{
return(new JsonResult(new { success = false }));
}
CourseInstance course = await _context.CourseInstance.Include(c => c.Status).Include(c => c.Instructors).ThenInclude(i => i.User)
.Where(c => c.CourseInstanceId == courseId).FirstOrDefaultAsync();
CourseStatus complete = _context.CourseStatus.Where(s => s.Status == CourseStatusNames.Complete).FirstOrDefault();
if (complete == null)
{
return(new JsonResult(new { success = false }));
}
course.Status = complete;
//Notify Instructors
foreach (Instructors inst in course.Instructors)
{
Notifications notify = new Notifications()
{
CourseInstance = course,
User = inst.User,
Text = "This course was approved.",
DateNotified = DateTime.Now,
Read = false
};
_context.Notifications.Add(notify);
}
_context.SaveChanges();
return(new JsonResult(new { success = true }));
}
public IActionResult OnGet(int id)
{
var currentUser = this.userManager.GetUserAsync(this.User).Result;
this.CourseInstance = this.contex.CourseInstances.FirstOrDefault(ci => ci.Id == id);
// bool hasSuchUser = this.CourseInstance.Students.Any(ci => ci.StudentId == currentUser.Id);
if (this.CourseInstance == null)
{
return(RedirectToPage("NoInsyances"));
}
bool hasSuchUser = this.contex.StudentsInCourses.Any(c => c.CourseId == CourseInstance.Id && c.StudentId == currentUser.Id);
if (hasSuchUser)
{
return(RedirectToPage("AlreadyEnrolled"));
}
var studentInCourse = new StudentsInCourses()
{
StudentId = currentUser.Id,
CourseId = this.CourseInstance.Id
};
this.contex.StudentsInCourses.Add(studentInCourse);
this.CourseInstance.Students.Add(studentInCourse);
this.contex.SaveChanges();
return(Page());
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Name,Description,Department,Number,Semester,Professor")] CourseInstance courseInstance)
{
if (id != courseInstance.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(courseInstance);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CourseInstanceExists(courseInstance.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(courseInstance));
}
public async Task CreateInstance(int courseId, int semesterId)
{
if (!context.Course.Any(_ => _.Id == courseId))
{
throw new ValidationException("Requested course doesn't exist.");
}
if (!context.Semester.Any(_ => _.Id == semesterId))
{
throw new ValidationException("Requested semester doesn't exist.");
}
if (context.CourseInstance.Any(_ => _.SemesterId == semesterId && _.CourseId == courseId))
{
throw new ValidationException("Course instance already exists.");
}
var courseInstance = new CourseInstance
{
CourseId = courseId,
SemesterId = semesterId
};
await context.CourseInstance.AddAsync(courseInstance);
await context.SaveChangesAsync();
}
public void Create_Instance_Should_Also_Add_A_New_Course()
{
// Arrange
var newCourse = new Course()
{
Id = 5, Title = "Fifth title", Code = "Fifth Code", Duration = 3
};
var newInstance = new CourseInstance()
{
Id = 5, StartDate = DateTime.Parse("24-03-2021"), Course = newCourse
};
// Act
var created = _repository.Create(newInstance).Result;
var courseInstances = _repository.GetAllCourseInstances().Result;
var result = courseInstances.Count();
// Assert
int expectedCount = 5;
Assert.IsInstanceOfType(created, typeof(CourseInstance));
Assert.AreEqual(expectedCount, result);
Assert.IsInstanceOfType(courseInstances[4].Course, typeof(Course));
Assert.IsNotNull(courseInstances[4].Course.Title);
Assert.IsNotNull(courseInstances[4].Course.Duration);
}
public static void Initialize(CourseContext context)
{
context.Database.EnsureCreated();
// Look for any students.
if (context.Courses.Any())
{
return; // DB has been seeded
}
var courses = new CourseDescription[]
{
new CourseDescription {
Description = "Coding class 1"
},
new CourseDescription {
Description = "Another coding class 2"
},
new CourseDescription {
Description = "Another coding class 3"
},
new CourseDescription {
Description = "Another coding class 4"
},
new CourseDescription {
Description = "Another coding class 5"
}
};
foreach (CourseDescription c in courses)
{
context.Description.Add(c);
}
context.SaveChanges();
var coursesList = new CourseInstance[]
{
new CourseInstance {
ID = 1, Dept = "Computer Science", Number = 1410, Semester = "Fall", Year = 2019, Description = courses[1]
},
new CourseInstance {
ID = 2, Dept = "Computer Science", Number = 2420, Semester = "Fall", Year = 2019, Description = courses[1]
},
new CourseInstance {
ID = 3, Dept = "Computer Science", Number = 2420, Semester = "Spring", Year = 2020, Description = courses[1]
},
new CourseInstance {
ID = 4, Dept = "Computer Science", Number = 3500, Semester = "Fall", Year = 2019, Description = courses[3]
},
new CourseInstance {
ID = 5, Dept = "Computer Science", Number = 3505, Semester = "Fall", Year = 2019, Description = courses[3]
},
};
foreach (CourseInstance s in coursesList)
{
context.Courses.Add(s);
}
context.SaveChanges();
}
public async Task <IActionResult> Create([Bind("Name,Description,Department,Number,Semester,Year,StatusId,DueDate")] CourseInstance courseInstance, string[] instructors)
{
if (ModelState.IsValid)
{
_context.Add(courseInstance);
if (instructors != null)
{
foreach (string instructor in instructors)
{
UserLocator instr = _context.UserLocator.Where(u => u.UserLoginEmail == instructor).FirstOrDefault();
if (instr != null)
{
_context.Instructors.Add(new Instructors()
{
CourseInstance = courseInstance, User = instr
});
}
}
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["CourseInstanceId"] = new SelectList(_context.CourseInstance, "CourseInstanceId", "Department", courseInstance.CourseInstanceId);
return(View(courseInstance));
}
public async Task GetExistingCourseInstanceShouldReturnCourseInstance()
{
//Arrange
var fixture = new CourseInstanceRepositoryFixture()
.WithXCourseInstances(1);
CourseInstance expected = new CourseInstance()
{
Course = new Course()
{
CourseId = 1, Code = "C1", LengthInDays = 5, Title = "Course1"
}, StartDate = DateTime.Now.Date, CourseInstanceId = 1
};
//Act
var result = await fixture.ExecuteGet(new CourseInstance()
{
Course = new Course()
{
Code = "C1"
}, StartDate = DateTime.Now.Date
});
//Assert
expected.Should().BeEquivalentTo(result);
}
public async Task DeleteCourseInstanceAsync(int idCourseInstance)
{
await CheckAccessToCourseInstance(idCourseInstance);
CourseInstance instance = await _context.FindAsync <CourseInstance>(idCourseInstance);
IList <CourseInstanceQuestionOption> courseInstanceQuestionOptions =
await _context.CourseInstancesQuestionOption
.Where(x => x.CourseInstanceQuestion.CourseInstance.Id == instance.Id)
.ToListAsync();
foreach (CourseInstanceQuestionOption courseInstanceQuestionOption in courseInstanceQuestionOptions)
{
_context.CourseInstancesQuestionOption.Remove(courseInstanceQuestionOption);
}
IList <CourseInstanceQuestion> coureInstanceQuestions = await _context.CourseInstancesQuestion
.Where(x => x.CourseInstance.Id == instance.Id)
.ToListAsync();
foreach (CourseInstanceQuestion courseInstanceQuestion in coureInstanceQuestions)
{
_context.Remove(courseInstanceQuestion);
}
_context.Remove(instance);
await SaveChangesAsync();
}
/// <summary>
/// Create a course from given NewCourseViewModel
/// </summary>
public bool CreateCourse(AdminNewCourseViewModel newCourseViewModel)
{
var course = _db.Courses.SingleOrDefault(x => x.Name == newCourseViewModel.Name);
Course newCourse = new Course {
Name = newCourseViewModel.Name,
Description = newCourseViewModel.Description
};
if (course == null)
{
course = _db.Courses.Add(newCourse);
}
CourseInstance newCourseInstance = new CourseInstance()
{
CourseId = course.Id,
Year = newCourseViewModel.Year,
SemesterId = newCourseViewModel.Semester
};
_db.CourseInstances.Add(newCourseInstance);
try {
_db.SaveChanges();
return(true);
}
catch (Exception e) {
return(false);
}
}
public void CreateCourse(NewCourseViewModel newCourseViewModel)
{
var _course = _db.Courses.SingleOrDefault(x => x.Name == newCourseViewModel.Name);
Course newCourse = new Course()
{
Name = newCourseViewModel.Name,
Description = newCourseViewModel.Description
};
if (_course == null)
{
_course = _db.Courses.Add(newCourse);
}
CourseInstance newCourseInstance = new CourseInstance()
{
CourseId = _course.Id,
Year = newCourseViewModel.Year,
SemesterId = newCourseViewModel.Semester
};
try
{
_db.SaveChanges();
} catch (Exception e)
{
// halp
return;
}
}
public ActionResult Remove(int courseId, int id, bool cameFromCoursePage)
{
CourseInstance courseInstance = db.CourseInstance.Where(c => c.ID == id).First();
if (courseInstance == null)
{
return(HttpNotFound());
}
Course course = db.Course.Where(c => c.ID == courseId).First();
if (course.Teachers.Where(t => User.Identity.Name == t.UserName).FirstOrDefault() == null && !User.IsInRole("admin"))
{
ViewBag.Message = "У вас нет прав на редактирование этих материалов";
return(View("Error"));
}
courseInstance.Students.Clear();
courseInstance.Lessons.Clear();
db.CourseInstance.Remove(courseInstance);
db.SaveChanges();
if (cameFromCoursePage)
{
return(RedirectToAction("course", "Courses", new { id = courseId }));
}
else
{
return(RedirectToAction("CourseInstance", new { id = id }));
}
}
public OpportunityListModel(CourseInstance courseInstance) : this()
{
this.OpportunityId = courseInstance.CourseInstanceId;
this.Status = courseInstance.RecordStatu.RecordStatusName;
this.OpportunityDetails = courseInstance.GetOpportunityDetails();
this.LastUpdate = courseInstance.ModifiedDateTimeUtc ?? courseInstance.CreatedDateTimeUtc;
}
public async Task <CourseInstance> Create(CourseInstance instance)
{
_context.Add(instance);
await _context.SaveChangesAsync();
return(instance);
}
public AdvanceStartDatesNotUpdated(CourseInstance opportunity)
{
this.CourseTitle = opportunity.Course.CourseTitle;
this.OpportunityId = opportunity.CourseInstanceId;
this.StartDate = String.Join(", ", opportunity.CourseInstanceStartDates.Select(d => d.StartDate.ToShortDateString()));
this.OpportunityDetails = opportunity.GetOpportunityDetails(false, false);
}
static void Main(string[] args)
{
using (efCoreMVCContext DB = new efCoreMVCContext())
{
// List<Course> c = DB.Course.ToList();
// // CourseType cy = DB.CourseTypes.Single();
// CourseType ct = DB.CourseTypes.First(u => u.CourseTypeID == "1");
// DB.CourseTypes.Remove(ct);
// Console.WriteLine(DB.Entry(ct).State);
// Console.WriteLine(DB.Entry(c.First()).State);
// Console.WriteLine(DB.Entry(c.First().CourseType).State);
// DB.SaveChanges();
// Console.WriteLine(DB.Entry(ct).State);
// Console.WriteLine(DB.Entry(c.First()).State);
// Console.WriteLine(DB.Entry(c.First().CourseType).State);
CourseInstance c = DB.Set <CourseInstance>().Include(u => u.Course.CourseType).Single(u => u.InstanceID == "1");
CourseInstance c1 = DB.Set <CourseInstance>().Include(u => u.Course.CourseType).Single(u => u.InstanceID == "2");
Console.WriteLine(c.Course.CourseType.GetHashCode());
Console.WriteLine(c1.Course.CourseType.GetHashCode());
}
Console.WriteLine("ok");
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Dept,Number,Semester,Year,DescriptionID")] CourseInstance courseInstance)
{
if (id != courseInstance.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(courseInstance);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CourseInstanceExists(courseInstance.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["Id"] = new SelectList(_context.Description, "DescriptionId", "DescriptionId", courseInstance.ID);
return(View(courseInstance));
}
public ActionResult Edit(int courseId, int id, bool cameFromCoursePage)
{
ViewBag.CourseID = courseId;
ViewBag.CameFromCoursePage = cameFromCoursePage;
CourseInstance courseInstance = db.CourseInstance.Where(ci => ci.ID == id).First();
if (courseInstance == null)
{
return(HttpNotFound());
}
Course course = db.Course.Where(cs => cs.ID == courseId).First();
if (course.Teachers.Where(t => User.Identity.Name == t.UserName).FirstOrDefault() == null && !User.IsInRole("admin"))
{
ViewBag.Message = "У вас нет прав на редактирование этих материалов";
return(View("Error"));
}
CourseInstanceCreateEdit c = new Models.CourseInstanceCreateEdit();
c.ID = courseInstance.ID;
c.Year = courseInstance.Year;
c.BaseCourse = courseInstance.BaseCourse;
c.AdditionalDescription = courseInstance.AdditionalDescription;
c.Place = courseInstance.Place;
c.Report_Date = courseInstance.Report_Date;
List <Person> students = new List <Person>();
foreach (Person p in db.Users)
{
if (p.Person_Type == "Student")
{
students.Add(p);
}
}
c.Chosen_Students = new bool[students.Count];
c.Students = students.ToArray();
for (int i = 0; i < students.Count; i++)
{
if (courseInstance.Students != null)
{
if (courseInstance.Students.Where(t => t.Id == c.Students[i].Id).FirstOrDefault() != null)
{
c.Chosen_Students[i] = true;
}
else
{
c.Chosen_Students[i] = false;
}
}
else
{
c.Chosen_Students[i] = false;
}
}
return(View(c));
}
