Exemple #1
0
 private static void UpdateMeetingSession(MeetingSessionDTO dto, LmsMeetingSession dbEvent)
 {
     dbEvent.Name      = dto.Name;
     dbEvent.Summary   = dto.Summary;
     dbEvent.StartDate = dto.StartDate;
     dbEvent.EndDate   = dto.EndDate;
 }
Exemple #2
0
        public async Task <MeetingSessionDTO> CreateSessionAsync(int meetingId, LtiParamDTO param)
        {
            LmsCourseMeeting meeting = _lmsCourseMeetingModel.GetOneById(meetingId).Value;

            MeetingNameInfo nameInfo = string.IsNullOrWhiteSpace(meeting.MeetingNameJson)
                ? new MeetingNameInfo()
                : JsonConvert.DeserializeObject <MeetingNameInfo>(meeting.MeetingNameJson);

            var      lastEvent = meeting.MeetingSessions.OrderByDescending(x => x.StartDate).FirstOrDefault();
            DateTime startDate = DateTime.UtcNow.AddHours(1);
            DateTime endDate   = startDate.AddHours(1);

            if (lastEvent != null)
            {
                startDate = lastEvent.StartDate.AddDays(1);
                endDate   = lastEvent.EndDate.AddDays(1);
            }

            var ev = new MeetingSessionDTO
            {
                Name      = nameInfo.meetingName + " #",
                Summary   = string.Empty,
                StartDate = startDate,
                EndDate   = endDate,
            };

            if (_calendarExportService != null)
            {
                var sakaiEventResult = await _calendarExportService.SaveEventsAsync(meetingId, new MeetingSessionDTO[] { ev }, param, _license);

                ev = sakaiEventResult.Single();
            }
            var dbEvent = new LmsMeetingSession
            {
                LmsCalendarEventId = ev.EventId,
                Name             = ev.Name,
                StartDate        = ev.StartDate,
                EndDate          = ev.EndDate,
                LmsCourseMeeting = meeting,
            };

            if (_calendarEventService != null)
            {
                var lmsSettings = _license.GetLMSSettings(Settings);
                LmsCalendarEventDTO calendarEventDto = new LmsCalendarEventDTO()
                {
                    Title   = dbEvent.Name,
                    StartAt = dbEvent.StartDate,
                    EndAt   = dbEvent.EndDate
                };
                LmsCalendarEventDTO newClaendarEventDto = await _calendarEventService.CreateEvent(param.course_id.ToString(), lmsSettings, calendarEventDto);

                dbEvent.LmsCalendarEventId = newClaendarEventDto?.Id;
            }

            meeting.MeetingSessions.Add(dbEvent);
            _lmsCourseMeetingModel.RegisterSave(meeting, true);
            return(ConvertFromEntity(dbEvent));
        }
Exemple #3
0
        private MeetingSessionDTO ConvertFromEntity(LmsMeetingSession entity)
        {
            var result = new MeetingSessionDTO
            {
                Id        = entity.Id,
                Name      = entity.Name,
                StartDate = entity.StartDate,
                EndDate   = entity.EndDate,
                Summary   = entity.Summary,
            };

            return(result);
        }
Exemple #4
0
 private async Task RemoveCalendarEvent(LmsMeetingSession dbEvent)
 {
     if (_calendarEventService != null)
     {
         try
         {
             var lmsSettings = _license.GetLMSSettings(Settings);
             if (!string.IsNullOrEmpty(dbEvent.LmsCalendarEventId))
             {
                 await _calendarEventService.DeleteCalendarEvent(dbEvent.LmsCalendarEventId, lmsSettings);
             }
         }
         catch (Exception e)
         {
             _logger.Error(e.Message);
         }
     }
 }
Exemple #5
0
        public async Task DeleteSessionAsync(int meetingId, int id, LtiParamDTO param)
        {
            LmsCourseMeeting  meeting = null;
            LmsMeetingSession dbEvent = null;

            if (meetingId != 0)
            {
                meeting = _lmsCourseMeetingModel.GetOneById(meetingId).Value;

                dbEvent = meeting.MeetingSessions.FirstOrDefault(x => x.Id == id);

                if (dbEvent == null)
                {
                    throw new InvalidOperationException(
                              $"Could not find meeting session in database. MeetingId={meetingId}, Id={id}");
                }
            }

            if (_calendarExportService != null)
            {
                var deleteResult = (await _calendarExportService.DeleteEventsAsync(new[] { dbEvent.LmsCalendarEventId }, param, _license))
                                   .Single();

                if (!string.IsNullOrWhiteSpace(deleteResult) &&
                    !dbEvent.LmsCalendarEventId.Equals(deleteResult, StringComparison.InvariantCultureIgnoreCase))
                {
                    // TODO: logging
                    throw new InvalidOperationException("Some events could not be removed from Sakai calendar.");
                }
            }

            await RemoveCalendarEvent(dbEvent);

            if (meetingId != 0)
            {
                meeting.MeetingSessions.Remove(dbEvent);
                _lmsCourseMeetingModel.RegisterSave(meeting, true);
            }
        }
Exemple #6
0
 private async Task UpdateCalendarEvent(MeetingSessionDTO dto, LtiParamDTO param, LmsMeetingSession dbEvent)
 {
     if (_calendarEventService != null)
     {
         if (!string.IsNullOrEmpty(dbEvent.LmsCalendarEventId))
         {
             var lmsSettings = _license.GetLMSSettings(Settings);
             LmsCalendarEventDTO calendarEventDto = new LmsCalendarEventDTO
             {
                 Id      = dbEvent.LmsCalendarEventId,
                 Title   = dto.Name,
                 StartAt = dto.StartDate,
                 EndAt   = dto.EndDate
             };
             await _calendarEventService.UpdateEvent(param.course_id.ToString(), lmsSettings, calendarEventDto);
         }
     }
 }