public virtual OperationResultWithData <IEnumerable <ACSessionDto> > GetSessionsReport([FromBody] ReportRequestDto request)
{
try
{
LmsCourseMeeting meeting = LmsCourseMeetingModel.GetOneByCourseAndId(LmsCompany.Id, CourseId, request.MeetingId);
if (meeting == null)
{
return(OperationResultWithData <IEnumerable <ACSessionDto> > .Error(Messages.MeetingNotFound));
}
IEnumerable <ACSessionDto> report = _reportService.GetSessionsReports(
meeting.GetMeetingScoId(),
GetAdminProvider(),
TimeZoneInfo.Utc,
request.StartIndex,
request.Limit);
return(report.ToSuccessResult());
}
catch (Exception ex)
{
string errorMessage = GetOutputErrorMessage("GetSessionsReport", ex);
return(OperationResultWithData <IEnumerable <ACSessionDto> > .Error(errorMessage));
}
}
public string UpdateName(LmsCourseMeeting meeting, string lmsMeetingTitle)
{
if (meeting == null)
{
throw new ArgumentNullException(nameof(meeting));
}
if (string.IsNullOrWhiteSpace(lmsMeetingTitle))
{
throw new ArgumentException("Meeting Title is required", nameof(lmsMeetingTitle));
}
MeetingNameInfo nameInfo = _nameInfoDeserializer.JsonDeserialize <MeetingNameInfo>(meeting.MeetingNameJson);
nameInfo.meetingName = lmsMeetingTitle;
meeting.MeetingNameJson = _nameInfoSerializer.JsonSerialize(nameInfo);
if (meeting.LmsMeetingType == (int)LmsMeetingType.OfficeHours)
{
return(lmsMeetingTitle.TruncateIfMoreThen(60));
}
int extraDataLength = ((string)nameInfo.courseNum).Length + ": ".Length + " - ".Length + ((string)nameInfo.courseId).Length;
if (extraDataLength > 52)
{
throw new WarningMessageException("Can't generate Adobe Connect meeting name. Course Label is too long.");
}
return(string.Format("{0}: {1} - {2}", (string)nameInfo.courseNum, lmsMeetingTitle.TruncateIfMoreThen(60 - extraDataLength), (string)nameInfo.courseId));
}
public async Task <OperationResultWithData <SlotDto> > BookSlot([FromBody] CreateSlotDto dto)
{
LmsCourseMeeting meeting = _lmsCourseMeetingModel.GetOneByCourseAndId(LmsCompany.Id, CourseId, dto.MeetingId);
if (meeting?.OfficeHours == null)
{
return(OperationResultWithData <SlotDto> .Error("Meeting not found"));
}
var slotResult = await _officeHoursService.AddSlots(meeting.OfficeHours.Id, Session.LmsUser, new[] { dto }, status : OfficeHoursSlotStatus.Booked);
//if (slotResult.IsSuccess)
//{
// var details = await _meetingApiService.GetMeetingApiDetails(meeting);
// var host = _userService.GetUser(meeting.ProviderHostId); //todo: get user data from lmsUser table
// if (host != null)
// {
// _queue.QueueBackgroundWorkItem(async token =>
// {
// await _notificationService.SendOHBookSlotEmail(slotResult.Data.First(), details.Topic, host.Email,
// $"{host.FirstName} {host.LastName}");
// Logger.Info($"Email for slotId={slotResult.Data.First().Id} is sent to host {host.Email}");
// });
// }
//}
return(slotResult.IsSuccess ? slotResult.Data.First().ToSuccessResult() : OperationResultWithData <SlotDto> .Error(slotResult.Message));
}
public OperationResult SaveSeminarSession([FromBody] SeminarSessionInputDto seminarSessionDto)
{
try
{
// TRICK: change record meeting id to meeting sco-id
LmsCourseMeeting meeting = this.LmsCourseMeetingModel.GetOneByCourseAndId(LmsCompany.Id, CourseId, long.Parse(seminarSessionDto.SeminarRoomId));
if (meeting == null)
{
return(OperationResult.Error(Messages.MeetingNotFound));
}
//NOTE: save under admin account doesn't work for user license
var ac = GetUserProvider();
ProcessQuota(ac, meeting.ScoId, seminarSessionDto);
//var timeZone = AcAccountService.GetAccountDetails(ac, IoC.Resolve<ICache>()).TimeZoneInfo;
var meetingUpdateResult = _seminarService.SaveSeminarSession(seminarSessionDto, meeting.ScoId, ac /*, timeZone*/);
return(meetingUpdateResult);
}
catch (Exception ex)
{
string errorMessage = GetOutputErrorMessage("SaveSeminarSession", ex);
return(OperationResult.Error(errorMessage));
}
}
public OperationResult UnpublishRecording([FromBody] RecordingRequestDto request)
{
try
{
// TODO : FeatureName - but default value is true here!
if (LmsCompany.AutoPublishRecordings)
{
throw new WarningMessageException("UnPublishing is not allowed by LMS license settings");
}
LmsCourseMeeting meeting = this.LmsCourseMeetingModel.GetOneByCourseAndId(LmsCompany.Id, CourseId, request.MeetingId);
var recording = meeting.MeetingRecordings.FirstOrDefault(x => x.ScoId == request.RecordingId);
if (recording != null)
{
meeting.MeetingRecordings.Remove(recording);
LmsCourseMeetingModel.RegisterSave(meeting, flush: true);
}
return(OperationResult.Success());
}
catch (Exception ex)
{
string errorMessage = GetOutputErrorMessage("PublishRecording", ex);
return(OperationResult.Error(errorMessage));
}
}
public OperationResult RemoveRecording(
ILmsLicense lmsCompany,
IAdobeConnectProxy provider,
string courseId,
string recordingId,
int id)
{
LmsCourseMeeting meeting = lmsCourseMeetingModel.GetOneByCourseAndId(lmsCompany.Id, courseId, id);
if (meeting == null)
{
return(OperationResult.Error(Resources.Messages.MeetingNotFound));
}
ScoContentCollectionResult result = provider.GetMeetingRecordings(new[] { meeting.GetMeetingScoId() }, lmsCompany.UseMP4);
var recording = result.Values.FirstOrDefault(x => x.ScoId == recordingId);
if (recording == null)
{
return(OperationResult.Error(Resources.Messages.RecordingNotFound));
}
/*if (recording.Icon == "mp4-archive")
* {
* var scheduledRecording = this.GetScheduledRecording(recordingId, scoId, provider);
* if (scheduledRecording.JobStatus == "job-pending")
* {
* return OperationResult.Error("Cannot delete " + scheduledRecording.Name + " MP4 recording. Recording converting - in progress");
* }
* }*/
provider.DeleteSco(recordingId);
return(OperationResult.Success());
}
private async Task CreateCalendarEvents(LtiParamDTO param, LmsCourseMeeting meeting)
{
if (_calendarEventService == null)
{
return;
}
foreach (var session in meeting.MeetingSessions)
{
var eventDto = new LmsCalendarEventDTO
{
StartAt = session.StartDate,
EndAt = session.EndDate,
Title = session.Name
};
var lmsSettings = _license.GetLMSSettings(Settings);
try
{
LmsCalendarEventDTO lmsCalendarEvent =
await _calendarEventService.CreateEvent(param.course_id.ToString(), lmsSettings, eventDto);
session.LmsCalendarEventId = lmsCalendarEvent?.Id;
}
catch (Exception e)
{
_logger.Error(e.Message);
return;
}
}
}
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));
}
private static LmsMeetingSession GetMeetingSession(MeetingSessionDTO dto, LmsCourseMeeting meeting)
{
var meetingSession = meeting.MeetingSessions.SingleOrDefault(x => x.Id == dto.Id)
?? new LmsMeetingSession {
LmsCourseMeeting = meeting
};
return(meetingSession);
}
public async Task <OperationResultWithData <OfficeHoursTeacherAvailabilityDto> > AddAvailabitily([FromBody] OfficeHoursTeacherAvailabilityDto dto)
{
LmsCourseMeeting meeting = _lmsCourseMeetingModel.GetOneByCourseAndId(LmsCompany.Id, CourseId, dto.MeetingId);
if (meeting?.OfficeHours == null)
{
return(OperationResultWithData <OfficeHoursTeacherAvailabilityDto> .Error("Meeting not found"));
}
var result = await _officeHoursService.AddAvailability(meeting.OfficeHours, Session.LmsUser, dto);
return(result);
}
public async Task <OperationResultWithData <IEnumerable <OfficeHoursTeacherAvailabilityDto> > > GetAvailabilities([FromBody] MeetingIdDto dto)
{
LmsCourseMeeting meeting = _lmsCourseMeetingModel.GetOneByCourseAndId(LmsCompany.Id, CourseId, dto.MeetingId);
if (meeting?.OfficeHours == null)
{
return(OperationResultWithData <IEnumerable <OfficeHoursTeacherAvailabilityDto> > .Error("Meeting not found"));
}
var availabilities = await _officeHoursService.GetAvailabilities(meeting.OfficeHours.Id, null); //todo: show slots accross the courses
return(availabilities.ToSuccessResult());
}
public async Task <OperationResult> ResetDeniedDate([FromBody] DenyDateDto dto)
{
LmsCourseMeeting meeting = _lmsCourseMeetingModel.GetOneByCourseAndId(LmsCompany.Id, CourseId, dto.MeetingId);
if (meeting?.OfficeHours == null)
{
return(OperationResultWithData <IEnumerable <SlotDto> > .Error("Meeting not found"));
}
var result = await _officeHoursService.ResetDeniedSlots(meeting.OfficeHours.Id, dto);
return(result);
}
[LmsAuthorizeBase] // TeacherOnly ?
public async Task <OperationResultWithData <SlotDto> > DenySlotByDate([FromBody] DenySlotByDateDto dto)
{
LmsCourseMeeting meeting = _lmsCourseMeetingModel.GetOneByCourseAndId(LmsCompany.Id, CourseId, dto.MeetingId);
if (meeting?.OfficeHours == null)
{
return(OperationResultWithData <SlotDto> .Error("Meeting not found"));
}
var result = await _officeHoursService.DenySlotByDate(meeting.OfficeHours.Id, dto.Start, Session.LmsUser);
return(result);
}
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);
}
public virtual async Task <OperationResult> UpdateMeeting([FromBody] EditMeetingDto input)
{
try
{
var trace = new StringBuilder();
var ac = GetAdminProvider();
//bool useLmsUserEmailForSearch = true;
var useLmsUserEmailForSearch = !string.IsNullOrEmpty(input.ApiLtiParam.lis_person_contact_email_primary);
var fb = new MeetingFolderBuilder((LmsCompany)LmsCompany, ac, useLmsUserEmailForSearch, LmsMeetingType.Meeting);
// HACK: we support Meeting only.
LmsCourseMeeting existed = _meetingSetup.GetCourseMeeting(LmsCompany, input.ApiLtiParam.course_id, input.Id, LmsMeetingType.Meeting);
string meetingSco = existed.GetMeetingScoId();
bool isNewMeeting = string.IsNullOrEmpty(meetingSco);
if (isNewMeeting)
{
return(OperationResult.Error("Meeting not found"));
}
var acProvider = this.GetAdminProvider();
ScoInfoResult scoResult = acProvider.GetScoInfo(meetingSco);
MeetingDTOInput meeting = input.Build(existed, scoResult.ScoInfo);
//LmsUser lmsUser = IoC.Resolve<LmsUserModel>()
// .GetOneByUserIdAndCompanyLms(input.ApiLtiParam.lms_user_id, LmsCompany.Id).Value;
//MeetingDTO dto = await _meetingSetup.BuildDto(
// lmsUser,
// input.ApiLtiParam,
// LmsCompany,
// meeting,
// null,
// //timeZone,
// trace);
OperationResult ret = await _meetingSetup.SaveMeeting(
LmsCompany,
ac,
input.ApiLtiParam,
meeting,
trace,
fb);
return(ret);
}
catch (Exception ex)
{
string errorMessage = GetOutputErrorMessage("UpdateMeeting", ex);
return(OperationResult.Error(errorMessage));
}
}
public async Task <MeetingSessionDTO> SaveSessionAsync(int meetingId, MeetingSessionDTO dto, LtiParamDTO param)
{
LmsCourseMeeting meeting = _lmsCourseMeetingModel.GetOneById(meetingId).Value;
var meetingSession = GetMeetingSession(dto, meeting);
if (meetingSession.Id == 0)
{
meeting.MeetingSessions.Add(meetingSession);
}
await UpdateCalendarEvent(dto, param, meetingSession);
UpdateMeetingSession(dto, meetingSession);
_lmsCourseMeetingModel.RegisterSave(meeting, true);
return(ConvertFromEntity(meetingSession));
}
//private static IEnumerable<IRecordingDto> GetRecordingsLegacy(string meetingSco,
// string accountUrl,
// TimeZoneInfo timeZone,
// Esynctraining.AdobeConnect.IAdobeConnectProxy provider)
//{
// var result = new List<RecordingDto>();
// ScoContentCollectionResult apiRecordings = provider.GetMeetingRecordings(new [] {meetingSco});
// foreach (var v in apiRecordings.Values)
// {
// var moreDetails = provider.GetScoPublicAccessPermissions(v.ScoId);
// var isPublic = false;
// if (moreDetails.Success && moreDetails.Values.Any())
// {
// isPublic = moreDetails.Values.First().PermissionId == PermissionId.view;
// }
// result.Add(new RecordingDto(v, accountUrl, isPublic, timeZone));
// }
// return result;
//}
private static void ProcessPublishedFlag(ILmsLicense lmsCompany, LmsCourseMeeting meeting, IEnumerable <IRecordingDto> records)
{
if (lmsCompany.AutoPublishRecordings)
{
foreach (var item in records)
{
item.Published = true;
}
}
else
{
foreach (var item in records)
{
item.Published = meeting.MeetingRecordings.Any(r => r.ScoId == item.Id);
}
}
}
public OperationResult EditRecording(
ILmsLicense lmsCompany,
IAdobeConnectProxy provider,
string courseId,
string recordingId,
int id,
string name,
string summary)
{
LmsCourseMeeting meeting = lmsCourseMeetingModel.GetOneByCourseAndId(lmsCompany.Id, courseId, id);
if (meeting == null)
{
return(OperationResult.Error(Resources.Messages.MeetingNotFound));
}
ScoContentCollectionResult result = provider.GetMeetingRecordings(new[] { meeting.GetMeetingScoId() }, lmsCompany.UseMP4);
var recording = result.Values.FirstOrDefault(x => x.ScoId == recordingId);
if (recording == null)
{
return(OperationResult.Error(Resources.Messages.RecordingNotFound));
}
ScoInfoResult editResult = provider.UpdateSco <RecordingUpdateItem>(new RecordingUpdateItem
{
ScoId = recordingId,
Name = name.Trim(),
Description = summary,
Type = ScoType.content,
});
if (!editResult.Success || editResult.ScoInfo == null)
{
if ((editResult.Status.SubCode == StatusSubCodes.duplicate) && (editResult.Status.InvalidField == "name"))
{
return(OperationResult.Error(Resources.Messages.NotUniqueName));
}
return(OperationResult.Error(editResult.Status.GetErrorInfo()));
}
return(OperationResult.Success());
}
public async Task <IEnumerable <MeetingSessionDTO> > CreateBatchAsync(CreateMeetingSessionsBatchDto dto, LtiParamDTO param)
{
LmsCourseMeeting meeting = _lmsCourseMeetingModel.GetOneById(dto.MeetingId).Value;
DateTime startDate = dto.StartTimestamp;
var endDate = TimeSpan.TryParse(dto.Duration, out var duration)
? startDate.AddMinutes((int)duration.TotalMinutes)
: startDate.AddHours(1);
//MeetingNameInfo nameInfo = string.IsNullOrWhiteSpace(meeting.MeetingNameJson)
// ? new MeetingNameInfo()
// : JsonConvert.DeserializeObject<MeetingNameInfo>(meeting.MeetingNameJson);
//var meetingName = nameInfo.meetingName ?? nameInfo.reusedMeetingName;
//int i = 1;
var latestDateToCheck = startDate.AddDays(dto.Weeks * 7);
var listOfEvents = new List <MeetingSessionDTO>();
while (startDate < latestDateToCheck)
{
if (dto.DaysOfWeek.Contains((int)startDate.DayOfWeek))
{
var ev = new MeetingSessionDTO
{
//Name = meetingName + " #" + i.ToString(),
Summary = string.Empty,
StartDate = startDate, //.ToString("yyyy-MM-dd HH:mm"),
EndDate = endDate, //.ToString("yyyy-MM-dd HH:mm"),
};
listOfEvents.Add(ev);
//i++;
}
startDate = startDate.AddDays(1);
endDate = endDate.AddDays(1);
}
if (_calendarExportService != null)
{
listOfEvents = (await _calendarExportService.SaveEventsAsync(meeting.Id, listOfEvents, param, _license))
.ToList();
}
return(listOfEvents.ToArray());
}
public string UpdateName(LmsCourseMeeting meeting, string lmsMeetingTitle)
{
if (meeting == null)
{
throw new ArgumentNullException(nameof(meeting));
}
if (string.IsNullOrWhiteSpace(lmsMeetingTitle))
{
throw new ArgumentException("Meeting Title is required", nameof(lmsMeetingTitle));
}
MeetingNameInfo nameInfo = _nameInfoDeserializer.JsonDeserialize <MeetingNameInfo>(meeting.MeetingNameJson);
nameInfo.meetingName = lmsMeetingTitle;
meeting.MeetingNameJson = _nameInfoSerializer.JsonSerialize(nameInfo);
return(lmsMeetingTitle.TruncateIfMoreThen(60));
}
private async Task RemoveCalendarEvents(LmsCourseMeeting meeting)
{
if (_calendarEventService != null)
{
try
{
var lmsSettings = _license.GetLMSSettings(Settings);
foreach (var session in meeting.MeetingSessions.Where(s => !String.IsNullOrEmpty(s.LmsCalendarEventId)))
{
await _calendarEventService.DeleteCalendarEvent(session.LmsCalendarEventId, lmsSettings);
}
}
catch (Exception e)
{
_logger.Error(e.Message);
}
}
}
public async Task <OperationResultWithData <IEnumerable <SlotDto> > > GetSlots([FromBody] GetSlotsDto dto)
{
LmsCourseMeeting meeting = _lmsCourseMeetingModel.GetOneByCourseAndId(LmsCompany.Id, CourseId, dto.MeetingId);
if (meeting?.OfficeHours == null)
{
return(OperationResultWithData <IEnumerable <SlotDto> > .Error("Meeting not found"));
}
var dateStartConverted = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(dto.Start);
DateTime?dateEndConverted = dto.End.HasValue ? new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(dto.End.Value) : (DateTime?)null;
var slots = await _officeHoursService.GetSlots(meeting.OfficeHours.Id, Session.LmsUser.Id, dateStartConverted, dateEndConverted);
if (dto.Status.HasValue)
{
slots = slots.Where(x => x.Status == dto.Status.Value);
}
return(slots.ToSuccessResult());
}
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);
}
}
public virtual OperationResultWithData <IEnumerable <RecordingTransactionDTO> > GetRecordingsReport([FromBody] MeetingRequestDto request)
{
try
{
LmsCourseMeeting meeting = LmsCourseMeetingModel.GetOneByCourseAndId(LmsCompany.Id, CourseId, request.MeetingId);
if (meeting == null)
{
return(OperationResultWithData <IEnumerable <RecordingTransactionDTO> > .Error(Messages.MeetingNotFound));
}
IEnumerable <RecordingTransactionDTO> report = new LtiReportService().GetRecordingsReport(
GetAdminProvider(),
meeting);
return(report.ToSuccessResult());
}
catch (Exception ex)
{
string errorMessage = GetOutputErrorMessage("GetRecordingsReport", ex);
return(OperationResultWithData <IEnumerable <RecordingTransactionDTO> > .Error(errorMessage));
}
}
public async Task DeleteMeetingSessionsAsync(LmsCourseMeeting meeting, LtiParamDTO param)
{
//if (meeting.MeetingSessions.Any())
//{
// var events = new HashSet<string>(meeting.MeetingSessions.Select(x => x.EventId));
// if (_calendarExportService != null)
// {
//todo:uncomment if need to delete sessions from API when deleting meeting
//var deleteResultIds = await _calendarExportService.DeleteEventsAsync(null, param, _license);
// if (!events.SetEquals(deleteResultIds))
// {
// _logger.Error(
// $"List of all calendar events {string.Join(",", events)}, response is {string.Join(",", deleteResultIds.ToArray())} ");
// throw new InvalidOperationException("Some events could not be removed from Sakai calendar.");
// }
//}
// meeting.MeetingSessions.Clear();
// _lmsCourseMeetingModel.RegisterSave(meeting);
//}
}
/// <summary>
/// The meeting SCO id.
/// </summary>
/// <param name="meeting">
/// The meeting.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public static string GetMeetingScoId(this LmsCourseMeeting meeting)
{
if (meeting == null)
{
throw new ArgumentNullException(nameof(meeting));
}
if (meeting.ScoId != null)
{
return(meeting.ScoId);
}
if (meeting.OfficeHours != null)
{
return(meeting.OfficeHours.ScoId);
}
// TODO: investigate
//if (meeting.Id > 0)
// throw new InvalidOperationException($"sco-id for meeting {meeting.Id} not found.");
return(null);
}
public string UpdateName(LmsCourseMeeting meeting, string lmsMeetingTitle)
{
if (meeting == null)
{
throw new ArgumentNullException(nameof(meeting));
}
if (string.IsNullOrWhiteSpace(lmsMeetingTitle))
{
throw new ArgumentException("Meeting Title is required", nameof(lmsMeetingTitle));
}
MeetingNameInfo nameInfo = _nameInfoDeserializer.JsonDeserialize <MeetingNameInfo>(meeting.MeetingNameJson);
nameInfo.meetingName = lmsMeetingTitle;
meeting.MeetingNameJson = _nameInfoSerializer.JsonSerialize(nameInfo);
if (meeting.LmsMeetingType == (int)LmsMeetingType.OfficeHours)
{
return(lmsMeetingTitle.TruncateIfMoreThen(60));
}
return(string.Format("{0}: {1}", (string)nameInfo.courseNum, lmsMeetingTitle).TruncateIfMoreThen(60));
}
private void UpdateACRoles(ILmsLicense lmsCompany, LmsCourseMeeting meeting,
IAdobeConnectProxy acProvider, List <MeetingPermissionInfo> enrollments)
{
string error = null;
var meetingRoles = usersSetup.GetUserMeetingRoles(meeting);
var dbUsers = meetingRoles
.Select(x => x.User);
try
{
usersSetup.SetDefaultRolesForNonParticipants(
lmsCompany,
acProvider,
meeting,
meetingRoles.Select(x => new LmsUserDTO
{
AcId = x.User.PrincipalId,
Id = x.User.UserIdExtended ?? x.User.UserId,
LtiId = x.User.UserId,
Login = x.User.Username,
Name = x.User.Name,
Email = x.User.Email,
LmsRole = x.LmsRole
}),
dbUsers,
enrollments,
ref error);
}
catch (Exception e)
{
var message = String.Format(
"Error happened when tried to update users in AC for meetingId={0}, scoId={1}",
meeting.Id, meeting.GetMeetingScoId());
logger.Error(message, e);
}
}
public async Task DeleteMeetingSessionsAsync(LmsCourseMeeting meeting, LtiParamDTO param)
{
if (meeting.MeetingSessions.Any())
{
var events = new HashSet <string>(meeting.MeetingSessions.Select(x => x.LmsCalendarEventId));
if (_calendarExportService != null)
{
var deleteResultIds = await _calendarExportService.DeleteEventsAsync(events, param, _license);
if (!events.SetEquals(deleteResultIds))
{
_logger.Error(
$"List of all calendar events {string.Join(",", events)}, response is {string.Join(",", deleteResultIds.ToArray())} ");
throw new InvalidOperationException("Some events could not be removed from Sakai calendar.");
}
}
await RemoveCalendarEvents(meeting);
meeting.MeetingSessions.Clear();
_lmsCourseMeetingModel.RegisterSave(meeting);
}
}
public virtual OperationResultWithData <IEnumerable <ACSessionParticipantDto> > GetAttendanceReport([FromBody] ReportRequestDto request)
{
try
{
LmsCourseMeeting meeting = this.LmsCourseMeetingModel.GetOneByCourseAndId(LmsCompany.Id, CourseId, request.MeetingId);
if (meeting == null)
{
return(OperationResultWithData <IEnumerable <ACSessionParticipantDto> > .Error(Messages.MeetingNotFound));
}
IEnumerable <ACSessionParticipantDto> report = _reportService.GetAttendanceReports(
meeting.GetMeetingScoId(),
this.GetAdminProvider(),
TimeZoneInfo.Utc,
request.StartIndex,
request.Limit);
// TRICK: check that is not API call.
if (SessionSave != null)
{
// TRICK: clean not to serialize
foreach (var item in report)
{
item.login = null;
item.principalId = null;
}
}
return(report.ToSuccessResult());
}
catch (Exception ex)
{
string errorMessage = GetOutputErrorMessage("GetAttendanceReport", ex);
return(OperationResultWithData <IEnumerable <ACSessionParticipantDto> > .Error(errorMessage));
}
}
