Exemplo n.º 1
0
        public async Task <OperationResultWithData <List <SlotDto> > > RescheduleDate([FromBody] RescheduleDateDto dto)
        {
            LmsCourseMeeting meeting = _lmsCourseMeetingModel.GetOneByCourseAndId(LmsCompany.Id, CourseId, dto.MeetingId);

            if (meeting?.OfficeHours == null)
            {
                return(OperationResultWithData <List <SlotDto> > .Error("Meeting not found"));
            }
            var slots = await _officeHoursService.RescheduleDate(meeting.OfficeHours.Id, Session.LmsUser, dto);

            return(slots);
        }
Exemplo n.º 2
0
        public async Task <OperationResultWithData <List <SlotDto> > > RescheduleDate(int ohId, LmsUser lmsUser,
                                                                                      RescheduleDateDto dto)
        {
            List <SlotDto> result               = new List <SlotDto>();
            var            availabilities       = _availabilityModel.GetAvailabilities(ohId);
            var            availabilitiesToAdd  = new List <OfficeHoursTeacherAvailabilityDto>();
            var            slotsToAdd           = new List <SlotDto>();
            var            overlappingFreeSlots = new List <SlotDto>();
            OfficeHours    oh = null;

            foreach (var availability in availabilities)
            {
                var availabilityDto = ConvertToDto(availability);
                var slots           = GetSlotsForAvailability(availabilityDto, dto.Start, dto.End, lmsUser.Id, availability);
                if (slots.Any())
                {
                    var newAvailabilityDto =
                        BuildAvailabilityBySlots(slots, dto.FirstSlotTimeshift, availability.Duration);
                    oh = oh ?? availability.Meeting;
                    var overlappingSlots = await ValidateSlotsRange(oh, lmsUser.Id, newAvailabilityDto);

                    if (overlappingSlots.Any(x => x.Status != (int)OfficeHoursSlotStatus.Free))
                    {
                        return(OperationResultWithData <List <SlotDto> > .Error(
                                   "The range of dates overlaps another date range. Please choose another date range."));
                    }
                    if (overlappingSlots.Any(x => (x.End - x.Start).Minutes != availability.Duration))
                    {
                        return(OperationResultWithData <List <SlotDto> > .Error(
                                   "The duration of new slots doesn't match duration of overalpped free slots."));
                    }
                    if (overlappingSlots.Any())
                    {
                        var slotsForAvailability = slots.Where(x =>
                                                               overlappingSlots.All(os => os.Start != x.Start.AddMilliseconds(dto.FirstSlotTimeshift)));
                        if (slotsForAvailability.Any())
                        {
                            newAvailabilityDto = BuildAvailabilityBySlots(slotsForAvailability, dto.FirstSlotTimeshift,
                                                                          availability.Duration);
                        }
                        else
                        {
                            slotsToAdd.AddRange(slots);
                            continue;
                        }
                    }
                    availabilitiesToAdd.Add(newAvailabilityDto);
                    slotsToAdd.AddRange(slots);
                }
            }

            foreach (var availabilityDto in availabilitiesToAdd)
            {
                var a = await AddAvailability(oh, lmsUser, availabilityDto);

                if (!a.IsSuccess)
                {
                    //todo: delete already added availabilities
                    return(OperationResultWithData <List <SlotDto> > .Error(a.Message));
                }
            }
            var notAddedSlots = new List <string>();
            var deniedSlots   = new List <SlotDto>();
            //var details = await _meetingService.GetMeetingApiDetails(meeting);
            //if (dto.KeepRegistration)
            //{
            var dbSlots = _slotModel.GetSlotsForDate(dto.Start, dto.End, ohId);

            foreach (var slotDto in slotsToAdd) //todo: add many slots at once
            {
                if (slotDto.Status == (int)OfficeHoursSlotStatus.Booked)
                {
                    slotDto.Start = slotDto.Start.AddMilliseconds(dto.FirstSlotTimeshift);
                    slotDto.End   = slotDto.End.AddMilliseconds(dto.FirstSlotTimeshift);
                    if (dto.KeepRegistration)
                    {
                        var s = await AddSlots(oh.Id, dbSlots.First(x => x.Id == slotDto.Id).User, new[] { slotDto });

                        if (!s.IsSuccess)
                        {
                            notAddedSlots.Add(slotDto.UserName);
                            slotDto.Id        = 0;
                            slotDto.Status    = (int)OfficeHoursSlotStatus.Free;
                            slotDto.Subject   = null;
                            slotDto.Questions = null;
                            slotDto.UserName  = null;
                            slotDto.CanEdit   = false;
                        }
                        if (s.IsSuccess && !string.IsNullOrEmpty(dto.Message))
                        {
                            //await _notificationService.SendOHRescheduleEmail(slotDto.Start, s.Data.First(),
                            //    details.Topic, dto.Message);
                        }
                    }
                    else
                    {
                        //await _notificationService.SendOHCancellationEmail(slotDto.Start, details.Topic, dto.Message, slotDto.UserName);
                    }
                    var updateResult = await UpdateSlotStatusInternal(slotDto.Id, OfficeHoursSlotStatus.Cancelled, lmsUser);

                    result.Add(slotDto);
                }

                //
                else
                {
                    deniedSlots.Add(slotDto);
                }
            }
            //}
            var denyFreeSlotsResult = await AddSlots(oh.Id, lmsUser, deniedSlots, OfficeHoursSlotStatus.Cancelled);

            deniedSlots.ForEach(x =>
            {
                x.Start = x.Start.AddMilliseconds(dto.FirstSlotTimeshift);
                x.End   = x.End.AddMilliseconds(dto.FirstSlotTimeshift);
            });

            result.AddRange(deniedSlots);
            var opResult = result.ToSuccessResult();

            if (notAddedSlots.Any())
            {
                opResult.Message = $"Slots for the following users were not moved: {String.Join(", ", notAddedSlots)}";
            }

            return(opResult);
        }