public CodeCamperUnitOfWork(string nameOrConnectionString = "CodeCamper")
: base(new CodeCamperDbContext(nameOrConnectionString))
{
RoomsRepository = new EntityFrameworkReadRepository<Room>(DbContext);
TimeSlotsRepository = new EntityFrameworkReadRepository<TimeSlot>(DbContext);
TracksRepository = new EntityFrameworkReadRepository<Track>(DbContext);
PersonsRepository = new PersonsRepository(DbContext);
SessionsRepository = new SessionsRepository(DbContext);
AttendanceRepository = new AttendanceRepository(DbContext);
}
public void GetAllAsync_Attendance_GetsAllCorrectly()
{
using var context = new UniversityContext(builder.Options);
var repository = new AttendanceRepository(context);
// From UniversityContext OnModelCreating
var initialNumber = 8;
var count = repository.GetAllAsync().Result.Count;
Assert.That(count, Is.EqualTo(initialNumber));
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Students = new StudentRepository(context);
Exams = new ExamRepository(context);
Attandences = new AttendanceRepository(context);
Departments = new DepartmentRepository(context);
Teachers = new TeacherRepository(context);
Specializations = new SpecializationRepository(context);
Users = new ApplicationUserRepository(context);
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Gigs = new GigRepository(context);
Attendances = new AttendanceRepository(context);
Genres = new GenreRepository(context);
Followings = new FollowingRepository(context);
Users = new ApplicationUserRepository(context);
Notifications = new NotificationRepository(context);
UserNotifications = new UserNotificationRepository(context);
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Patients = new PatientRepository(context);
Appointments = new AppointmentRepository(context);
Attandences = new AttendanceRepository(context);
Cities = new CityRepository(context);
Doctors = new DoctorRepository(context);
Specializations = new SpecializationRepository(context);
Users = new ApplicationUserRepository(context);
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Gigs = new GigRepository(_context);
Attendances = new AttendanceRepository(_context);
Genres = new GenreRepository(_context);
Relationships = new RelationshipRepository(_context);
Users = new UserRepository(_context);
UserNotifications = new UserNotificationRepository(_context);
Notification = new NotificationRepository(_context);
}
private void AddAttendance()
{
var attendanceToAdd = new Attendance()
{
VisitedDateTime = DateTime.Now,
Temperature = double.Parse(txtTemperature.Text),
AttendeeId = selectedAttendeeId,
PlaceId = 1
};
AttendanceRepository.PostAttendance(attendanceToAdd);
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Coops = new CoopRepository(_context);
Attendances = new AttendanceRepository(_context);
Games = new GameRepository(_context);
Followings = new FollowingRepository(_context);
Users = new ApplicationUserRepository(_context);
Notifications = new NotificationRepository(_context);
UserNotifications = new UserNotificationRepository(_context);
}
public void AddAsync_Attendance_AddsCorrectly()
{
using var context = new UniversityContext(builder.Options);
var repository = new AttendanceRepository(context);
var attendance = new Attendance()
{
StudentId = 1, LessonInScheduleId = 1, IsPresent = true
};
var res = repository.AddAsync(attendance).Result;
Assert.That(res.Id, Is.Not.EqualTo(0));
}
// public IUserDescriptionRepository UserDescriptions { get; }
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Gigs = new GigRepository(_context);
Attendances = new AttendanceRepository(_context);
Followings = new FollowingRepository(_context);
Genres = new GenreRepository(_context);
UserNotifications = new UserNotificationRepository(_context);
Users = new UserRepository(_context);
Roles = new RoleRepository(_context);
Logins = new LoginRepository(_context);
// UserDescriptions = new UserDescriptionRepository(_context);
}
//private static int ids = 0;
public void AddToAttendance()
{
Attendance attendance = new Attendance();
attendance.AttendanceDate = DateTime.Now;
attendance.ImageSource = "ok4.jpg";
//attendance.Id = ids++;
Attendance.Attendances.Add(attendance);
var repo = new AttendanceRepository();
repo.Save(attendance);
}
public ActionResult UpdateAttendance(AttendanceViewModel vm)
{
try
{
AttendanceRepository.UpdateAttendance(vm.Periods, vm.Date2, this.CurrentUser.Class_id);
TempData["success"] = "1";
}
catch (Exception ex)
{
TempData["success"] = "0";
}
return(RedirectToAction("Show", new { d = vm.Date2 }));
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Payments = new PaymentRepository(context);
StudentPaymentAndPeriods = new StudentPaymentAndPeriodRepository(context);
Groups = new GroupRepository(context);
Student = new StudentRepository(context);
Branchs = new BranchRepository(context);
Levels = new LevelRepository(context);
TimeTables = new TimeTableRepository(context);
Attendances = new AttendanceRepository(context);
Comments = new CommentRepository(context);
}
public ActionResult CourseAttendance(CourseAttendanceModel model)
{
if (ModelState.IsValid)
{
AttendanceRepository attendance = new AttendanceRepository();
attendance.OnSave(model.studentName, model.isPresent, model.currentDate);
return(View("SaveAttendance", model));
}
else
{
return(View());
}
}
public AttendanceManager(AttendanceRepository attendaceRepository,
TimeTableManager tableManager,
ClassesRepository classesRepository,
SubjectRepository subjectRepository,
FacultyRepository facultyRepository,
StudentRepository studentRepository)
{
_attendanceRepository = attendaceRepository;
_timeTableManager = tableManager;
_classesRepository = classesRepository;
_subjectRepository = subjectRepository;
_facultyRepository = facultyRepository;
_studentRepository = studentRepository;
}
public long DeleteAttendance(DateModal dmt)
{
long result;
if (dmt.attendanceId.ToString() == "")
{
result = 0;
}
else
{
string AttedanceId = dmt.attendanceId.ToString();
result = AttendanceRepository.DeleteAttendance(Guid.Parse(AttedanceId));
}
return(result);
}
public void DeleteAsync_Attendance_DeletesCorrectly()
{
using var context = new UniversityContext(builder.Options);
var repository = new AttendanceRepository(context);
var attendance = new Attendance()
{
StudentId = 1, LessonInScheduleId = 1, IsPresent = true
};
var res = repository.AddAsync(attendance).Result;
repository.DeleteAsync(res.Id).Wait();
var deletedAttendance = repository.GetByIdAsync(res.Id).Result;
Assert.That(deletedAttendance, Is.EqualTo(null));
}
public void GetAttendanceHoursByDateTest()
{
var databaseFactory = new DatabaseFactory();
var unitOfWork = new UnitOfWork(databaseFactory);
var employeeDepartmentRepository = new EmployeeDepartmentRepository(databaseFactory);
var employeeRepository = new EmployeeRepository(databaseFactory, employeeDepartmentRepository);
var attendanceLogRepository = new AttendanceLogRepository(databaseFactory, employeeRepository);
var employeeHoursRepository = new EmployeeHoursRepository(databaseFactory);
var attendanceRepository = new AttendanceRepository(databaseFactory);
var attendanceLogService = new AttendanceLogService(attendanceLogRepository);
var attendanceService = new AttendanceService(unitOfWork, attendanceRepository, attendanceLogService, employeeHoursRepository);
var result = attendanceService.GetAttendanceAndHoursByDate(new DateTime(2016, 6, 8), new DateTime(2016, 6, 8), 0);
}
public void UpdateAsync_Attendance_UpdatesCorrectly()
{
using var context = new UniversityContext(builder.Options);
var repository = new AttendanceRepository(context);
var attendance = new Attendance()
{
StudentId = 1, LessonInScheduleId = 1, IsPresent = true
};
var res = repository.AddAsync(attendance).Result;
var attendanceFromDb = repository.GetByIdAsync(res.Id).Result;
attendanceFromDb.StudentId = 2;
var changedRes = repository.UpdateAsync(attendanceFromDb).Result;
Assert.That(changedRes.StudentId, Is.EqualTo(2));
}
private void btnSubmit_Click(object sender, EventArgs e)
{
var empId = Convert.ToInt32(txtEmployeeID.Text);
var model = new AttendanceModel();
model.EmployeeId = empId;
var repo = new AttendanceRepository();
var attendance = repo.GetLastRecord(empId);
var currentDate = DateTime.Now;
if (attendance != null && attendance.DateTimeOut == null)
{
model.DateTimeOut = currentDate;
model.RegularHoursRendered = currentDate.Subtract(attendance.DateTimeIn.Value).TotalHours;
model.OTHoursRendered = 0;
if (currentDate.Hour > 17)
{
model.OTHoursRendered = currentDate.Hour - 17;
}
if (repo.TimeOut(model) != -1)
{
MessageBox.Show("You have timed out", "APS", MessageBoxButtons.OK, MessageBoxIcon.Information);
Reset();
return;
}
}
else
{
model.DateTimeIn = currentDate;
if (repo.TimeIn(model) != -1)
{
MessageBox.Show("You have timed in", "APS", MessageBoxButtons.OK, MessageBoxIcon.Information);
Reset();
return;
}
}
// if we reach here, there's an error
MessageBox.Show("Error in logging in/out!", "APS", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
public void GetWithIncludeAsync_Attendance_GetsCorrectly()
{
using var context = new UniversityContext(builder.Options);
var repository = new AttendanceRepository(context);
var attendance = new Attendance()
{
StudentId = 1, LessonInScheduleId = 1, IsPresent = true
};
var res = repository.AddAsync(attendance).Result;
var attendanceFromDb = repository.GetByIdWithIncludeAsync(res.Id).Result;
Assert.Multiple(() =>
{
Assert.That(attendanceFromDb.LessonInSchedule, Is.Not.EqualTo(null));
Assert.That(attendanceFromDb.Student, Is.Not.EqualTo(null));
});
}
private void UpdateAttendanceById()
{
SelectedAttendance.Status = comboStatus.Text;
if (SelectedAttendance.Id > 0)
{
AttendanceRepository.UpdateAttendanceStatus(SelectedAttendance);
AttendeeRepository.UpdateAttendeeStatus(new Attendee {
Id = int.Parse(dgvAttendances.CurrentRow.Cells[7].Value.ToString()), Status = SelectedAttendance.Status
});
}
if (SelectedAttendance.Status == "POSITIVE")
{
UpdateMultipleAttendances(SelectedAttendance.VisitedDateTime, SelectedAttendance.AttendeeId, SelectedAttendance.Id);
}
SelectedAttendance = new Attendance();
}
public IHttpActionResult EditAttendance(DateModal dtm)
{
if (dtm.employeeId == Guid.Empty)
{
dtm.employeeId = Guid.Parse(GetUserId());
}
DateTime Date = DateTime.Parse(dtm.attendanceDate);
//DateTime.Parse(dtm.monthStartDate);
int? day = null;
int year = Convert.ToDateTime(dtm.attendanceDate).Year;
int month = Convert.ToDateTime(dtm.attendanceDate).Month;
DataSet ds = AttendanceRepository.GetAttendance(dtm.employeeId, Convert.ToInt32(dtm.todayDay) == 0 ? day : Convert.ToInt32(dtm.todayDay), Date.Month, Date.Year);
ds.Tables[0].TableName = "Attendance";
DataTable dt = BindTotalTime(GetUserId(), dtm.attendanceDate);
if (dt.Rows.Count > 0)
{
dt.TableName = "TotalHours";
ds.Tables.Add(dt.Copy());
}
DataTable Results = ds.Tables[0];
var query = Results.AsEnumerable().Select(Result => new
{
Attendance = Result.Field <decimal>("Attendance"),
AttendanceId = Result.Field <Guid?>("AttendanceId"),
Date = Result.Field <DateTime>("Date").ToString("MM-dd-yyyy"),
DayDescription = Result.Field <string>("DayDescription"),
EmployeeId = Result.Field <Guid>("EmployeeId"),
InTime = Result.Field <DateTime?>("InTime"),
IsWorkFromHome = Result.Field <Boolean>("IsWorkFromHome"),
OutTime = Result.Field <DateTime?>("OutTime"),
Remarks = Result.Field <string>("Remarks"),
TotalTime = Result.Field <string>("TotalTime"),
Type = Result.Field <string>("Type"),
//id = Result.Field<string>("id"),
//internalId=Result.Field<string>("internalId")
});
var singleresult = query.Where(m => m.EmployeeId == dtm.employeeId && m.Date == dtm.attendanceDate);
return(Ok(singleresult));
}
public IHttpActionResult GetAttendanceReport(DateModal modal)
{
DateTime startDate = Convert.ToDateTime(modal.monthStartDate);
DataSet ds = AttendanceRepository.GetAttendanceReport(startDate);
ds.Tables[0].TableName = "Attendance";
DataTable dt = new DataTable();
dt.Clear();
dt.Columns.Add("ReportHeaders");
foreach (DataColumn col in ds.Tables[0].Columns)
{
DataRow newRow = dt.NewRow();
newRow["ReportHeaders"] = col.ColumnName;
dt.Rows.Add(newRow);
}
ds.Tables.Add(dt);
ds.Tables[1].TableName = "ReportHeaders";
return(Ok(ds));
}
public UnitOfWork()
{
_dbContext = new ApplicationDbContext();
Users = new UserRepository(_dbContext);
Teachers = new TeacherRepository(_dbContext);
Students = new StudentRepository(_dbContext);
Courses = new CourseRepository(_dbContext);
Rooms = new RoomRepository(_dbContext);
Campuses = new CampusRepository(_dbContext);
Attendances = new AttendanceRepository(_dbContext);
StatusAttendances = new StatusAttendanceRepository(_dbContext);
StatusTimeTables = new StatusTimeTableRepository(_dbContext);
TimeSlots = new TimeSlotRepository(_dbContext);
TimeTables = new TimeTableRepository(_dbContext);
StudentGroups = new StudentGroupRepository(_dbContext);
StatusTakeAttendances = new StatusTakeAttendanceRepository(_dbContext);
StudentFaces = new StudentFacesRepository(_dbContext);
IdentityStudents = new IdentityStudentRepository(_dbContext);
RecognitionImages = new RecognitionImageRepository(_dbContext);
Messages = new MessageRepository(_dbContext);
StatusesMessage = new StatusMessageRepository(_dbContext);
}
private void UpdateMultipleAttendances(DateTime visitedDateTime, int attendeeId, int attendanceId)
{
var attendances = AttendanceRepository.GetAttendances().Where(a => a.VisitedDateTime.Year <= visitedDateTime.Year &&
a.VisitedDateTime.Month <= visitedDateTime.Month &&
a.VisitedDateTime.Day <= visitedDateTime.Day &&
a.VisitedDateTime.Date >= visitedDateTime.Date.AddDays(-14) &&
a.PlaceId == Helpers.PlaceHelper.PlaceId);
var attendancesWherePositiveAttendeeExists = attendances.Where(a => a.AttendeeId == attendeeId).GroupBy(a => a.VisitedDateTime.Date).Select(a => a.First()).ToList();
var datesWhenPositiveAttendeeExists = attendancesWherePositiveAttendeeExists.Select(a => a.VisitedDateTime.Date);
foreach (var date in datesWhenPositiveAttendeeExists)
{
foreach (var attendance in attendances)
{
if (attendance.Id != attendanceId && attendance.Status != "POSITIVE" && attendance.VisitedDateTime.Date == date.Date)
{
AttendanceRepository.UpdateAttendanceStatus(new Attendance {
Id = attendance.Id, Status = "PUI"
});
AttendeeRepository.UpdateAttendeeStatus(new Attendee {
Id = attendance.AttendeeId, Status = "PUI"
});
}
if (attendance.AttendeeId == attendeeId && attendance.VisitedDateTime.Date == date.Date)
{
AttendanceRepository.UpdateAttendanceStatus(new Attendance {
Id = attendance.Id, Status = "POSITIVE"
});
AttendeeRepository.UpdateAttendeeStatus(new Attendee {
Id = attendance.AttendeeId, Status = "POSITIVE"
});
}
}
}
}
//IGenericRepository IUnitOfWork.Repository => throw new NotImplementedException();
public UnitOfWork()
{
dbContext = new DatabaseContext();
Repository = new GenericRepository(dbContext);
SchoolRepository = new SchoolRepository(dbContext);
ExceptionLoggerRepository = new ExceptionLoggerRepository(dbContext);
ApiLogRepository = new ApiLogRepository(dbContext);
ImageFileTypeRepository = new ImageFileTypeRepository(dbContext);
AssessmentRepository = new AssessmentRepository(dbContext);
AttendanceRepository = new AttendanceRepository(dbContext);
BookRepository = new BookRepository(dbContext);
BookTransactionRepository = new BookTransactionRepository(dbContext);
EventRepository = new EventRepository(dbContext);
HomeworkRepository = new HomeworkRepository(dbContext);
ImageFileUrlRepository = new ImageFileUrlRepository(dbContext);
ParentRepository = new ParentRepository(dbContext);
StandardRepository = new StandardRepository(dbContext);
StudentRepository = new StudentRepository(dbContext);
SubjectRepository = new SubjectRepository(dbContext);
TeacherRepository = new TeacherRepository(dbContext);
YearRepository = new YearRepository(dbContext);
OperationalStaffRepository = new OperationalStaffRepository(dbContext);
}
public IHttpActionResult GetAttendance(DateModal dtm)
{
if (dtm.employeeId == Guid.Empty)
{
dtm.employeeId = Guid.Parse(GetUserId());
}
DateTime startDate = DateTime.Parse(dtm.monthStartDate);
//DateTime.Parse(dtm.monthStartDate);
int? day = null;
int year = Convert.ToDateTime(dtm.monthStartDate).Year;
int month = Convert.ToDateTime(dtm.monthStartDate).Month;
DataSet ds = AttendanceRepository.GetAttendance(dtm.employeeId, Convert.ToInt32(dtm.todayDay) == 0 ? day : Convert.ToInt32(dtm.todayDay), startDate.Month, startDate.Year);
ds.Tables[0].TableName = "Attendance";
DataTable dt = BindTotalTime(GetUserId(), dtm.monthStartDate);
if (dt.Rows.Count > 0)
{
dt.TableName = "TotalHours";
ds.Tables.Add(dt.Copy());
}
return(Ok(ds));
//return Ok(JsonConvert.SerializeObject(ds, Formatting.Indented, new JsonSerializerSettings { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }));
}
public HomeController()
{
_context = new ApplicationDbContext();
_attendanceRepository = new AttendanceRepository(_context);
}
private List <AttendanceDto> GetAttendances()
{
var attendances = AttendanceRepository.GetAttendances();
return(attendances.ToList());
}
public ActionResult Attendance(DateTime?dd1, DateTime?dd2)
{
var vm = AttendanceRepository.CalculateClassAttendance(dd1, dd2, this.CurrentUser.Class_id);
return(View(vm));
}
