/// <summary>
/// The login if necessary.
/// </summary>
/// <typeparam name="T">
/// Any type
/// </typeparam>
/// <param name="client">
/// The client.
/// </param>
/// <param name="action">
/// The action.
/// </param>
/// <param name="lmsCompany">
/// The company LMS.
/// </param>
/// <param name="error">
/// The error.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
// ReSharper disable once UnusedMember.Local
public T LoginIfNecessary <T>(ref WebserviceWrapper client, Func <WebserviceWrapper, T> action, Dictionary <string, object> licenseSettings, out string error)
{
error = null;
client = client ?? BeginBatch(out error, licenseSettings);
if (client != null)
{
return(action(client));
}
return(default(T));
}
public override async Task <OperationResultWithData <List <LmsUserDTO> > > GetUsers(Dictionary <string, object> licenseSettings, string courseId, ILtiParam param = null)
{
if (licenseSettings == null)
{
throw new ArgumentNullException(nameof(licenseSettings));
}
string error = null;
string[] userIds = null;
WebserviceWrapper client = null;
List <LmsUserDTO> users = _soapApi.GetUsersForCourse(
licenseSettings,
courseId,
userIds,
out error,
ref client);
if ((users.Count == 0) &&
error.Return(
x => x.IndexOf("ACCESS DENIED", StringComparison.InvariantCultureIgnoreCase) >= 0,
false))
{
Logger.Warn("GetBlackBoardUsers.AccessDenied. " + error);
if (client != null)
{
client.logout();
}
// NOTE: set to null to re-create session.
client = null;
users = _soapApi.GetUsersForCourse(
licenseSettings,
courseId,
userIds,
out error,
ref client);
}
// NOTE: always call logout
if (client != null)
{
client.logout();
}
return(!string.IsNullOrEmpty(error)
? OperationResultWithData <List <LmsUserDTO> > .Error(error)
: users.ToSuccessResult());
}
/// <summary>
/// The initialize client.
/// </summary>
/// <param name="lmsDomain">
/// The LMS domain.
/// </param>
/// <param name="client">
/// The client.
/// </param>
/// <param name="error">
/// The error.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
private bool InitializeClient(string lmsDomain, out WebserviceWrapper client, out string error)
{
client = new WebserviceWrapper(
lmsDomain,
VendorEgc,
ProgramLti,
TimeSpan.FromMinutes(1).Seconds,
new CastleLoggerAdapter(_logger));
if (HadError(client, out error))
{
return(false);
}
client.initialize_v1();
return(!HadError(client, out error));
}
private static bool HadError(WebserviceWrapper ws, out string error)
{
error = null;
if (ws == null)
{
error = "NULL webservicewrapper";
return(true);
}
string lastError = ws.getLastError();
if (lastError != null)
{
error = lastError;
return(true);
}
return(false);
}
private T LoginIfNecessary <T>(ref WebserviceWrapper client, Func <WebserviceWrapper, Tuple <T, string> > action, Dictionary <string, object> licenseSettings, out string error)
{
error = null;
client = client ?? BeginBatch(out error, licenseSettings);
if (client != null)
{
var result = action(client);
error = result.Item2;
if (!string.IsNullOrWhiteSpace(error))
{
throw new InvalidOperationException("BlackBoard.LoginIfNecessary. Error: " + error);
}
return(result.Item1);
}
return(default(T));
}
public async Task SendAnswersAsync(Dictionary <string, object> licenseSettings, string contentId, bool isSurvey, string[] answers)
{
WebserviceWrapper client = null;
string contentId1 = contentId;
var tests = this.LoginIfNecessary(
ref client,
c =>
{
var egc = c.getEdugameCloudWrapper();
return(egc.submitTestResult(
contentId1,
(string)licenseSettings[LmsUserSettingNames.Token],
answers,
null,
isSurvey));
},
licenseSettings,
out contentId);
}
static public String[,] getData(String host, String vendor, String program, String secret, String username, string userpass, String logintype, String courseuser)
{
// If not logged in already...
if (!loggedIn)
{
// Initialize and configure web service wrapper
ws = new WebserviceWrapper(host, vendor, program, EXPECTED_LIFE);
// Context.WS initialize to establish session and get session Id
ws.initialize_v1();
if (logintype.Equals("tool"))
{
// Login as proxy Tool
loggedIn = ws.loginTool(secret);
}
else
{
// Login as user
loggedIn = ws.loginUser(username, userpass);
}
if (!loggedIn)
{
Console.WriteLine("Login " + logintype + " failed: " + ws.getLastError());
return(null);
}
}
//Initialize the web service wrappers necessary for this sample
initWrappers();
// Get a list of courses for this user
String[,] courseList = getCourseList(courseuser);
// Return the courseList to the form for processing
return(courseList);
}
public List <LmsUserDTO> GetUsersForCourse(
Dictionary <string, object> licenseSettings,
string courseId,
string[] userIds,
out string error,
ref WebserviceWrapper client)
{
var courseIdFixed = string.Format("_{0}_1", courseId);
var enrollmentsResult = LoginIfNecessary(
ref client,
c =>
{
string errorDuringEnrollments = null;
var resultedList = new List <LmsUserDTO>();
// NOTE: check http://library.blackboard.com/ref/fd8c40a0-f670-4c48-9e02-c5d84e61eda7/blackboard/ws/coursemembership/CourseMembershipWS.html
// for filterType
//var membershipFilter = new MembershipFilter
//{
// filterType = (userIds == null) ? 2 : 6,
// filterTypeSpecified = true,
// courseIds = new[] { courseIdFixed },
// userIds = userIds,
//};
var membershipFilter = new MembershipFilter
{
filterType = 2,
filterTypeSpecified = true,
courseIds = new[] { courseIdFixed },
};
CourseMembershipWrapper membership = c.getCourseMembershipWrapper();
if (membership != null)
{
CourseMembershipVO[] enrollments = membership.loadCourseMembership(courseIdFixed, membershipFilter);
if (HadError(c, out errorDuringEnrollments))
{
return(new Tuple <List <LmsUserDTO>, string>(resultedList, errorDuringEnrollments));
}
if (enrollments != null)
{
var activeEnrollments = enrollments.Where(x => x.available.HasValue && x.available.Value);
CourseMembershipRoleVO[] roles = membership.loadRoles(null);
var userFilter = new UserFilter
{
filterTypeSpecified = true,
filterType = 2,
id = activeEnrollments.Select(x => x.userId).ToArray(),
};
UserWrapper userService = c.getUserWrapper();
if (userService != null)
{
UserVO[] users = userService.getUser(userFilter);
if (users == null)
{
HadError(c, out errorDuringEnrollments);
return(new Tuple <List <LmsUserDTO>, string>(resultedList, errorDuringEnrollments));
}
resultedList = activeEnrollments.Select(
e =>
{
var user = users.FirstOrDefault(u => e.userId == u.id);
var ltiIdString = user != null && user.expansionData != null
? user.expansionData.FirstOrDefault(ed => ed.StartsWith("USER.UUID", StringComparison.OrdinalIgnoreCase))
: null;
if (ltiIdString != null)
{
ltiIdString = ltiIdString.Substring(ltiIdString.IndexOf('=') + 1);
}
return(new LmsUserDTO
{
Id = e.userId,
Login = user.With(x => x.name),
Email = user.With(x => x.extendedInfo).With(x => x.emailAddress),
Name = user.With(x => x.extendedInfo).Return(x => string.Format("{0} {1}", x.givenName, x.familyName).Trim(), user.With(s => s.name)),
LmsRole = GetRole(e.roleId, roles),
LtiId = ltiIdString,
});
}).ToList();
}
}
}
return(new Tuple <List <LmsUserDTO>, string>(resultedList, errorDuringEnrollments));
},
licenseSettings,
out error);
if (enrollmentsResult == null)
{
error = error ?? "SOAP. Unable to retrive result from API";
return(new List <LmsUserDTO>());
}
return(enrollmentsResult);
}
public async Task <OperationResultWithData <IEnumerable <LmsQuizDTO> > > GetItemsForUserAsync(Dictionary <string, object> licenseSettings, bool isSurvey, IEnumerable <int> quizIds)
{
WebserviceWrapper client = null;
string error;
var tests = this.LoginIfNecessary(
ref client,
c =>
{
var egc = c.getEdugameCloudWrapper();
var content = c.getContentWrapper();
var tos = content.getTOCsByCourseId((string)licenseSettings[LmsUserSettingNames.CourseId]);
if (tos != null)
{
tos =
tos.Where(
to =>
to.label != null &&
to.label.Equals("content", StringComparison.InvariantCultureIgnoreCase))
.ToArray();
}
ContentVO[] tsts = null;
if (tos != null && tos.Any())
{
var contentFilter = new ContentFilter()
{
filterType = 3,
filterTypeSpecified = true,
contentId = tos.First().courseContentsId
};
var loaded = content.loadFilteredContent((string)licenseSettings[LmsUserSettingNames.CourseId], contentFilter);
if (loaded != null)
{
tsts =
loaded.Where(
l =>
l.contentHandler != null &&
l.contentHandler.Equals(isSurvey ? "resource/x-bb-asmt-survey-link" : "resource/x-bb-asmt-test-link")).ToArray();
}
}
string testData = string.Empty;
if (tsts != null)
{
var quizDTO = new List <LmsQuizDTO>();
foreach (var t in tsts)
{
var lqd = new LmsQuizDTO()
{
course = (string)licenseSettings[LmsUserSettingNames.CourseId],
courseName = (string)licenseSettings[LmsUserSettingNames.CourseId],
description = t.body.ClearName(),
title = t.title.ClearName(),
id = BlackboardHelper.GetBBId(t.id),
published = true
};
if (quizIds != null && !quizIds.Contains(lqd.id))
{
continue;
}
testData = egc.getAssessmentDetails(t.id, isSurvey);
if (testData != null && !testData.StartsWith("Error", StringComparison.InvariantCultureIgnoreCase))
{
var td = JsonConvert.DeserializeObject <BBAssessmentDTO>(testData);
lqd.question_list = BlackboardQuizParser.ParseQuestions(td, testData);
var repoImages = td.images as JToken;
if (repoImages != null)
{
var temp = repoImages.ToObject <Dictionary <string, string> >();
lqd.Images = temp.ToDictionary(x => x.Key, x => x.Value);
}
}
quizDTO.Add(lqd);
}
return(quizDTO.ToList());
}
return(new List <LmsQuizDTO> {
});
},
licenseSettings,
out error);
return(string.IsNullOrEmpty(error)
? ((IEnumerable <LmsQuizDTO>)tests).ToSuccessResult()
: OperationResultWithData <IEnumerable <LmsQuizDTO> > .Error(error));
}
static public Boolean registerTool(String host, String vendor, String program, String secret, String regpass)
{
// Configure and initialize Web Service Wrapper
ws = new WebserviceWrapper(host, vendor, program, EXPECTED_LIFE);
// Initialize the web service session. Under the covers, this takes care of Context.initialize()
ws.initialize_v1();
// Create a string array of requested entitlements. This is overkill for this sample.
string [] tools = new string [] { "Announcement.WS:createCourseAnnouncements",
"Announcement.WS:createOrgAnnouncements",
"Announcement.WS:createSystemAnnouncements",
"Announcement.WS:deleteCourseAnnouncements",
"Announcement.WS:deleteOrgAnnouncements",
"Announcement.WS:deleteSystemAnnouncements",
"Announcement.WS:getCourseAnnouncements",
"Announcement.WS:getOrgAnnouncements",
"Announcement.WS:getSystemAnnouncements",
"Announcement.WS:updateCourseAnnouncements",
"Announcement.WS:updateOrgAnnouncements",
"Announcement.WS:updateSystemAnnouncements",
"Calendar.WS:canUpdateCourseCalendarItem",
"Calendar.WS:canUpdateInstitutionCalendarItem",
"Calendar.WS:canUpdatePersonalCalendarItem",
"Calendar.WS:createCourseCalendarItem",
"Calendar.WS:createInstitutionCalendarItem",
"Calendar.WS:createPersonalCalendarItem",
"Calendar.WS:deleteCourseCalendarItem",
"Calendar.WS:deleteInstitutionCalendarItem",
"Calendar.WS:deletePersonalCalendarItem",
"Calendar.WS:getCalendarItem",
"Calendar.WS:saveCourseCalendarItem",
"Calendar.WS:saveInstitutionCalendarItem",
"Calendar.WS:savePersonalCalendarItem",
"Calendar.WS:updateCourseCalendarItem",
"Calendar.WS:updateInstitutionCalendarItem",
"Calendar.WS:updatePersonalCalendarItem",
"Content.WS:addContentFile",
"Content.WS:deleteContentFiles",
"Content.WS:deleteContents",
"Content.WS:deleteCourseTOCs",
"Content.WS:deleteLinks",
"Content.WS:getContentFiles",
"Content.WS:getFilteredContent",
"Content.WS:getFilteredCourseStatus",
"Content.WS:getLinksByReferredToType",
"Content.WS:getLinksByReferrerType",
"Content.WS:getReviewStatusByCourseId",
"Content.WS:getTOCsByCourseId",
"Content.WS:loadContent",
"Content.WS:removeContent",
"Content.WS:saveContent",
"Content.WS:saveContentsReviewed",
"Content.WS:saveCourseTOC",
"Content.WS:saveLink",
"Context.WS:emulateUser",
"Context.WS:getMemberships",
"Context.WS:getMyMemberships",
"Course.WS:changeCourseBatchUid",
"Course.WS:changeCourseCategoryBatchUid",
"Course.WS:changeCourseDataSourceId",
"Course.WS:changeOrgBatchUid",
"Course.WS:changeOrgCategoryBatchUid",
"Course.WS:changeOrgDataSourceId",
"Course.WS:createCourse",
"Course.WS:createOrg",
"Course.WS:deleteCartridge",
"Course.WS:deleteCourse",
"Course.WS:deleteCourseCategory",
"Course.WS:deleteCourseCategoryMembership",
"Course.WS:deleteGroup",
"Course.WS:deleteOrg",
"Course.WS:deleteOrgCategory",
"Course.WS:deleteOrgCategoryMembership",
"Course.WS:deleteStaffInfo",
"Course.WS:getAvailableGroupTools",
"Course.WS:getCartridge",
"Course.WS:getCategories",
"Course.WS:getCategoryMembership",
"Course.WS:getClassifications",
"Course.WS:getCourse",
"Course.WS:getGroup",
"Course.WS:getOrg",
"Course.WS:getStaffInfo",
"Course.WS:saveCartridge",
"Course.WS:saveCourse",
"Course.WS:saveCourseCategory",
"Course.WS:saveCourseCategoryMembership",
"Course.WS:saveGroup",
"Course.WS:saveOrgCategory",
"Course.WS:saveOrgCategoryMembership",
"Course.WS:saveStaffInfo",
"Course.WS:updateCourse",
"Course.WS:updateOrg",
"Course.WS:loadCoursesInTerm",
"Course.WS:addCourseToTerm",
"Course.WS:removeCourseFromTerm",
"Course.WS:loadTerm",
"Course.WS:loadTermByCourseId",
"Course.WS:saveTerm",
"Course.WS:removeTerm",
"Course.WS:loadTerms",
"Course.WS:loadTermsByName",
"CourseMembership.WS:deleteCourseMembership",
"CourseMembership.WS:deleteGroupMembership",
"CourseMembership.WS:getCourseMembership",
"CourseMembership.WS:getCourseRoles",
"CourseMembership.WS:getGroupMembership",
"CourseMembership.WS:saveCourseMembership",
"CourseMembership.WS:saveGroupMembership",
"Gradebook.WS:deleteAttempts",
"Gradebook.WS:deleteColumns",
"Gradebook.WS:deleteGradebookTypes",
"Gradebook.WS:deleteGrades",
"Gradebook.WS:deleteGradingSchemas",
"Gradebook.WS:getAttempts",
"Gradebook.WS:getGradebookColumns",
"Gradebook.WS:getGradebookTypes",
"Gradebook.WS:getGrades",
"Gradebook.WS:getGradingSchemas",
"Gradebook.WS:saveAttempts",
"Gradebook.WS:saveColumns",
"Gradebook.WS:saveGradebookTypes",
"Gradebook.WS:saveGrades",
"Gradebook.WS:saveGradingSchemas",
"Gradebook.WS:updateColumnAttribute",
"User.WS:changeUserBatchUid",
"User.WS:changeUserDataSourceId",
"User.WS:deleteAddressBookEntry",
"User.WS:deleteObserverAssociation",
"User.WS:deleteUser",
"User.WS:deleteUserByInstitutionRole",
"User.WS:getAddressBookEntry",
"User.WS:getInstitutionRoles",
"User.WS:getObservee",
"User.WS:getSystemRoles",
"User.WS:getUser",
"User.WS:getUserInstitutionRoles",
"User.WS:saveAddressBookEntry",
"User.WS:saveObserverAssociation",
"User.WS:saveUser",
"Util.WS:checkEntitlement",
"Util.WS:deleteSetting",
"Util.WS:getDataSources",
"Util.WS:loadSetting",
"Util.WS:saveSetting" };
// Create empty tickets array.
string [] tickets = null;
// Register the proxy tool.
RegisterToolResultVO result = ws.registerTool("Blackboard Developer Experience C-Sharp Sample Tool", regpass, secret, tools, tickets);
// If registration is successful
if (result.status)
{
Console.WriteLine("Success - tool registered");
string proxyToolGuid = result.proxyToolGuid;
if (proxyToolGuid != null && proxyToolGuid.Length > 0)
{
Console.WriteLine("Proxy Tool GUID: " + proxyToolGuid);
}
return(true);
}
else
{
Console.WriteLine("Failed - tool not registered (to re-register you must clear the password on the server):");
for (int i = 0; i < result.failureErrors.Length; i++)
{
Console.WriteLine(result.failureErrors[i]);
}
Console.WriteLine(ws.getLastError());
return(false);
}
}
