public async Task TestAddNonNullEntity()
{
// Arrange
var options = TestUtilities.BuildTestDbOptions();
var testEntity = new ClassSession();
await using (var context = new ApplicationDbContext(options))
{
context.Database.EnsureCreated();
var repository = new ClassSessionRepository(context);
Assert.Empty(context.ClassSession);
// Act
repository.Add(testEntity);
context.SaveChanges();
}
// Assert
await using (var context = new ApplicationDbContext(options))
{
Assert.Single(context.ClassSession);
context.Database.EnsureDeleted();
}
}
public async Task <IActionResult> PutClassSession(int id, ClassSession classSession)
{
if (id != classSession.Id)
{
return(BadRequest());
}
_context.Entry(classSession).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClassSessionExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
ClassInfomation ConvertStringsToInfo(string[] contents, string date, ClassSession session, FetchType type)
{
if (contents == null)
{
return(new ClassInfomation());
}
switch (type)
{
case FetchType.Teacher:
return(new ClassInfomation()
{
date = DateTime.Parse(date),
session = session,
classCode = contents[0],
className = contents[1],
classRoom = contents[2]
});
case FetchType.ClassCode:
return(new ClassInfomation()
{
date = DateTime.Parse(date),
session = session,
teacher = contents[0],
className = contents[1],
classRoom = contents[2]
});
default:
throw new Exception();
}
}
public async Task <ActionResult <ClassSession> > PostClassSession(ClassSession classSession)
{
_context.ClassSessions.Add(classSession);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetClassSession", new { id = classSession.Id }, classSession));
}
public async Task <IActionResult> Edit(int id, [Bind("classSessionId,fitnessClassId,ClassSessionStartTime,locationId")] ClassSession classSession)
{
if (id != classSession.classSessionId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(classSession);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClassSessionExists(classSession.classSessionId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["fitnessClassId"] = new SelectList(_context.FitnessClasses, "fitnessclassId", "fitnessclassId", classSession.fitnessClassId);
ViewData["locationId"] = new SelectList(_context.Locations, "locationId", "locationId", classSession.locationId);
return(View(classSession));
}
public ActionResult DropIn(int id, DateTime date)
{
ViewBag.ClassSessionId = id;
ViewBag.Date = date;
ClassSession classSession = db.GetDbSet <ClassSession>().Find(id);
var members = (from mem in db.GetDbSet <Member>().Include("DisciplineEnrolledMembers")
where !mem.IsArchived &&
!mem.DisciplineEnrolledMembers.Any(d => d.DisciplineId == classSession.DisciplineId)
select mem).ToList();
// Get list of currentSheets
var curSheets = (from sheet in db.GetDbSet <AttendanceSheet>()
where sheet.ClassSessionId == id &&
DbFunctions.TruncateTime(sheet.AttendanceDate) == DbFunctions.TruncateTime(date)
select new
{
sheet.MemberId
}).ToList();
members.RemoveAll(a => curSheets.Any(s => s.MemberId == a.Id));
return(PartialView(members));
}
public async Task <Object> PostClassSessionClass(string classId, int timeShiftId, List <string> days)
{
var teachingScheduleByClass = _context.TeachingSchedules.Where(x => x.LanguageClassId == classId).SingleOrDefault();
if (teachingScheduleByClass != null)
{
List <ClassSession> classSessions = new List <ClassSession>();
TimeSpan Time = teachingScheduleByClass.ToDate - teachingScheduleByClass.FromDate;
int totalDay = Time.Days;
var learnDate = teachingScheduleByClass.FromDate;
var timeshift = _context.TimeShifts.Where(x => x.Id == timeShiftId).SingleOrDefault();
for (int i = 1; i <= totalDay; i++)
{
if (days.Contains(learnDate.DayOfWeek.ToString()))
{
ClassSession classSession1 = new ClassSession();
classSession1.Date = learnDate;
classSession1.FromTime = timeshift.FromTime;
classSession1.ToTime = timeshift.ToTime;
classSession1.TeachingScheduleId = teachingScheduleByClass.Id;
classSessions.Add(classSession1);
}
learnDate = learnDate.AddDays(1);
}
teachingScheduleByClass.Status = Status.Active;
_context.TeachingSchedules.Update(teachingScheduleByClass);
_context.ClassSessions.AddRange(classSessions);
await _context.SaveChangesAsync();
return(await Task.FromResult(classSessions));
}
return(await Task.FromResult("No hope"));
}
public ClassSessionLogicModel(ClassSession session)
{
Id = session.Id;
StartTime = session.StartTime;
EndTime = session.EndTime;
Weekday = GetDayOfWeek(session.Weekday);
Room = session.Room;
}
private List <Member> OutputFilter(long id)
{
ClassSession classSession = db.GetDbSet <ClassSession>().Find(id);
var membersList = (from mem in db.GetDbSet <Member>().Include("DisciplineEnrolledMembers")
where !mem.IsArchived &&
!mem.DisciplineEnrolledMembers.Any(d => d.DisciplineId == classSession.DisciplineId)
select mem);
return(membersList.ToList());
}
private List <Member> GetDropIns(string[] ids, long id)
{
ClassSession classSession = db.GetDbSet <ClassSession>().Find(id);
var membersList = (from mem in db.GetDbSet <Member>().Include("DisciplineEnrolledMembers")
where !mem.IsArchived &&
!mem.DisciplineEnrolledMembers.Any(d => d.DisciplineId == classSession.DisciplineId) &&
ids.Any(i => i == mem.Id.ToString())
select mem);
return(membersList.ToList());
}
public IServiceResults<Guid> EditClassSession(ClassSession model)
{
_classSession.Attach(model);
_uow.Entry(model).State = EntityState.Modified;
var saveResult = _uow.SaveChanges();
return new ServiceResults<Guid>
{
IsSuccessfull = saveResult.ToBool(),
Message = saveResult.ToMessage(BusinessMessage.Error),
Result = model.ClassSessionId
};
}
public ActionResult Create([Bind(Include = "Id,AttendanceDate,ClassSessionId")] AttendanceSheet attendanceSheet)
{
string DropIn = Request.Form["DropInList"];
ClassSession classSession = db.GetDbSet <ClassSession>().Include("Discipline").Include("Discipline.EnrolledMembers").Include("Discipline.EnrolledMembers.Member").FirstOrDefault(c => c.Id == attendanceSheet.ClassSessionId);
attendanceSheet.ClassSession = classSession;
string[] ids = Request.Form.GetValues("present");
ViewBag.ClassSessionId = attendanceSheet.ClassSessionId;
ViewBag.Discipline = classSession.Discipline.Name;
ViewBag.DayOfWeek = classSession.DayOfWeek;
ViewBag.StartTime = classSession.StartTime.ToString("h:mm tt");
if (attendanceSheet.AttendanceDate.DayOfWeek == classSession.DayOfWeek)
{
if (attendanceSheet.ClassSession == null)
{
return(PartialView("Create", attendanceSheet));
}
if (ModelState.IsValid)
{
List <AttendanceSheet> attendance = new List <AttendanceSheet>();
if (ids != null)
{
foreach (string id in ids)
{
AttendanceSheet attendee = new AttendanceSheet {
ClassSessionId = classSession.Id, AttendanceDate = attendanceSheet.AttendanceDate, MemberId = int.Parse(id)
};
attendance.Add(attendee);
}
}
db.GetDbSet <AttendanceSheet>().AddRange(attendance);
db.SaveChanges();
return(Json(new JsonReturn {
RefreshScreen = true
}));
}
}
attendanceSheet.AttendanceDate = DateTime.Now.StartOfWeek(classSession.DayOfWeek);
ViewBag.Invalid = true;
List <string> presentIds = ids.ToList();
ViewBag.ids = presentIds;
List <Member> dropIns = this.GetDropIns(ids, attendanceSheet.ClassSessionId);
List <Member> output = this.OutputFilter(attendanceSheet.ClassSessionId);
ViewBag.OutputDropDown = output.Except(dropIns);
ViewBag.DropIns = dropIns;
return(PartialView(attendanceSheet));
}
public IActionResult Presentation()
{
ClassSession returnModel = new ClassSession();
returnModel.Sessions = uow.SessionsDataAccess
.GetAll()
.ToList();
returnModel.Classes = uow.ClassDataAccess
.GetAll()
.ToList();
return(View(returnModel));
}
public async Task <IActionResult> Create([Bind("classSessionId,fitnessClassId,ClassSessionStartTime,locationId")] ClassSession classSession)
{
if (ModelState.IsValid)
{
_context.Add(classSession);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["fitnessClassId"] = new SelectList(_context.FitnessClasses, "fitnessclassId", "fitnessclassId", classSession.fitnessClassId);
ViewData["locationId"] = new SelectList(_context.Locations, "locationId", "locationId", classSession.locationId);
return(View(classSession));
}
// GET: AttendanceSheet/Create
public ActionResult Create(int id)
{
string DropIn = Request.Form["DropInList"];
ClassSession classSession = db.GetDbSet <ClassSession>().Include("Discipline").Include("Discipline.EnrolledMembers").Include("Discipline.EnrolledMembers.Member").FirstOrDefault(c => c.Id == id);
AttendanceSheet attendanceSheet = new AttendanceSheet {
ClassSession = classSession
};
ViewBag.OutputDropDown = this.OutputFilter(id);
// Get closest day of the week and set as default.
attendanceSheet.AttendanceDate = DateTime.Now.StartOfWeek(classSession?.DayOfWeek ?? DateTime.Now.DayOfWeek);
ViewBag.Discipline = classSession.Discipline.Name;
ViewBag.DayOfWeek = classSession.DayOfWeek;
ViewBag.StartTime = classSession.StartTime.ToString("h:mm tt");
ViewBag.ClassSessionId = id;
return(PartialView(attendanceSheet));
}
public virtual ActionResult Edit(ClassSession model)
{
if (!ModelState.IsValid)
{
return View(model);
}
model.ReBind();
var result = _sessionService.EditClassSession(model);
if (!result.IsSuccessfull)
{
this.NotificationController().Notify(result.Message, NotificationStatus.Error);
return View(model);
}
return RedirectToAction(MVC.Session.ActionNames.Add, MVC.Session.Name, new
{
classId = model.ClassId
});
}
public virtual ActionResult Add(ClassSession model)
{
if (!ModelState.IsValid)
{
return View(model);
}
model.ReBind();
var result = _sessionService.AddClassSession(model);
if (!result.IsSuccessfull)
{
this.NotificationController().Notify(result.Message, NotificationStatus.Error);
return View(model);
}
if (!model.IsCanceled)
this.NotificationController().Notify(string.Format(LocalMessage.SessionMaterialAddress, result.Message), NotificationStatus.Success);
return RedirectToAction(MVC.Session.ActionNames.Add, MVC.Session.Name, new
{
classId = model.ClassId
});
}
public IServiceResults<Guid> AddClassSession(ClassSession model)
{
if (IsUnique(model.ClassId, model.ClassSessionDateSh))
return new ServiceResults<Guid>
{
IsSuccessfull = false,
Message = BusinessMessage.RecordExist,
Result = model.ClassId
};
if (GetSessionsCount(model.ClassId) == _classService.FindClass(model.ClassId).SessionCount)
return new ServiceResults<Guid>
{
IsSuccessfull = false,
Message = BusinessMessage.SessionCountIsFull,
Result = model.ClassId
};
model.ClassSessionId = Guid.NewGuid();
_classSession.Add(model);
var saveResult = _uow.SaveChanges();
if (saveResult.ToBool() && GetSessionsCount(model.ClassId) == _classService.FindClass(model.ClassId)?.SessionCount)
_classService.FinishedClass(model.ClassId);
if (saveResult.ToBool())
SendNotification(model.ClassId, model.ClassSessionDateSh, model.IsCanceled);
string resultFileProxy = string.Empty;
if (!model.IsCanceled && saveResult.ToBool())
{
var _class = _classService.FindFullClassData(model.ClassId);
var time = PersianDateTime.Parse(model.ClassSessionDateSh);
var address = $"{time.Year}/{time.Month}/{time.Day}/{_class.ClassTimeInformation}";
resultFileProxy = _filesProxyAdapter.CreateDirectory(address);
}
return new ServiceResults<Guid>
{
IsSuccessfull = saveResult.ToBool(),
Message = resultFileProxy,
Result = model.ClassSessionId
};
}
/// <summary>
/// Asynchronously creates a new ClassSession entity and saves it
/// to the context.
/// </summary>
/// <param name="dto"></param>
/// <returns>The created ClassSession entity.</returns>
/// <exception cref="ArgumentException"></exception>
public async Task <ClassSession> CreateAsync(ClassSessionDto dto)
{
if (dto == null)
{
throw new ArgumentException("ClassSession DTO cannot be null.");
}
var entity = new ClassSession
{
Date = dto.Date ?? new DateTime(),
StartTime = dto.StartTime ?? new DateTime(),
EndTime = dto.EndTime ?? new DateTime(),
StudentClass = await GetStudentClassByIdAsync(dto.StudentClassId.GetValueOrDefault()),
Students = await MapStudentIdsToStudents(dto.StudentIds)
};
_repositoryWrapper.ClassSession.Add(entity);
await _repositoryWrapper.SaveAsync();
return(entity);
}
bool TryConvertStringsToInfo(string[] contents, string date, ClassSession session, FetchType type, ref ClassInfomation info)
{
if (contents == null)
{
return(false);
}
switch (type)
{
case FetchType.Teacher:
info = new ClassInfomation()
{
date = DateTime.Parse(date),
session = session,
classCode = contents[0],
className = contents[1],
classRoom = contents[2]
};
break;
case FetchType.ClassCode:
info = new ClassInfomation()
{
date = DateTime.Parse(date),
session = session,
teacher = contents[0],
className = contents[1],
classRoom = contents[2]
};
break;
default:
return(false);
}
return(true);
}
//
// GET: /NewSession/
public ActionResult NewSession(Guid scheduleId)
{
SessionCache.Teacher_CurrentClassSession = null;
SessionCache.Teacher_CurrentSessionCalc = null;
var newSession = new ClassSession();
var schedule = Academy.Current.GetClassScheduleById(scheduleId);
var cls = Academy.Current.GetClassById(schedule.ClassId);
var attendance = new Attendance();
newSession.ClassScheduleId = schedule.Id;
var students = Academy.Current.GetStudentsByScheduleId(scheduleId);
foreach (var student in students)
{
attendance.CmbStudents.Add(new SelectListItem() { Text = student.Name, Value = student.Id + "" });
}
newSession.Attendance = attendance;
SessionCache.Teacher_CurrentClassSession = newSession;
SessionCache.Teacher_CurrentSessionCalc = SessionCache.Teacher_CurrentSessionCalc ?? new NewClassSessionCalc() { Duration = cls.Duration.ToString() };
return View(newSession);
}
public ActionResult Index()
{
// Gets all of the discipline enrolled members from the database and puts them in a list.
var memberList = (from mem in db.GetDbSet <DisciplineEnrolledMember>()
where !mem.IsArchived
select new
{
mem.Member,
mem.Discipline,
mem.Discipline.Name,
mem.Member.FirstName,
mem.Member.LastName,
mem.EndDate,
mem.RemainingCost
}).ToList();
DayOfWeek today = DateTime.Now.DayOfWeek;
// Gets all of the class sessions from the database and puts them in a list.
var classSession = (from cls in db.GetDbSet <ClassSession>()
where cls.DayOfWeek == today &&
!cls.IsArchived
select new
{
cls.Id,
cls.Discipline,
cls.Discipline.Name,
cls.DayOfWeek,
cls.StartTime
}).ToList();
// Remove all memberships with an end date prior to the last 2 months.
memberList.RemoveAll(x => x.EndDate < DateTime.Now.AddMonths(-2));
// Sorts the members by their end date
memberList.Sort((x, y) => DateTime.Compare(x.EndDate, y.EndDate));
// Selects the top 5 members from the list.
if (memberList.Count > 5)
{
memberList.RemoveRange(5, memberList.Count - 5);
}
// Select top 5 class sessions.
if (classSession.Count > 5)
{
classSession.RemoveRange(5, classSession.Count - 5);
}
HomeViewModel viewModel = new HomeViewModel()
{
DisciplineEnrolledMembers = new List <DisciplineEnrolledMember>(),
ClassSessions = new List <ClassSession>()
};
// Creates a model and sets lists properties to the model properties.
foreach (var item in memberList)
{
DisciplineEnrolledMember mem = new DisciplineEnrolledMember();
mem.Member = item.Member;
mem.Discipline = item.Discipline;
mem.Discipline.Name = item.Name;
mem.Member.FirstName = item.FirstName;
mem.Member.LastName = item.LastName;
mem.EndDate = item.EndDate;
mem.RemainingCost = item.RemainingCost;
viewModel.DisciplineEnrolledMembers.Add(mem);
}
// Creates a model and sets lists properties to the class properties.
foreach (var item in classSession)
{
ClassSession session = new ClassSession();
session.Id = item.Id;
session.Discipline = item.Discipline;
session.Discipline.Name = item.Name;
session.DayOfWeek = item.DayOfWeek;
session.StartTime = item.StartTime;
viewModel.ClassSessions.Add(session);
}
ViewBag.ClassName = null;
return(View(viewModel));
}
public ActionResult QuickAttendanceRecord(int memberId, int disciplineId)
{
ViewBag.IsLocked = ApplicationContext.CurrentApplicationContext.CurrentSession.AttendanceLock;
// Get selected member
Member member = db.GetDbSet <Member>().Where(m => m.Id == memberId).FirstOrDefault();
// Find the class session going on right now for given discipline.
DateTime dtNow = DateTime.Now;
int dow = (int)dtNow.DayOfWeek;
var classSessionQuery = from cs in db.GetDbSet <ClassSession>().Include("Discipline")
where cs.DisciplineId == disciplineId &&
cs.StartTime <= dtNow && cs.EndTime >= dtNow &&
(int)cs.DayOfWeek == dow
select cs;
ClassSession classSession = classSessionQuery.FirstOrDefault();
// If class session is null...
if (classSession == null)
{
// Find the closest class session to now from the given disipline.
classSessionQuery = from cs in db.GetDbSet <ClassSession>().Include("Discipline")
where cs.DisciplineId == disciplineId &&
(int)cs.DayOfWeek == dow
orderby EntityFunctions.DiffSeconds(cs.StartTime, dtNow),
EntityFunctions.DiffSeconds(cs.EndTime, dtNow)
select cs;
classSession = classSessionQuery.FirstOrDefault();
}
// If class session or member is null..
if (classSession == null || member == null)
{
// Return an error.
return(Json(new { Error = true }));
}
else
{
// Check if member is already checked in.
bool alreadyCheckedIn = db.GetDbSet <AttendanceSheet>().Any(a => a.MemberId == member.Id &&
a.ClassSessionId == classSession.Id &&
DbFunctions.TruncateTime(a.AttendanceDate) == DbFunctions.TruncateTime(dtNow));
// If the member is not currently checked in...
if (!alreadyCheckedIn)
{
// Create attendance record for member.
AttendanceSheet sheet = new AttendanceSheet()
{
AttendanceDate = dtNow,
MemberId = member.Id,
ClassSessionId = classSession.Id
};
db.GetDbSet <AttendanceSheet>().Add(sheet);
db.SaveChanges();
}
// Return that member has been checked in and class session checked in for.
return(Json(new { Error = false, checkedIn = alreadyCheckedIn, classSession = $"{classSession.Discipline.Name} {classSession.StartTime.ToString("h:mm tt")} - {classSession.EndTime.ToString("h:mm tt")}", member = member.FullName }));
}
}
//
// GET: /Teacher/StartStopSession/0 or 1
public ActionResult StartStopSession(ClassSession form)
{
SessionCache.Teacher_CurrentSessionCalc.ClickCount += 1;
var duration=int.Parse(SessionCache.Teacher_CurrentSessionCalc.Duration.Split(':')[1]) * 60 * 1000;
if (SessionCache.Teacher_CurrentSessionCalc.ClickCount == 1)
{
SessionCache.Teacher_CurrentClassSession = form;
SessionCache.Teacher_CurrentClassSession.StartTime = DateTime.Now;
SessionCache.Teacher_CurrentClassSession.EndTime = SessionCache.Teacher_CurrentClassSession.StartTime.AddMilliseconds(duration);
SessionCache.Teacher_CurrentSessionCalc.EndTime = SessionCache.Teacher_CurrentClassSession.EndTime.ToJSDate();
}
if (SessionCache.Teacher_CurrentSessionCalc.Mode == 1)//Start
{
var lastMinUsed = SessionCache.Teacher_CurrentSessionCalc.TimeElapsed;
SessionCache.Teacher_CurrentSessionCalc.EndTime = DateTime.Now.AddMilliseconds(duration - lastMinUsed.TotalMilliseconds).ToJSDate();
}
else//Stop
{
var timeRemaining = DateTime.Parse(SessionCache.Teacher_CurrentSessionCalc.EndTime) - DateTime.Now;
var remainingMin = timeRemaining.TotalMilliseconds;
SessionCache.Teacher_CurrentSessionCalc.TimeElapsed = TimeSpan.FromMilliseconds((duration - remainingMin));
}
SessionCache.Teacher_CurrentSessionCalc.Mode = SessionCache.Teacher_CurrentSessionCalc.Mode == 1 ? 0 : 1;
var data =JsonConvert.SerializeObject(SessionCache.Teacher_CurrentSessionCalc);
return Content(data);
//return Json(SessionCache.Teacher_CurrentSessionCalc, JsonRequestBehavior.AllowGet);
}
public ActionResult Edit([Bind(Include = "Id,AttendanceDate,MemberId,Present,ClassSessionId")] AttendanceSheet attendanceSheet)
{
ClassSession classSession = db.GetDbSet <ClassSession>().Include("Discipline").FirstOrDefault(c => c.Id == attendanceSheet.ClassSessionId);
attendanceSheet.ClassSession = classSession;
List <AttendanceViewModel> modelList = GetAttendance(attendanceSheet);
ViewBag.Name = attendanceSheet.ClassSession.Discipline.Name;
ViewBag.DayOfWeek = attendanceSheet.ClassSession.DayOfWeek;
ViewBag.AttendanceDate = attendanceSheet.AttendanceDate;
ViewBag.DisplayDate = attendanceSheet.AttendanceDate.ToString("MM/dd/yyyy");
ViewBag.Time = attendanceSheet.ClassSession.StartTime.ToString("h:MM");
ViewBag.ClassSessionId = attendanceSheet.ClassSessionId;
if (ModelState.IsValid)
{
// Gets the list of selected members from the form
List <string> ids = Request.Form.GetValues("item.Present").ToList();
// Creates a list of members that where not previously marked present
List <AttendanceViewModel> newAttendees = modelList.Where(a => a.Present == false).ToList();
List <AttendanceSheet> addAttendance = new List <AttendanceSheet>();
//Creates a list of members that have been selected
newAttendees.ForEach(a => { if (ids.IndexOf(a.MemberId.ToString()) >= 0)
{
addAttendance.Add(new AttendanceSheet
{
MemberId = a.MemberId,
ClassSessionId = a.ClassSessionId,
AttendanceDate = attendanceSheet.AttendanceDate
});
}
});
// Creates a list of members that where already marked present for the selected session
List <AttendanceSheet> oldAttendance = (from att in db.GetDbSet <AttendanceSheet>()
where att.ClassSessionId == attendanceSheet.ClassSessionId &&
DbFunctions.TruncateTime(att.AttendanceDate) == DbFunctions.TruncateTime(attendanceSheet.AttendanceDate)
select att).ToList();
List <AttendanceSheet> removeAttendance = new List <AttendanceSheet>();
// Creates a list of members that have been unselected
oldAttendance.ForEach(a => { if (ids.IndexOf(a.MemberId.ToString()) < 0)
{
removeAttendance.Add(a);
}
});
// Updates database with selected and unselected members
db.GetDbSet <AttendanceSheet>().AddRange(addAttendance);
db.GetDbSet <AttendanceSheet>().RemoveRange(removeAttendance);
db.SaveChanges();
modelList = GetAttendance(attendanceSheet);
List <AttendanceSheet> sheets = db.GetDbSet <AttendanceSheet>().Where(x => !x.IsArchived).ToList();
foreach (AttendanceSheet A in sheets.Where(a => a.ClassSessionId == attendanceSheet.ClassSessionId && a.AttendanceDate == attendanceSheet.AttendanceDate))
{
bool dropIn = true;
foreach (AttendanceViewModel B in modelList)
{
if (A.MemberId == B.MemberId)
{
dropIn = false;
}
}
if (dropIn == true)
{
modelList.Add(new AttendanceViewModel {
FullName = A.Member.FullName, ClassSessionId = attendanceSheet.ClassSessionId, MemberId = A.MemberId, Present = true
});
}
}
ViewBag.IsValid = true;
return(PartialView("Edit", modelList));
}
ViewBag.ClassSessionId = attendanceSheet.ClassSessionId;
ViewBag.IsValid = false;
return(PartialView(modelList));
}