public async Task <IActionResult> DeleteTimeAndAttendanceScheduledToWork([FromBody] TimeAndAttendanceScheduledToWorkView view)
        {
            TimeAndAttendanceScheduledToWorkModule invMod = new TimeAndAttendanceScheduledToWorkModule();
            TimeAndAttendanceScheduledToWork       timeAndAttendanceScheduledToWork = await invMod.ScheduledToWork.Query().MapToEntity(view);

            invMod.ScheduledToWork.DeleteTimeAndAttendanceScheduledToWork(timeAndAttendanceScheduledToWork).Apply();

            return(Ok(view));
        }
 public TimeAndAttendanceScheduledToWorkView(TimeAndAttendanceScheduledToWork scheduledToWork)
 {
     this.EmployeeId        = scheduledToWork.EmployeeId;
     this.EmployeeName      = scheduledToWork.Employee.AddressBook.Name;
     this.ScheduleId        = scheduledToWork.ScheduleId;
     this.ScheduleName      = scheduledToWork.TimeAndAttendanceSchedule.ScheduleName;
     this.ScheduleStartDate = scheduledToWork.TimeAndAttendanceSchedule.StartDate;
     this.ScheduleEndDate   = scheduledToWork.TimeAndAttendanceSchedule.EndDate;
     this.ShiftStartTime    = scheduledToWork.TimeAndAttendanceSchedule.TimeAndAttendanceShift.ShiftStartTime;
     this.ShiftEndTime      = scheduledToWork.TimeAndAttendanceSchedule.TimeAndAttendanceShift.ShiftEndTime;
 }
Example #3
0
        public IList <TimeAndAttendanceScheduledToWork> BuildScheduledToWork(TimeAndAttendanceScheduleView scheduleView, IList <EmployeeView> employeeViews)
        {
            IList <TimeAndAttendanceScheduledToWork> retList = new List <TimeAndAttendanceScheduledToWork>();

            foreach (var employeeItem in employeeViews)
            {
                TimeAndAttendanceScheduledToWork scheduledToWork = unitOfWork.timeAndAttendanceScheduledToWorkRepository.BuildScheduledToWork(scheduleView, employeeItem);
                retList.Add(scheduledToWork);
            }

            return(retList);
        }
Example #4
0
        public override void MapTimeAndAttendanceScheduledToWorkEntity(ref TimeAndAttendanceScheduledToWork scheduledToWork, TimeAndAttendanceScheduleView scheduleView, TimeAndAttendanceScheduleDayView dayView, EmployeeView employeeView, string payCode)

        {
            scheduledToWork.EmployeeId    = employeeView.EmployeeId;
            scheduledToWork.EmployeeName  = employeeView.EmployeeName;
            scheduledToWork.ScheduleId    = scheduleView.ScheduleId;
            scheduledToWork.ScheduleName  = scheduleView.ScheduleName;
            scheduledToWork.StartDate     = dayView.StartDate;
            scheduledToWork.EndDate       = dayView.EndDate;
            scheduledToWork.StartDateTime = dayView.StartDateTime;
            scheduledToWork.EndDateTime   = dayView.EndDateTime;
            scheduledToWork.ShiftId       = scheduleView.ShiftId ?? 0;
            scheduledToWork.JobCode       = employeeView.JobCode;
            scheduledToWork.WorkedJobCode = employeeView.JobCode;
            scheduledToWork.PayCode       = payCode;
        }
        public async Task <IActionResult> AddTimeAndAttendanceScheduledToWork([FromBody] TimeAndAttendanceScheduledToWorkView view)
        {
            TimeAndAttendanceScheduledToWorkModule invMod = new TimeAndAttendanceScheduledToWorkModule();

            NextNumber nnTimeAndAttendanceScheduledToWork = await invMod.ScheduledToWork.Query().GetNextNumber();

            view.ScheduledToWorkNumber = nnTimeAndAttendanceScheduledToWork.NextNumberValue;

            TimeAndAttendanceScheduledToWork timeAndAttendanceScheduledToWork = await invMod.ScheduledToWork.Query().MapToEntity(view);

            invMod.ScheduledToWork.AddTimeAndAttendanceScheduledToWork(timeAndAttendanceScheduledToWork).Apply();

            TimeAndAttendanceScheduledToWorkView newView = await invMod.ScheduledToWork.Query().GetViewByNumber(view.ScheduledToWorkNumber);


            return(Ok(newView));
        }
        public IList <TimeAndAttendanceScheduledToWork> BuildScheduledToWork(TimeAndAttendanceScheduleView scheduleView, IList <EmployeeView> employeeViews, string payCode)
        {
            IList <TimeAndAttendanceScheduledToWork> retList = new List <TimeAndAttendanceScheduledToWork>();

            DateTime startDay = scheduleView.StartDate ?? DateTime.Now;
            DateTime endDay   = scheduleView.EndDate ?? DateTime.Now;

            TimeSpan difference = endDay - startDay;

            foreach (var employeeItem in employeeViews)
            {
                for (int i = 0; i <= difference.Days; i++)
                {
                    bool monday    = scheduleView.Monday ?? false;
                    bool tuesday   = scheduleView.Tuesday ?? false;
                    bool wednesday = scheduleView.Wednesday ?? false;
                    bool thursday  = scheduleView.Thursday ?? false;
                    bool friday    = scheduleView.Friday ?? false;
                    bool saturday  = scheduleView.Saturday ?? false;
                    bool sunday    = scheduleView.Sunday ?? false;


                    DateTime scheduleStartDate = scheduleView.StartDate ?? DateTime.Now;
                    DateTime currentDate       = scheduleStartDate.AddDays(i);
                    int?     durationHours     = scheduleView.DurationHours ?? 0;
                    int?     durationMinutes   = scheduleView.DurationMinutes ?? 0;

                    string shiftStartTime = scheduleView.ShiftStartTime;
                    string shiftEndTime   = scheduleView.ShiftEndTime;


                    DateTime startDate = unitOfWork.timeAndAttendanceRepository.BuildShortDate(currentDate, shiftStartTime);
                    DateTime endDate   = unitOfWork.timeAndAttendanceRepository.AddTimeShortDate(startDate, durationHours ?? 0, durationMinutes ?? 0);

                    string startDateTime = unitOfWork.timeAndAttendanceRepository.BuildLongDate(currentDate, shiftStartTime);
                    string endDateTime   = unitOfWork.timeAndAttendanceRepository.BuildLongDate(endDate);

                    TimeAndAttendanceScheduleDayView currentDayView = new TimeAndAttendanceScheduleDayView();
                    currentDayView.StartDate     = currentDate;
                    currentDayView.StartDateTime = startDateTime;
                    currentDayView.EndDate       = endDate;
                    currentDayView.EndDateTime   = endDateTime;


                    if (
                        (currentDate.DayOfWeek == DayOfWeek.Monday && monday) ||
                        (currentDate.DayOfWeek == DayOfWeek.Tuesday && tuesday) ||
                        (currentDate.DayOfWeek == DayOfWeek.Wednesday && wednesday) ||
                        (currentDate.DayOfWeek == DayOfWeek.Thursday && thursday) ||
                        (currentDate.DayOfWeek == DayOfWeek.Friday && friday) ||
                        (currentDate.DayOfWeek == DayOfWeek.Saturday && saturday) ||
                        (currentDate.DayOfWeek == DayOfWeek.Sunday && sunday)
                        )
                    {
                        TimeAndAttendanceScheduledToWork scheduledToWork = unitOfWork.timeAndAttendanceScheduledToWorkRepository.BuildScheduledToWork(scheduleView, currentDayView, employeeItem, payCode);
                        retList.Add(scheduledToWork);
                    }
                }
            }

            return(retList);
        }
 public IFluentTimeAndAttendanceScheduledToWork DeleteTimeAndAttendanceScheduledToWork(TimeAndAttendanceScheduledToWork deleteObject)
 {
     unitOfWork.timeAndAttendanceScheduledToWorkRepository.DeleteObject(deleteObject);
     this.processStatus = CreateProcessStatus.Delete;
     return(this as IFluentTimeAndAttendanceScheduledToWork);
 }
 public IFluentTimeAndAttendanceScheduledToWork AddTimeAndAttendanceScheduledToWork(TimeAndAttendanceScheduledToWork newObject)
 {
     unitOfWork.timeAndAttendanceScheduledToWorkRepository.AddObject(newObject);
     this.processStatus = CreateProcessStatus.Insert;
     return(this as IFluentTimeAndAttendanceScheduledToWork);
 }
Example #9
0
 public abstract void MapTimeAndAttendanceScheduledToWorkEntity(ref TimeAndAttendanceScheduledToWork scheduledToWork, TimeAndAttendanceScheduleView scheduleView, TimeAndAttendanceScheduleDayView dayView, EmployeeView employeeView, string payCode);
        public async Task TestAddUpdatDelete()
        {
            TimeAndAttendanceScheduledToWorkModule TimeAndAttendanceScheduledToWorkMod = new TimeAndAttendanceScheduledToWorkModule();
            TimeAndAttendanceSchedule schedule = await TimeAndAttendanceScheduledToWorkMod.Schedule.Query().GetEntityById(4);

            TimeAndAttendanceShift shift = await TimeAndAttendanceScheduledToWorkMod.Shift.Query().GetEntityById(schedule?.ShiftId);

            Employee employee = await TimeAndAttendanceScheduledToWorkMod.Employee.Query().GetEntityById(1);

            AddressBook addressBookEmployee = await TimeAndAttendanceScheduledToWorkMod.AddressBook.Query().GetEntityById(employee?.AddressId);

            Udc udcJobCode = await TimeAndAttendanceScheduledToWorkMod.Udc.Query().GetEntityById(25);

            Udc udcPayCode = await TimeAndAttendanceScheduledToWorkMod.Udc.Query().GetEntityById(16);

            Udc udcWorkedJobCode = await TimeAndAttendanceScheduledToWorkMod.Udc.Query().GetEntityById(25);

            string shiftStartTime = await TimeAndAttendanceScheduledToWorkMod.Shift.Query().BuildLongDate(schedule.StartDate, shift?.ShiftStartTime);

            string shiftEndTime = await TimeAndAttendanceScheduledToWorkMod.Shift.Query().BuildLongDate(schedule.EndDate, shift?.ShiftEndTime);

            TimeAndAttendanceScheduledToWorkView view = new TimeAndAttendanceScheduledToWorkView()
            {
                EmployeeId          = employee.EmployeeId,
                EmployeeName        = addressBookEmployee?.Name,
                ScheduleId          = schedule.ScheduleId,
                ScheduleName        = schedule.ScheduleName,
                ScheduleStartDate   = schedule.StartDate,
                ScheduleEndDate     = schedule.EndDate,
                ShiftId             = shift?.ShiftId,
                ShiftStartTime      = shiftStartTime,
                ShiftEndTime        = shiftEndTime,
                DurationHours       = shift?.DurationHours ?? 0,
                DurationMinutes     = shift?.DurationMinutes ?? 0,
                Monday              = shift?.Monday,
                Tuesday             = shift?.Tuesday,
                Wednesday           = shift?.Wednesday,
                Thursday            = shift?.Thursday,
                Friday              = shift?.Friday,
                Saturday            = shift?.Saturday,
                Sunday              = shift?.Sunday,
                JobCodeXrefId       = udcJobCode.XrefId,
                JobCode             = udcJobCode?.KeyCode,
                PayCodeXrefId       = udcPayCode.XrefId,
                PayCode             = udcPayCode?.KeyCode,
                WorkedJobCodeXrefId = udcWorkedJobCode.XrefId,
                WorkedJobCode       = udcWorkedJobCode?.KeyCode
            };
            NextNumber nnNextNumber = await TimeAndAttendanceScheduledToWorkMod.ScheduledToWork.Query().GetNextNumber();

            view.ScheduledToWorkNumber = nnNextNumber.NextNumberValue;

            TimeAndAttendanceScheduledToWork timeAndAttendanceScheduledToWork = await TimeAndAttendanceScheduledToWorkMod.ScheduledToWork.Query().MapToEntity(view);

            TimeAndAttendanceScheduledToWorkMod.ScheduledToWork.AddTimeAndAttendanceScheduledToWork(timeAndAttendanceScheduledToWork).Apply();

            TimeAndAttendanceScheduledToWork newTimeAndAttendanceScheduledToWork = await TimeAndAttendanceScheduledToWorkMod.ScheduledToWork.Query().GetEntityByNumber(view.ScheduledToWorkNumber);

            Assert.NotNull(newTimeAndAttendanceScheduledToWork);

            newTimeAndAttendanceScheduledToWork.Note = "Note Update";

            TimeAndAttendanceScheduledToWorkMod.ScheduledToWork.UpdateTimeAndAttendanceScheduledToWork(newTimeAndAttendanceScheduledToWork).Apply();

            TimeAndAttendanceScheduledToWorkView updateView = await TimeAndAttendanceScheduledToWorkMod.ScheduledToWork.Query().GetViewById(newTimeAndAttendanceScheduledToWork.ScheduledToWorkId);

            Assert.Same(updateView.Note, "Note Update");
            TimeAndAttendanceScheduledToWorkMod.ScheduledToWork.DeleteTimeAndAttendanceScheduledToWork(newTimeAndAttendanceScheduledToWork).Apply();
            TimeAndAttendanceScheduledToWork lookupTimeAndAttendanceScheduledToWork = await TimeAndAttendanceScheduledToWorkMod.ScheduledToWork.Query().GetEntityById(view.ScheduledToWorkId);

            Assert.Null(lookupTimeAndAttendanceScheduledToWork);
        }