public async Task <LmsUserDTO> GetCourseUser(string userId, ILmsLicense lmsCompany, string userToken, int courseId)
{
try
{
Validate(lmsCompany.LmsDomain, userToken);
if (lmsCompany.AdminUser == null)
{
_logger.ErrorFormat("There is no admin user set for LmsCompanyId={0}.", lmsCompany.Id);
throw new WarningMessageException(Resources.Messages.NoLicenseAdmin);
}
var token = lmsCompany.AdminUser.Token;
if (string.IsNullOrWhiteSpace(token))
{
_logger.ErrorFormat("There is no admin user set for LmsCompanyId={0}. (AdminUser has EMPTY token).", lmsCompany.Id);
throw new WarningMessageException(Resources.Messages.NoLicenseAdmin);
}
LmsUserDTO user = await FetchCourseUser(userId, lmsCompany.LmsDomain, token, courseId);
return(user);
}
catch (Exception ex)
{
_logger.ErrorFormat(ex, "[EGCEnabledCanvasAPI.GetCourseUser] API:{0}. UserToken:{1}. CourseId:{2}. UserId:{3}.", lmsCompany.LmsDomain, userToken, courseId, userId);
throw;
}
}
public override async Task <(LmsUserDTO user, string error)> GetUser(ILmsLicense lmsCompany,
string lmsUserId, int courseId, LtiParamDTO extraData = null)
{
if (lmsCompany == null)
{
throw new ArgumentNullException(nameof(lmsCompany));
}
if (lmsCompany.AdminUser == null)
{
Logger.ErrorFormat("There is no admin user set for LmsCompanyId={0}.", lmsCompany.Id);
throw new WarningMessageException(Resources.Messages.NoLicenseAdmin);
}
var token = lmsCompany.AdminUser.Token;
if (string.IsNullOrWhiteSpace(token))
{
Logger.ErrorFormat("There is no admin user set for LmsCompanyId={0}. (AdminUser has EMPTY token).", lmsCompany.Id);
throw new WarningMessageException(Resources.Messages.NoLicenseAdmin);
}
var user = await _canvasApi.GetCourseUser(
lmsUserId,
lmsCompany,
token,
courseId);
return(user, null);
}
public LmsCourseMeeting GetLtiCreatedByCompanyAndScoId(ILmsLicense lmsCompany, string scoId)
{
if (lmsCompany == null)
{
throw new ArgumentNullException(nameof(lmsCompany));
}
if (string.IsNullOrWhiteSpace(scoId))
{
throw new ArgumentException("scoId can not be empty", nameof(scoId));
}
// NOTE: check only licenses of the company with the same AC!!
var query = from c in this.Repository.Session.Query <LmsCompany>()
where c.CompanyId == lmsCompany.CompanyId
select new { c.Id, c.AcServer };
var currentLicenseAc = new Uri(lmsCompany.AcServer);
var companyLicenses = query.ToArray().Where(c => new Uri(c.AcServer).Host == currentLicenseAc.Host).Select(c => c.Id).ToArray();
// NOTE: return only not-reused meeting - created from LTI
LmsCourseMeeting x = null;
OfficeHours oh = null;
var defaultQuery = new DefaultQueryOver <LmsCourseMeeting, int>()
.GetQueryOver(() => x)
.JoinAlias(() => x.OfficeHours, () => oh, JoinType.LeftOuterJoin)
//.Clone()
.WhereRestrictionOn(() => x.LmsCompanyId).IsIn(companyLicenses)
.Where(() =>
(x.Reused == null || x.Reused == false)
&&
(((x.ScoId != null) && (x.ScoId == scoId)) ||
(x.OfficeHours != null && oh.ScoId == scoId)))
.Take(1);
return(this.Repository.FindOne(defaultQuery).Value);
}
public IEnumerable <LmsCourseMeeting> GetByCompanyWithAudioProfiles(ILmsLicense lmsCompany)
{
if (lmsCompany == null)
{
throw new ArgumentNullException(nameof(lmsCompany));
}
// NOTE: check only licenses of the company with the same AC!!
var query = from c in this.Repository.Session.Query <LmsCompany>()
where c.CompanyId == lmsCompany.CompanyId
select new { c.Id, c.AcServer };
var currentLicenseAc = new Uri(lmsCompany.AcServer);
var companyLicenses = query.ToArray().Where(c => new Uri(c.AcServer).Host == currentLicenseAc.Host).Select(c => c.Id).ToArray();
LmsCourseMeeting x = null;
OfficeHours oh = null;
var defaultQuery = new DefaultQueryOver <LmsCourseMeeting, int>()
.GetQueryOver(() => x)
.JoinAlias(() => x.OfficeHours, () => oh, JoinType.LeftOuterJoin)
.WhereRestrictionOn(() => x.LmsCompanyId).IsIn(companyLicenses)
.And(() => x.AudioProfileId != null)
.TransformUsing(Transformers.DistinctRootEntity);
return(this.Repository.FindAll(defaultQuery));
}
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());
}
public BridgeMeetingSessionService(LmsCourseMeetingModel lmsCourseMeetingModel, ILogger logger, ICalendarExportService calendarExportService, IBridgeApi api, ILmsLicense license, LtiParamDTO param)
{
_lmsCourseMeetingModel = lmsCourseMeetingModel ?? throw new ArgumentNullException(nameof(lmsCourseMeetingModel));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_calendarExportService = calendarExportService;
_license = license;
_param = param;
_api = api;
}
public MeetingSessionService(LmsCourseMeetingModel lmsCourseMeetingModel, ILogger logger, ICalendarExportService calendarExportService, ILmsLicense license, LmsCalendarEventServiceBase calendarEventService)
{
_lmsCourseMeetingModel = lmsCourseMeetingModel ?? throw new ArgumentNullException(nameof(lmsCourseMeetingModel));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_calendarExportService = calendarExportService;
_license = license;
_calendarEventService = calendarEventService;
}
public void CheckAndSetNoneACMapping(LmsUserDTO user, ILmsLicense lmsCompany)
{
LmsCompanyRoleMapping mapping = lmsCompany.RoleMappings
.FirstOrDefault(x => x.LmsRoleName.Equals(user.LmsRole, StringComparison.OrdinalIgnoreCase));
if (mapping != null && mapping.AcRole == AcRole.None.Id) // LMS role is set to be not mapped to any AC role
{
user.AcRole = AcRole.None.Id;
}
}
public string GetPasscode(ILmsLicense lmsCompany, IAdobeConnectProxy provider, string scoId)
{
var info = provider.GetScoInfo(scoId);
if (!info.Success)
{
return(string.Empty);
}
return(info.ScoInfo.MeetingPasscode);
}
protected IAdobeConnectProxy GetAdobeConnectProvider(ILmsLicense lmsCompany)
{
IAdobeConnectProxy provider = null;
if (lmsCompany != null)
{
provider = acAccountService.GetProvider(new AdobeConnectAccess(new Uri(lmsCompany.AcServer), lmsCompany.AcUsername, lmsCompany.AcPassword), true);
}
return(provider);
}
public bool IsTeacher(ILtiParam param, ILmsLicense lmsCompany)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
if (lmsCompany == null)
{
throw new ArgumentNullException(nameof(lmsCompany));
}
if (param.roles == null)
{
return(false);
}
// ACLTI-1132 Blackboard: IsTeacher Functionality
if (lmsCompany.LmsProviderId == (int)LmsProviderEnum.Blackboard && !string.IsNullOrWhiteSpace(param.custom_role))
{
var isTeacher = lmsCompany.RoleMappings
.Where(x => x.IsTeacherRole)
.Select(x => x.LmsRoleName)
.Any(x => param.custom_role.Equals(x.Trim(), StringComparison.InvariantCultureIgnoreCase));
if (isTeacher)
{
return(isTeacher);
}
}
//LTI PARAMs from canvas do not contain custom roles.
if (lmsCompany.LmsProviderId == (int)LmsProviderEnum.Canvas)
{
char[] delimiterChars = { '/', ',', '.', ':' };
string roles = System.Web.HttpUtility.UrlDecode(param.roles);
string[] lmsRolesFromParams = roles.Split(delimiterChars);
return
//defaultTeacherRoles
((!string.IsNullOrWhiteSpace(_teacherRoles) && _teacherRoles.Split(',')
.Any(x => lmsRolesFromParams.Any(p => p.Equals(x.Trim(), StringComparison.InvariantCultureIgnoreCase))))
//licenseSpecificTeacherRoles
|| lmsCompany.RoleMappings.Where(x => x.IsTeacherRole).Select(x => x.LmsRoleName)
.Any(x => lmsRolesFromParams.Any(p => p.Equals(x.Trim(), StringComparison.InvariantCultureIgnoreCase))));
}
return
//defaultTeacherRoles
((!string.IsNullOrWhiteSpace(_teacherRoles) && _teacherRoles.Split(',')
.Any(x => param.roles.IndexOf(x.Trim(), StringComparison.InvariantCultureIgnoreCase) >= 0))
//licenseSpecificTeacherRoles
|| lmsCompany.RoleMappings.Where(x => x.IsTeacherRole).Select(x => x.LmsRoleName)
.Any(x => param.roles.IndexOf(x.Trim(), StringComparison.InvariantCultureIgnoreCase) >= 0));
}
internal Task <(Session session, string error)> BeginBatchAsync(ILmsLicense lmsCompany)
{
var lmsUser = lmsCompany.AdminUser;
if (lmsUser != null)
{
string lmsDomain = lmsUser.LmsCompany.LmsDomain;
return(LoginAndCreateASessionAsync(lmsDomain, lmsUser.Username, lmsUser.Password));
}
return(Task.FromResult(((Session)null, "ASP.NET Session is expired")));
}
public IAdobeConnectProxy GetProvider(ILmsLicense license, bool login = true)
{
var credentials = new UserCredentials(license.AcUsername, license.AcPassword);
try
{
return(GetProvider(license.AcServer, credentials, login));
}
catch (InvalidOperationException ex)
{
throw new Core.WarningMessageException("Adobe Connect Server credentials are not valid in the license. Please contact EGC administrator.", ex);
}
}
public MeetingPermissionId SetAcRole(ILmsLicense lmsCompany, LmsUserDTO u, bool ignoreEmptyACRole = false)
{
string role = u.LmsRole != null?u.LmsRole.ToLower() : string.Empty;
var permission = MeetingPermissionId.view;
u.AcRole = AcRole.Participant.Id;
if (string.IsNullOrWhiteSpace(u.Id) || u.Id.Equals("0"))
{
permission = MeetingPermissionId.remove;
u.AcRole = null; // "Remove"; // probably doesn't make sence, need to review and remove
}
LmsCompanyRoleMapping mapping = lmsCompany.RoleMappings.FirstOrDefault(x => x.LmsRoleName.Equals(role, StringComparison.OrdinalIgnoreCase));
if (mapping != null)
{
if (mapping.AcRole == AcRole.None.Id)
{
if (!ignoreEmptyACRole)
{
permission = AcRole.None.MeetingPermissionId;
u.AcRole = AcRole.None.Id;
}
return(permission);
}
else
{
AcRole acRole = AcRole.GetById(mapping.AcRole);
u.AcRole = acRole.Id;
return(acRole.MeetingPermissionId);
}
}
if (role.Contains("teacher") || role.Contains("instructor") || role.Contains("owner") ||
role.Contains("admin") || role.Contains("lecture"))
{
permission = MeetingPermissionId.host;
u.AcRole = AcRole.Host.Id;
}
else if (role.Contains("ta") || role.Contains("designer") || role.Contains("author") ||
role.Contains("teaching assistant") || role.Contains("course builder") ||
role.Contains("grader") || role == "advisor")
{
u.AcRole = AcRole.Presenter.Id;
permission = MeetingPermissionId.mini_host;
}
return(permission);
}
private IAdobeConnectProxy GetAdminProvider(ILmsLicense lmsCompany)
{
string cacheKey = CachePolicies.Keys.CompanyLmsAdobeConnectProxy(lmsCompany.Id);
var provider = _acCache.Get(cacheKey) as IAdobeConnectProxy;
if (provider == null)
{
provider = acAccountService.GetProvider(lmsCompany, login: true);
var sessionTimeout = acAccountService.GetAccountDetails(provider, Cache).SessionTimeout - 1; //-1 is to be sure
_acCache.Set(cacheKey, provider, DateTimeOffset.Now.AddMinutes(sessionTimeout));
}
return(provider);
}
private IEnumerable <LmsUser> UpdateDbUsers(List <LmsUserDTO> lmsUserDtos, ILmsLicense lmsCompany,
IEnumerable <LmsUser> existedDbUsers, IAdobeConnectProxy provider)
{
var newUsers = new List <LmsUser>();
var company = lmsCompanyModel.GetOneById(lmsCompany.Id).Value;
foreach (var lmsUserDto in lmsUserDtos.Where(x => x.Email != null || x.Login != null || x.Name != null))
{
var dbUser = existedDbUsers.FirstOrDefault(u =>
(lmsUserDto.LtiId != null && u.UserId == lmsUserDto.LtiId) || u.UserId == lmsUserDto.Id);
if (dbUser == null)
{
string login = lmsUserDto.GetLogin();
Principal principal = null;
try
{
principal = acUserService.GetOrCreatePrincipal(provider, login, lmsUserDto.Email,
lmsUserDto.GetFirstName(),
lmsUserDto.GetLastName(), lmsCompany);
}
catch (Exception ex)
{
logger.Error("SyncUsers - GetOrCreatePrincipal", ex);
continue;
}
var loginLength = login.Length > 50 ? 50 : login.Length;
dbUser = new LmsUser
{
LmsCompany = company,
Username = login.Substring(0, loginLength), // hack: to escape GenericADOException when name>50 //todo: review lmsUserDto.GetLogin() and lmsUser.Username usage
UserId = lmsUserDto.LtiId ?? lmsUserDto.Id,
PrincipalId = principal?.PrincipalId,
};
newUsers.Add(dbUser);
logger.InfoFormat(
"New user to DB: lmsCompanyId={0}, UserId={1}, Username={2}, Name={3}, Email={4}",
lmsCompany.Id, dbUser.UserId, login, lmsUserDto.Name, lmsUserDto.Email);
lmsUserModel.RegisterSave(dbUser);
}
dbUser.Name = lmsUserDto.Name;
dbUser.Email = lmsUserDto.Email;
dbUser.UserIdExtended = lmsUserDto.LtiId != null ? lmsUserDto.Id : null;
// todo: save lmsUserDto.id to dbUser.UserId
}
return(newUsers);
}
private async Task CreateAnnouncement(
LmsMeetingType meetingType,
ILmsLicense lmsCompany,
ILtiParam param,
MeetingDTOInput meetingDto)
{
if (!lmsCompany.ShowAnnouncements.GetValueOrDefault() || string.IsNullOrEmpty(param.context_title))
{
return;
}
var announcementTitle = string.Format(
"A new {0} room was created for course {1}",
meetingNames[meetingType],
param.context_title);
string announcementMessage = GetAnnouncementMessage(meetingType, meetingDto, param.referer);
switch (lmsCompany.LmsProviderId)
{
case (int)LmsProviderEnum.Canvas:
var lmsUser = LmsUserModel.GetOneByUserIdAndCompanyLms(param.lms_user_id, lmsCompany.Id).Value;
var token = UsersSetup.IsTeacher(param, lmsCompany) && !string.IsNullOrEmpty(lmsUser.Token)
? lmsUser.Token
: lmsCompany.AdminUser.Return(a => a.Token, string.Empty);
await CanvasApi.CreateAnnouncement(
lmsCompany.LmsDomain,
token,
param.course_id,
announcementTitle,
announcementMessage);
break;
case (int)LmsProviderEnum.Blackboard:
BlackboardApi.CreateAnnouncement(param.course_id.ToString(), param.lms_user_id, lmsCompany.GetLMSSettings(Settings), announcementTitle, announcementMessage);
break;
case (int)LmsProviderEnum.AgilixBuzz:
// string error;
// this.dlapApi.CreateAnnouncement(
// credentials,
// param.course_id,
// announcementTitle,
// announcementMessage,
// out error);
break;
}
}
private IAdobeConnectProxy GetAdminProvider(ILmsLicense lmsCompany)
{
string cacheKey = CachePolicies.Keys.CompanyLmsAdobeConnectProxy(lmsCompany.Id);
var provider = _cache.Get(cacheKey) as IAdobeConnectProxy;
if (provider == null)
{
provider = AcAccountService.GetProvider(new AdobeConnectAccess(new Uri(lmsCompany.AcServer), lmsCompany.AcUsername, lmsCompany.AcPassword), true);
var sessionTimeout = AcAccountService.GetAccountDetails(provider).SessionTimeout - 1; //-1 is to be sure
_cache.Set(cacheKey, provider, DateTimeOffset.Now.AddMinutes(sessionTimeout));
}
return(provider);
}
public IEnumerable <LmsCourseMeeting> GetByCompanyAndScoId(ILmsLicense lmsCompany, string scoId, int excludedLmsCourseMeetingId)
{
if (lmsCompany == null)
{
throw new ArgumentNullException(nameof(lmsCompany));
}
if (string.IsNullOrWhiteSpace(scoId))
{
throw new ArgumentException("scoId can not be empty", nameof(scoId));
}
var defaultQuery = GetByCompanyAndScoIdQuery(lmsCompany, scoId, excludedLmsCourseMeetingId);
return(this.Repository.FindAll(defaultQuery));
}
public bool ContainsByCompanyAndScoId(ILmsLicense lmsCompany, string scoId, int excludedLmsCourseMeetingId)
{
if (lmsCompany == null)
{
throw new ArgumentNullException(nameof(lmsCompany));
}
if (string.IsNullOrWhiteSpace(scoId))
{
throw new ArgumentException("scoId can not be empty", nameof(scoId));
}
var defaultQuery = GetByCompanyAndScoIdQuery(lmsCompany, scoId, excludedLmsCourseMeetingId)
.Take(1);
return(this.Repository.FindOne(defaultQuery).Value != null);
}
//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);
}
}
}
private async Task <List <LmsUserDTO> > FetchUsers(ILmsLicense lmsCompany, int courseId)
{
string token = lmsCompany.AdminUser.Token;
List <LmsUserDTO> users = await _canvasApi.GetUsersForCourse(
lmsCompany.LmsDomain,
token,
courseId);
// IF emails are NOT included (for student + lmsCompany.AdminUser == null)
if (users.Any(x => string.IsNullOrEmpty(x.PrimaryEmail)))
{
// TODO: details about ampty email users
Logger.ErrorFormat("[Canvas GetUsers] API did not return emails. CourseID={0}. LMSCompanyID:{1}.", courseId, lmsCompany.Id);
}
return(users);
}
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());
}
private Principal GetPrincipal(ILmsLicense lmsCompany, LtiParamDTO param, string scoId,
IAdobeConnectProxy provider, out string breezeToken)
{
breezeToken = string.Empty;
var lmsUser = LmsUserModel.GetOneByUserIdAndCompanyLms(param.lms_user_id, lmsCompany.Id).Value;
if (lmsUser == null)
{
throw new WarningMessageException(string.Format("No user with id {0} found in the database.",
param.lms_user_id));
}
var loginResult = MeetingSetup.ACLogin(lmsCompany, param, lmsUser, provider);
breezeToken = loginResult.BreezeSession;
return(loginResult.User);
}
//todo: move to companyLms/settings service?
public static KeyValuePair <string, string> GetApiKeys(ILmsLicense lmsCompany, string globalAppId, string globalAppKey)
{
string appId = null;
string appKey = null;
var isSandbox = lmsCompany.GetSetting <bool>(LmsLicenseSettingNames.IsOAuthSandbox);
if (isSandbox)
{
appId = lmsCompany.GetSetting <string>(LmsLicenseSettingNames.OAuthAppId);
appKey = lmsCompany.GetSetting <string>(LmsLicenseSettingNames.OAuthAppKey);
}
else
{
appId = globalAppId;
appKey = globalAppKey;
}
return(new KeyValuePair <string, string>(appId, appKey));
}
public IMeetingSessionService GetMeetingSessionService(ILmsLicense lmsLicense, ILtiParam param)
{
var lmsCourseMeetingModel = IoC.Resolve <LmsCourseMeetingModel>();
var logger = IoC.Resolve <ILogger>();
ICalendarExportService calendarExportService = null;
var lmsId = (LmsProviderEnum)lmsLicense.LmsProviderId;
switch (lmsId)
{
// case LmsProviderEnum.Sakai:
case LmsProviderEnum.Bridge:
var container = IoC.Resolve <IWindsorContainer>(); //bad hack - until parameterized methods are added to IoC and IServiceLocator
calendarExportService = IoC.Resolve <ICalendarExportService>(lmsId + "CalendarExportService");
return(container.Resolve <IMeetingSessionService>(lmsId + "SessionsService",
new { license = lmsLicense, param, calendarExportService }));
}
return(new MeetingSessionService(lmsCourseMeetingModel, logger, calendarExportService, lmsLicense, GetCalendarEventService(lmsId, lmsLicense)));
}
public void DeleteProfile(ILmsLicense lmsCompany, TelephonyProfileInfoResult profile)
{
if (lmsCompany == null)
{
throw new ArgumentNullException(nameof(lmsCompany));
}
if (profile == null)
{
throw new ArgumentNullException(nameof(profile));
}
string roomNumber = profile.TelephonyProfileFields.First(x => x.Key == "x-tel-meetingone-conference-id").Value;
if (string.IsNullOrWhiteSpace(roomNumber))
{
throw new InvalidOperationException("Can't find meeting-one room number");
}
var access = new AccessDetails
{
UserName = lmsCompany.GetSetting <string>(LmsLicenseSettingNames.Telephony.MeetingOne.UserName),
SecretHashKey = lmsCompany.GetSetting <string>(LmsLicenseSettingNames.Telephony.MeetingOne.SecretHashKey),
OwningAccountNumber = lmsCompany.GetSetting <string>(LmsLicenseSettingNames.Telephony.MeetingOne.OwningAccountNumber),
};
bool deleted = false;
try
{
var client = new MeetingOneClient(_baseAddress, _logger);
deleted = client.DeleteRoom(access, roomNumber);
}
catch (Exception ex)
{
_logger.Error($"MeetingOneClient.DeleteRoom failed. RoomNumber:'{roomNumber}'. LmsCompanyId:{lmsCompany.Id}", ex);
}
if (!deleted)
{
throw new InvalidOperationException("MeetingONE API hasn't deleted room.");
}
}
public int CourseCountByCompanyAndScoId(ILmsLicense lmsCompany, string scoId, int excludedLmsCourseMeetingId)
{
if (lmsCompany == null)
{
throw new ArgumentNullException(nameof(lmsCompany));
}
if (string.IsNullOrWhiteSpace(scoId))
{
throw new ArgumentException("scoId can not be empty", nameof(scoId));
}
var defaultQuery = GetByCompanyAndScoIdQuery(lmsCompany, scoId, excludedLmsCourseMeetingId);
var rowCountQuery = defaultQuery
.Select(Projections.Distinct(Projections.Property <LmsCourseMeeting>(s => s.CourseId)))
.TransformUsing(Transformers.DistinctRootEntity)
.ToRowCountQuery();
return(this.Repository.FindOne <int>(rowCountQuery).Value);
}
public string UpdateRecording(ILmsLicense lmsCompany, IAdobeConnectProxy provider, string id, bool isPublic, string password)
{
var recording = provider.GetScoInfo(id).ScoInfo;
if (recording == null)
{
return(string.Empty);
}
if (!IsValidPassCode(password))
{
throw new Core.WarningMessageException("Your passcode must be 4 to 12 characters long (letters or numbers)");
}
provider.UpdatePublicAccessPermissions(id, isPublic ? PermissionId.view : PermissionId.view_denied);
provider.UpdateAclFieldWithPasscode(id, AclFieldId.meeting_passcode, password, !string.IsNullOrEmpty(password));
var recordingUrl = (lmsCompany.AcServer.EndsWith("/")
? lmsCompany.AcServer.Substring(0, lmsCompany.AcServer.Length - 1)
: lmsCompany.AcServer) + recording.UrlPath;
return(recordingUrl);
}
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);
}
}
