private async Task <LmsUserDTO> FetchCourseUser(string userId, string domain, string userToken, int courseId)
{
try
{
Validate(domain, userToken);
var client = CreateRestClient(domain);
var link = string.Format("/api/v1/courses/{0}/users/{1}?include[]=email&include[]=enrollments",
courseId, userId);
RestRequest request = CreateRequest(domain, link, Method.GET, userToken);
IRestResponse <CanvasLmsUserDTO> response = await client.ExecuteTaskAsync <CanvasLmsUserDTO>(request);
if (response.StatusCode == HttpStatusCode.NotFound)
{
// NOTE: user not longer exists in Canvas - return null;
return(null);
}
if (response.StatusCode != HttpStatusCode.OK)
{
_logger.ErrorFormat("[EGCEnabledCanvasAPI.FetchCourseUser] API:{0}. UserToken:{1}. CourseId:{2}. UserId:{3}. {4}",
domain, userToken, courseId, userId, BuildInformation(response));
throw new InvalidOperationException(string.Format("[EGCEnabledCanvasAPI.FetchCourseUser] Canvas returns '{0}'", response.StatusDescription));
}
var user = response.Data;
if (user == null)
{
return(null);
}
if (!user.enrollments.Any(x => x.course_id == courseId && x.enrollment_state == CanvasEnrollment.EnrollmentState.Active))
{
return(null);
}
var result = new LmsUserDTO
{
Id = user.Id,
Email = user.Email,
Login = user.login_id,
Name = user.Name,
PrimaryEmail = user.Email,
LmsRole = SetRole(user, courseId)
};
return(result);
}
catch (Exception ex)
{
_logger.ErrorFormat(ex, "[EGCEnabledCanvasAPI.FetchCourseUser] API:{0}. UserToken:{1}. CourseId:{2}. UserId:{3}.", domain, userToken, courseId, userId);
throw;
}
}
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 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 static LmsUserDTO ParseUser(XElement node)
{
var user = node.Element("user");
var info = new LmsUserDTO()
{
Id = node.Attribute("user_id").Value,
LmsRole = node.Attribute("role").Value == "S" ? "Student" : "Teacher",
Login = user.Attribute("login").Value,
Email = user.Attribute("email")?.Value ?? user.Attribute("unconfirmed_email")?.Value,
Name = user.Attribute("first_name").Value + " " + user.Attribute("last_name").Value,
SectionIds = node.Elements("section").Select(s => s.Attribute("id").Value).ToList()
};
return(info);
}
public virtual OperationResultWithData <LmsUserDTO> AddNewUser([FromBody] AddUserDto request)
{
try
{
// TODO: use FeatureName but this settings has true as default value
if (!LmsCompany.GetSetting <bool>(LmsLicenseSettingNames.EnableAddGuest, true))
{
return(OperationResultWithData <LmsUserDTO> .Error("Operation is not enabled."));
}
var provider = GetAdminProvider();
Principal principal;
try
{
if (string.IsNullOrWhiteSpace(request.PrincipalId))
{
principal = CreatePrincipal(request, LmsCompany, provider);
}
else
{
principal = provider.GetOneByPrincipalId(request.PrincipalId).PrincipalInfo.Principal;
}
}
catch (WarningMessageException ex)
{
return(OperationResultWithData <LmsUserDTO> .Error(ex.Message));
}
// HACK: LmsMeetingType.Meeting param - not in use here
LmsCourseMeeting meeting = MeetingSetup.GetCourseMeeting(LmsCompany, CourseId, request.MeetingId, LmsMeetingType.Meeting);
// TODO: review for user-sync mode
MeetingPermissionCollectionResult meetingEnrollments = provider.GetAllMeetingEnrollments(meeting.GetMeetingScoId());
if (meetingEnrollments.Status.Code != StatusCodes.ok)
{
string errorMessage = GetOutputErrorMessage(
string.Format("AcUserController.AddNewUser.GetAllMeetingEnrollments. Status.Code: {0}, Status.SubCode: {1}.",
meetingEnrollments.Status.Code,
meetingEnrollments.Status.SubCode));
return(OperationResultWithData <LmsUserDTO> .Error(errorMessage));
}
if (meetingEnrollments.Values.Any(x => x.PrincipalId == principal.PrincipalId))
{
return(OperationResultWithData <LmsUserDTO> .Error(Messages.UserIsAlreadyParticipant));
}
AcRole role = AcRole.GetById(request.MeetingRole);
StatusInfo status = provider.UpdateScoPermissionForPrincipal(meeting.GetMeetingScoId(), principal.PrincipalId, role.MeetingPermissionId);
// Add user as guest to DB
var guest = new LmsCourseMeetingGuest
{
PrincipalId = principal.PrincipalId,
LmsCourseMeeting = meeting,
};
meeting.MeetingGuests.Add(guest);
this.LmsCourseMeetingModel.RegisterSave(meeting, flush: true);
var result = new LmsUserDTO
{
GuestId = guest.Id,
AcId = guest.PrincipalId,
Name = principal.Name,
AcRole = request.MeetingRole,
};
return(result.ToSuccessResult());
}
catch (Exception ex)
{
string errorMessage = GetOutputErrorMessage("AcUserController.AddNewUser", ex);
return(OperationResultWithData <LmsUserDTO> .Error(errorMessage));
}
}
public async Task <(string url, string breezeSession)> JoinRecording(ILmsLicense lmsCompany, LtiParamDTO param, string recordingUrl,
IAdobeConnectProxy provider, string mode = null)
{
LmsUserDTO lmsUserDto = null;
var acRecordingScoResult = provider.GetScoByUrl(recordingUrl);
if (!acRecordingScoResult.Success)
{
logger.Error(string.Format("[AdobeConnectProxy Error] {0}. Recording url:{1}", acRecordingScoResult.Status.GetErrorInfo(), recordingUrl));
throw new AdobeConnectException(acRecordingScoResult.Status);
}
var lmsUser = lmsUserModel.GetOneByUserIdAndCompanyLms(param.lms_user_id, lmsCompany.Id).Value;
if (lmsUser == null)
{
throw new Core.WarningMessageException(string.Format("No user with id {0} found in the database.",
param.lms_user_id));
}
var courseMeetings = this.lmsCourseMeetingModel.GetByCompanyAndScoId(lmsCompany, acRecordingScoResult.ScoInfo.FolderId, 0);
// for AC provisioning courseMeeting.scoId() is used, so here we can take only first record if Dynamic provisioning is enabled for at least one meeting
// if sync is enabled then all meetings with the same scoId should have the same users roster and the same value of EnableDynamicProvisioning property
var courseMeeting = courseMeetings.FirstOrDefault(x => x.EnableDynamicProvisioning);
if (courseMeeting != null &&
(LmsMeetingType)courseMeeting.LmsMeetingType != LmsMeetingType.StudyGroup &&
lmsCompany.UseSynchronizedUsers)
{
var lmsUserDtoRes = await usersSetup.GetOrCreateUserWithAcRole(lmsCompany, provider, param, courseMeeting, param.lms_user_id);
lmsUserDto = lmsUserDtoRes.Data;
if (!lmsUserDtoRes.IsSuccess)
{
throw new Core.WarningMessageException(
string.Format(
"[Dynamic provisioning] Could not create user, id={0}. Message: {1}",
param.lms_user_id, lmsUserDtoRes.Message));
}
meetingSetup.ProcessDynamicProvisioning(provider, lmsCompany, courseMeeting, lmsUser, lmsUserDto);
}
var loginResult = meetingSetup.ACLogin(lmsCompany, param, lmsUser, provider);
string breezeToken = loginResult.BreezeSession;
meetingSetup.ProcessGuestAuditUsers(provider, lmsCompany, acRecordingScoResult.ScoInfo.FolderId,
loginResult.User.PrincipalId, param, () => courseMeetings);
var baseUrl = lmsCompany.AcServer + "/" + recordingUrl;
var breezeSession = breezeToken ?? string.Empty;
var url = string.Format(
"{0}?{1}{2}{3}",
baseUrl,
mode != null ? string.Format("pbMode={0}", mode) : string.Empty,
mode != null && !lmsCompany.LoginUsingCookie.GetValueOrDefault() ? "&" : string.Empty,
!lmsCompany.LoginUsingCookie.GetValueOrDefault() && breezeToken != null
? "session=" + breezeToken
: string.Empty);
return(url, breezeSession);
}
public override async Task <OperationResultWithData <List <LmsUserDTO> > > GetUsers(Dictionary <string, object> licenseSettings,
string courseId, ILtiUserListParam param = null)
{
if (licenseSettings == null)
{
throw new ArgumentNullException(nameof(licenseSettings));
}
if (string.IsNullOrEmpty((string)licenseSettings[LmsUserSettingNames.Token]))
{
Logger.WarnFormat("[GetD2LUsers]: Admin Token does not exist for LmsCompany key: {1}.", licenseSettings[LmsLicenseSettingNames.LicenseKey]);
throw new WarningMessageException(Resources.Messages.NoLicenseAdmin);
}
string[] tokens = ((string)licenseSettings[LmsUserSettingNames.Token]).Split(' ');
// get course users list
var classlistEnrollments = d2lApiService.GetApiObjects <List <ClasslistUser> >(
tokens[0],
tokens[1],
(string)licenseSettings[LmsLicenseSettingNames.LmsDomain],
string.Format(
d2lApiService.EnrollmentsClasslistUrlFormat,
(string)this.settings.BrightspaceApiVersion,
courseId),
licenseSettings);
// mapping to LmsUserDTO
var result = new List <LmsUserDTO>();
if (classlistEnrollments != null)
{
// get enrollments - this information contains user roles
var enrollmentsList = new List <OrgUnitUser>();
PagedResultSet <OrgUnitUser> enrollments = null;
do
{
enrollments = d2lApiService.GetApiObjects <PagedResultSet <OrgUnitUser> >(
tokens[0],
tokens[1],
(string)licenseSettings[LmsLicenseSettingNames.LmsDomain],
string.Format(
d2lApiService.EnrollmentsUrlFormat,
(string)this.settings.BrightspaceApiVersion,
courseId)
+ (enrollments != null ? "?bookmark=" + enrollments.PagingInfo.Bookmark : string.Empty),
licenseSettings);
if (enrollments == null || enrollments.Items == null)
{
var error = "Incorrect API call or returned data. Please contact site administrator";
Logger.Error("[D2L Enrollments]: Object returned from API has null value");
return(OperationResultWithData <List <LmsUserDTO> > .Error(error));
}
enrollmentsList.AddRange(enrollments.Items);
} while (enrollments.PagingInfo.HasMoreItems && !string.IsNullOrEmpty(enrollments.PagingInfo.Bookmark));
string currentLmsUserId = param?.lms_user_id;
// current user is not enrolled to this course (user is admin) -> add him to user list
if (AllowAdminAdditionToCourse && classlistEnrollments.All(x => x.Identifier != currentLmsUserId))
{
var currentLmsUser = lmsUserModel.GetOneByUserIdAndCompanyLms(currentLmsUserId, (int)licenseSettings[LmsLicenseSettingNames.LicenseId]).Value;
if ((currentLmsUser != null) && !string.IsNullOrEmpty(currentLmsUser.Token))
{
string[] currentUserTokens = currentLmsUser.Token.Split(' ');
var currentUserInfo = d2lApiService.GetApiObjects <WhoAmIUser>(
currentUserTokens[0],
currentUserTokens[1],
(string)licenseSettings[LmsLicenseSettingNames.LmsDomain],
string.Format(d2lApiService.WhoAmIUrlFormat, (string)this.settings.BrightspaceApiVersion),
licenseSettings);
if (currentUserInfo != null)
{
//
var userInfo = d2lApiService.GetApiObjects <UserData>(tokens[0], tokens[1],
(string)licenseSettings[LmsLicenseSettingNames.LmsDomain],
string.Format(d2lApiService.GetUserUrlFormat, (string)this.settings.BrightspaceApiVersion,
currentUserInfo.Identifier),
licenseSettings);
classlistEnrollments.Add(
new ClasslistUser
{
Identifier = currentUserInfo.Identifier,
Username = currentUserInfo.UniqueName,
DisplayName = currentUserInfo.FirstName + " " + currentUserInfo.LastName,
Email = userInfo.ExternalEmail, // TODO: is it OK??
});
}
}
}
foreach (ClasslistUser enrollment in classlistEnrollments)
{
OrgUnitUser userInfo =
enrollmentsList.FirstOrDefault(e => e.User.Identifier == enrollment.Identifier);
var user = new LmsUserDTO
{
Id = enrollment.Identifier,
Login = enrollment.Username,
Name = enrollment.GetValidFullName(),
Email = enrollment.Email ?? userInfo?.User.EmailAddress,
LmsRole = userInfo != null ? userInfo.Role.Name : "Unknown",
};
result.Add(user);
}
}
return(result.ToSuccessResult());
}
public async Task <OperationResultWithData <IEnumerable <LmsUserDTO> > > UpdateUser([FromBody] CourseUsersDto request)
{
var credentials = LmsCompany;
string lastError = null;
var updatedUsers = new List <LmsUserDTO>();
foreach (var user in request.Users)
{
try
{
LmsUserDTO updatedUser = null;
string error;
if (user.GuestId.HasValue)
{
updatedUser = this.UsersSetup.UpdateGuest(
credentials,
GetAdminProvider(),
Session.LtiSession.LtiParam,
user,
request.MeetingId,
out error);
}
else
{
var updatedUserRes = await UsersSetup.UpdateUser(
credentials,
GetAdminProvider(),
Session.LtiSession.LtiParam,
user,
request.MeetingId);
updatedUser = updatedUserRes.Data;
error = updatedUserRes.Message;
}
if (!string.IsNullOrEmpty(error))
{
Logger.Error($"[UpdateUsers] {error}. UserId={user.Id}, MeetingId={request.MeetingId}");
lastError = error;
}
else
{
// TRICK: if user not found in LMS - return original record from client (remove user from meeting participant list - user doesn't exist in LMS)
updatedUsers.Add(updatedUser ?? user);
}
}
catch (Exception ex)
{
lastError = GetOutputErrorMessage("UpdateUsers", ex);
Logger.Error($"[RemoveUsers] UserId={user.Id}, MeetingId={request.MeetingId}, {lastError}", ex);
}
}
if (string.IsNullOrEmpty(lastError))
{
return(updatedUsers.AsEnumerable().ToSuccessResult());
}
return(new OperationResultWithData <IEnumerable <LmsUserDTO> >
{
Message = Messages.UsersCouldNotBeUpdated,
Data = updatedUsers
});
}
