/// <summary>Creates the child controls.</summary>
protected override void CreateChildControls()
{
try
{
if (Show())
{
SlkMemberships slkMembers = new SlkMemberships();
slkMembers.FindAllSlkMembers(Web, Store, false);
foreach (SlkUser learner in slkMembers.Learners)
{
HyperLink link = new HyperLink();
link.Text = learner.Name;
members[learner.Key] = link;
}
}
}
catch (SafeToDisplayException e)
{
errorOccurred = true;
Literal literal = new Literal();
literal.Text = string.Format(CultureInfo.InvariantCulture, "<p class=\"ms-formvalidation\">{0}</p>", e.Message);
Controls.Add(literal);
}
base.CreateChildControls();
}
public static void RunProgram(string classWebUrl)
{
Stack <IDisposable> disposer = new Stack <IDisposable>();
try
{
// "log in" to SLK as the current user, and set <memberships> to information about
// the instructors and learners in the class Web site (i.e. the SPWeb with URL
// <classWebUrl>)
SPSite spSite = new SPSite(classWebUrl);
disposer.Push(spSite);
SPWeb spWeb = spSite.OpenWeb();
disposer.Push(spWeb);
SlkStore slkStore = SlkStore.GetStore(spWeb);
SlkMemberships memberships = slkStore.GetMemberships(spWeb, null, null);
// make sure there's at least one instructor and one learner on the class Web; these
// roles are defined by the "SLK Instructor" and "SLK Learner" permissions (as defined
// in the SharePoint Learning Kit configuration page in SharePoint Central
// Administration)
if (memberships.Instructors.Count == 0)
{
throw new Exception("Class Web must have at least one instructor");
}
if (memberships.Learners.Count == 0)
{
throw new Exception("Class Web must have at least one learner");
}
// arbitrarily choose the first instructor in the class as the user who will create
// the assignments
SlkUser primaryInstructor = memberships.Instructors[0];
// set <classWeb> to the SPWeb of the SharePoint Web site that the new assignment will
// be associated with; "log into" this Web site as the instructor retrieved above
SPSite classSite = new SPSite(classWebUrl, primaryInstructor.SPUser.UserToken);
disposer.Push(classSite);
SPWeb classWeb = classSite.OpenWeb();
disposer.Push(classWeb);
// set <slkStore> to the SharePoint Learning Kit store associated with the SPSite of
// <classWeb>
slkStore = SlkStore.GetStore(classWeb);
// set <packageLocations> to the SharePointPackageStore-format location strings
// corresponding to each element of <PackageUrls>; "log into" these Web sites as the
// instructor retrieved above
string[] packageLocations = new string[PackageUrls.Length];
for (int packageIndex = 0; packageIndex < packageLocations.Length; packageIndex++)
{
// set <packageWeb> to the SPWeb of the SharePoint Web site containing the package
// or document to assign
string packageUrl = PackageUrls[packageIndex];
SPSite packageSite = new SPSite(packageUrl, primaryInstructor.SPUser.UserToken);
disposer.Push(packageSite);
SPWeb packageWeb = packageSite.OpenWeb();
disposer.Push(packageWeb);
// set <spFile> to the SPFile of the package or document to assign
SPFile spFile = packageWeb.GetFile(packageUrl);
// set the current element of <packageLocation> to the SharePointPackageStore
// format location string that uniquely identifies the current version of the
// <spFile>
packageLocations[packageIndex] = new SharePointFileLocation(
packageWeb, spFile.UniqueId, spFile.UIVersion).ToString();
}
// create a random number generator
s_random = new Random(RandomNumberSeed);
// set <maxNumberOfLearners> to the number of learners in the class
int maxNumberOfLearners = memberships.Learners.Count;
// set <learners> to an array of learners of this class; for each assignment, we'll
// shuffle this array and choose a subset to be learners on the assignment
SlkUser[] learners = new SlkUser[memberships.Learners.Count];
memberships.Learners.CopyTo(learners, 0);
// display table header
Console.WriteLine("Assign. No. of Due Not");
Console.WriteLine("ID Learners Date Started Active Completed Final");
Console.WriteLine("----------------------------------------------------------");
// create assignments as specified by the constants at the top of this source file
for (int assignmentIndex = 0; assignmentIndex < NumberOfAssignments; assignmentIndex++)
{
// set <fraction> to be proportional to <assignmentIndex>, between 0.0 and 1.0
double fraction = (double)assignmentIndex / NumberOfAssignments;
// randomly choose an e-learning package or non-e-learning document to be assigned
string packageLocation = packageLocations[s_random.Next(0, PackageUrls.Length)];
// get some information about the package/document; set <isNonELearning> to true if
// if it's a non-e-learning document; NOTE: this is oversimplified code -- proper
// production code should handle error conditions more carefully
SPFile spFile = SlkUtilities.GetSPFileFromPackageLocation(packageLocation);
bool isNonELearning;
SharePointFileLocation spFileLocation;
SharePointFileLocation.TryParse(packageLocation, out spFileLocation);
using (SharePointPackageReader spPackageReader =
new SharePointPackageReader(slkStore.SharePointCacheSettings, spFileLocation))
{
isNonELearning = PackageValidator.Validate(spPackageReader).HasErrors;
}
// set <assignmentProperties> to the default assignment properties for the package
// or document being assigned; some of these properties will be overridden below
LearningStoreXml packageWarnings;
int?organizationIndex = (isNonELearning ? (int?)null : 0);
AssignmentProperties assignmentProperties =
slkStore.GetNewAssignmentDefaultProperties(
classWeb, packageLocation, organizationIndex, SlkRole.Instructor,
out packageWarnings);
// randomly generate a title for the assignment
assignmentProperties.Title = CreateRandomTitle();
// set the due date of the assignment based on <fraction>,
// <OldestAssignmentDaysAgo>, and <NewestAssignmentDaysFromNow>
assignmentProperties.DueDate = DateTime.Now.AddDays(
(OldestAssignmentDaysAgo + NewestAssignmentDaysFromNow)
* fraction - OldestAssignmentDaysAgo);
// set the start date of the assignment to be a day earlier than the earliest
// due date
assignmentProperties.StartDate = DateTime.Today.AddDays(
-OldestAssignmentDaysAgo - 1);
// randomly set Points Possible
if ((assignmentProperties.PointsPossible == null) &&
(s_random.NextDouble() > FractionOfBlankPointsPossible))
{
const int divideBy = 4;
const int maxValue = 100;
assignmentProperties.PointsPossible = (float)Math.Round(
s_random.NextDouble() * divideBy * maxValue) / maxValue;
}
// make all instructors of this class (i.e. all SharePoint users that have the SLK
// Instructor permission) be instructors on this assignment
assignmentProperties.Instructors.Clear();
foreach (SlkUser slkUser in memberships.Instructors)
{
assignmentProperties.Instructors.Add(slkUser);
}
// shuffle <learners>
for (int learnerIndex = 0; learnerIndex < learners.Length; learnerIndex++)
{
int otherLearnerIndex = s_random.Next(0, learners.Length);
SlkUser temp = learners[learnerIndex];
learners[learnerIndex] = learners[otherLearnerIndex];
learners[otherLearnerIndex] = temp;
}
// randomly choose a number of learners for this assignment
int numberOfLearners = s_random.Next(
Math.Min(maxNumberOfLearners, MinLearnersPerAssignment),
maxNumberOfLearners + 1);
// copy the first <numberOfLearners> learners to <assignmentProperties>
assignmentProperties.Learners.Clear();
for (int learnerIndex = 0; learnerIndex < numberOfLearners; learnerIndex++)
{
assignmentProperties.Learners.Add(learners[learnerIndex]);
}
// create the assignment
AssignmentItemIdentifier assignmentId = slkStore.CreateAssignment(classWeb,
packageLocation, organizationIndex, SlkRole.Instructor, assignmentProperties);
// set <gradingPropertiesList> to information about the learner assignments of the
// new assignment; in particular, we need the learner assignment IDs
AssignmentProperties basicAssignmentProperties;
ReadOnlyCollection <GradingProperties> gradingPropertiesList =
slkStore.GetGradingProperties(assignmentId, out basicAssignmentProperties);
// adjust the status of each learner assignment of this assignment according to
// the rules specified in constants at the top of this source file
int[] newStatusCount = new int[(int)LearnerAssignmentState.Final + 1];
for (int learnerIndex = 0;
learnerIndex < gradingPropertiesList.Count;
learnerIndex++)
{
// set <gradingProperties> to information about this learner assignment
GradingProperties gradingProperties = gradingPropertiesList[learnerIndex];
// set <newStatus> to the new status of the assignment, applying the rules
// specified in constants at the top of this source file
if (fraction > 1 - FractionOfAssignmentsNotStarted)
{
gradingProperties.Status = LearnerAssignmentState.NotStarted;
}
else
if (fraction < FractionOfAssignmentsAllFinal)
{
gradingProperties.Status = LearnerAssignmentState.Final;
}
else
{
gradingProperties.Status = (LearnerAssignmentState)
s_random.Next(0, (int)LearnerAssignmentState.Final + 1);
}
// if we're transitioning learner assignment to Final state, optionally
// assign a final points value
if ((gradingProperties.Status == LearnerAssignmentState.Final) &&
(assignmentProperties.PointsPossible != null))
{
if (s_random.NextDouble() < FractionOfOverriddenFinalPoints)
{
const int divideBy = 4;
gradingProperties.FinalPoints = (float)Math.Round(
s_random.NextDouble() * divideBy *
assignmentProperties.PointsPossible.Value) / divideBy;
}
}
// update statistics
newStatusCount[(int)gradingProperties.Status]++;
}
// save changes to the assignment
string warnings = slkStore.SetGradingProperties(assignmentId,
gradingPropertiesList);
Debug.Assert(warnings == null, warnings);
// display feedback
Console.WriteLine("{0,-8}{1,-10}{2,-10:d}{3,-8}{4,-7}{5,-10}{6,-6}",
assignmentId.GetKey(), assignmentProperties.Learners.Count,
assignmentProperties.DueDate, newStatusCount[0], newStatusCount[1],
newStatusCount[2], newStatusCount[3]);
}
}
finally
{
// dispose of objects used by this method
while (disposer.Count > 0)
{
disposer.Pop().Dispose();
}
}
}
/// <summary>
/// Creates a SharePoint Learning Kit assignment.
/// </summary>
///
/// <param name="packageUrl">The URL of the e-learning package or non-e-learning document
/// to assign. This file must be located within a SharePoint document library.</param>
///
/// <param name="organizationIndex">If <paramref name="packageUrl"/> refers to an e-learning
/// package (e.g. a SCORM .zip file), <paramref name="organizationIndex"/> should be
/// the zero-based index of the organization to assign. (Use 0 to assign the first
/// organization.) If <paramref name="packageUrl"/> is a non-e-learning document,
/// <paramref name="organizationIndex"/> should be <c>null</c>.</param>
///
/// <param name="assignmentWebUrl">The URL of the SharePoint Web site that the new assignment
/// will be associated with.</param>
///
/// <param name="title"></param>
///
/// <param name="instructorLoginName">The SharePoint login name of the instructor of the
/// assignment. If the instructor account is a local machine account, the caller can
/// specify @".\account-name". This user must have read access to the file specified by
/// <paramref name="packageUrl"/>, and must have the "SLK Instructor" permission on the
/// SharePoint Web site specified by <paramref name="assignmentWebUrl"/>.</param>
///
/// <param name="learnerLoginNames">The SharePoint login names of the learners of the
/// assignment. If a learner account is a local machine account, the caller can
/// specify @".\account-name". Learners need not have access to the file specified by
/// <paramref name="packageUrl"/>, but they must have the "SLK Learner" permission on the
/// SharePoint Web site specified by <paramref name="assignmentWebUrl"/>.</param>
///
/// <returns>
/// The <c>AssignmentItemIdentifier</c> of the newly-created SharePoint Learning Kit
/// assignment.
/// </returns>
///
static AssignmentItemIdentifier CreateAssignment(string packageUrl, int?organizationIndex,
string assignmentWebUrl, string title, string instructorLoginName,
params string[] learnerLoginNames)
{
Stack <IDisposable> disposer = new Stack <IDisposable>();
try
{
// set <instructorToken> to the SPUserToken of the instructor
SPUser instructor;
SPUserToken instructorToken;
SPSite anonymousSite = new SPSite(packageUrl);
disposer.Push(anonymousSite);
if (instructorLoginName.StartsWith(@".\"))
{
instructorLoginName = anonymousSite.HostName + instructorLoginName.Substring(1);
}
disposer.Push(anonymousSite.RootWeb);
instructor = anonymousSite.RootWeb.AllUsers[instructorLoginName];
instructorToken = instructor.UserToken;
// set <packageWeb> to the SPWeb of the SharePoint Web site containing the package
// or document to assign
SPSite packageSite = new SPSite(packageUrl, instructorToken);
disposer.Push(packageSite);
SPWeb packageWeb = packageSite.OpenWeb();
disposer.Push(packageWeb);
// set <spFile> to the SPFile of the package or document to assign
SPFile spFile = packageWeb.GetFile(packageUrl);
// set <packageLocation> to the SharePointPackageStore-format location string that
// uniquely identifies the current version of the <spFile>
string packageLocation = new SharePointFileLocation(packageWeb,
spFile.UniqueId, spFile.UIVersion).ToString();
// set <assignmentWeb> to the SPWeb of the SharePoint Web site that the new assignment
// will be associated with
SPSite assignmentSite = new SPSite(assignmentWebUrl, instructorToken);
disposer.Push(assignmentSite);
SPWeb assignmentWeb = assignmentSite.OpenWeb();
disposer.Push(assignmentWeb);
// set <slkStore> to the SharePoint Learning Kit store associated with the SPSite of
// <assignmentWeb>
SlkStore slkStore = SlkStore.GetStore(assignmentWeb);
// set <assignmentProperties> to the default assignment properties for the package or
// document being assigned; some of these properties will be overridden below
LearningStoreXml packageWarnings;
AssignmentProperties assignmentProperties = slkStore.GetNewAssignmentDefaultProperties(
assignmentWeb, packageLocation, organizationIndex, SlkRole.Instructor,
out packageWarnings);
// set the assignment title
assignmentProperties.Title = title;
// set <allLearners> to a dictionary that maps SharePoint user login names to SlkUser
// objects, for all users that have the "SLK Learner" permission on <assignmentWeb>
SlkMemberships memberships = slkStore.GetMemberships(assignmentWeb, null, null);
Dictionary <string, SlkUser> allLearners = new Dictionary <string, SlkUser>(
StringComparer.OrdinalIgnoreCase);
foreach (SlkUser learner in memberships.Learners)
{
allLearners.Add(learner.SPUser.LoginName, learner);
}
// set the learners of the assignment to be <learnerLoginNames>
assignmentProperties.Learners.Clear();
foreach (string rawLearnerLoginName in learnerLoginNames)
{
string learnerLoginName;
if (rawLearnerLoginName.StartsWith(@".\"))
{
learnerLoginName = anonymousSite.HostName + rawLearnerLoginName.Substring(1);
}
else
{
learnerLoginName = rawLearnerLoginName;
}
SlkUser slkUser;
if (allLearners.TryGetValue(learnerLoginName, out slkUser))
{
assignmentProperties.Learners.Add(slkUser);
}
else
{
throw new Exception(String.Format("Not a learner: {0}", learnerLoginName));
}
}
// create the assignment
AssignmentItemIdentifier assignmentId = slkStore.CreateAssignment(assignmentWeb,
packageLocation, organizationIndex, SlkRole.Instructor, assignmentProperties);
// return the ID of the new assignment
return(assignmentId);
}
finally
{
// dispose of objects used by this method
while (disposer.Count > 0)
{
disposer.Pop().Dispose();
}
}
}
/// <summary>
/// For the class requested gets the assignments data from Class Server 4 database
/// and transfers assignments and grading points and teacher comments using SLK API
/// </summary>
/// <param name="classData">class information from Class Server 4 classes config file</param>
/// <param name="logText">returns log of operations performed</param>
/// <param name="learningPackages">information about learning packages available on SLK school site</param>
private void MoveAssignments(CS4Class classData, ref string logText, Hashtable learningPackages)
{
SharePointV3 assignmentSite = new SharePointV3();
string assignmentSiteUrl = assignmentSite.BuildSubSiteUrl(SiteBuilder.Default.SLKSchoolWeb, classData.ClassWeb);
//for the getmemberships operation to succeed the current user has to be an SLK instructor on the web site
//looping through all the class users to see if any of them are instructors
//and trying to open the class web with and instructor's token
SPWeb assignmentWeb = null;
SPWeb assignmentWebUnderCurrentUser = assignmentSite.OpenWeb(assignmentSiteUrl);
SPRoleDefinition instructorsRole = assignmentWebUnderCurrentUser.RoleDefinitions[SiteBuilder.Default.SLKInstructorSharePointRole];
bool foundInstructor = false;
foreach (CS4User user in classData.Users)
{
if ((user.IsTeacher) && (user.Transfer))
{
try
{
SPUser spUser = assignmentWebUnderCurrentUser.SiteUsers[user.UserLoginWithDomain];
SPUserToken token = spUser.UserToken;
SPSite site = new SPSite(assignmentSiteUrl, token);
assignmentWeb = site.OpenWeb();
if (assignmentWeb.AllRolesForCurrentUser.Contains(instructorsRole))
{
foundInstructor = true;
break;
}
}
catch
{
//doing nothing, will try the next instructor
}
}
}
if (!foundInstructor)
{
logText += TextResources.AssignmentsTransferErrorNoClassInstructors + Environment.NewLine;
return;
}
//open the Class SLK store
//note we are using SPWeb opened with an instructor's SPUserToken
Microsoft.SharePointLearningKit.SlkStore slkStore = SlkStore.GetStore(assignmentWeb);
//get all learners and instructors for the class
SlkMemberships memberships = slkStore.GetMemberships(assignmentWeb, null, null);
Dictionary <string, SlkUser> allLearners = new Dictionary <string, SlkUser>(
StringComparer.OrdinalIgnoreCase);
foreach (SlkUser learner in memberships.Learners)
{
allLearners.Add(learner.SPUser.LoginName, learner);
}
Dictionary <string, SlkUser> allInstructors = new Dictionary <string, SlkUser>(
StringComparer.OrdinalIgnoreCase);
foreach (SlkUser instructor in memberships.Instructors)
{
allInstructors.Add(instructor.SPUser.LoginName, instructor);
}
//instructors list will always be the same for all assignments
//because there is no link between assignments and teachers in CS4
SlkUserCollection classInstructors = new SlkUserCollection();
foreach (CS4User user in classData.Users)
{
if ((user.IsTeacher) && (user.Transfer))
{
SlkUser slkUser;
if (allInstructors.TryGetValue(user.UserLoginWithDomain, out slkUser))
{
classInstructors.Add(slkUser);
}
else
{
//instructor not found on slk site, log
logText += String.Format(TextResources.InstructorNotRegisteredWithSLKSite, user.UserLoginWithDomain, assignmentSiteUrl) + Environment.NewLine;
}
}
}
//get assignments for this class from the CS4 data base
CS4Database database = new CS4Database(SiteBuilder.Default.ClassServerDBConnectionString);
DataTable assignmentItems;
DataTable userAssignments;
int numAssignments = database.GetAssignments(classData.ClassId, out assignmentItems, out userAssignments);
//loop through assignments list
for (int assignmentIndex = 0; assignmentIndex < numAssignments; assignmentIndex++)
{
try
{
string packageIdent = (assignmentItems.Rows[assignmentIndex]["PackageIdentifier"] != System.DBNull.Value ? assignmentItems.Rows[assignmentIndex]["PackageIdentifier"].ToString() : String.Empty);
int assignmentId = (assignmentItems.Rows[assignmentIndex]["AssignmentID"] != System.DBNull.Value ? System.Convert.ToInt32(assignmentItems.Rows[assignmentIndex]["AssignmentID"]) : 0);
logText += String.Format(TextResources.TransferringAssignment, assignmentId.ToString()) + Environment.NewLine;
//get assignment's package identifier
string packageLocation = GetPackageLocation(packageIdent, learningPackages);
if (packageLocation.Length == 0)
{
if (packageIdent.Length == 0)
{
//log: not importing assignment as the package cannot be identified
logText += String.Format(TextResources.CantTransferAssignmentUnknownLearningResource, assignmentId) + Environment.NewLine;
}
else
{
//log - assignment cannot be imported as the package is not imported into slk
logText += String.Format(TextResources.CantTransferAssignmentNoLearningResource, assignmentId) + Environment.NewLine;
}
//move on to the next assignment
break;
}
//set assignment properties
AssignmentProperties properties = ReadAssignmentPropertiesFromDataRow(assignmentItems.Rows[assignmentIndex]);
Hashtable gradingPoints = new Hashtable();
Hashtable gradingComments = new Hashtable();
//set instructors list
foreach (SlkUser classInstructor in classInstructors)
{
properties.Instructors.Add(classInstructor);
}
//set learners list
for (int userAssignmentIndex = 0; userAssignmentIndex < userAssignments.Rows.Count; userAssignmentIndex++)
{
DataRow assignmentRow = userAssignments.Rows[userAssignmentIndex];
int userAssignmentTableID = (assignmentRow["AssignmentID"] == System.DBNull.Value) ? 0 : System.Convert.ToInt32(assignmentRow["AssignmentID"]);
int userId = (assignmentRow["StudentID"] == System.DBNull.Value) ? 0 : System.Convert.ToInt32(assignmentRow["StudentID"]);
bool isAssignmentGraded = (assignmentRow["HasTeacherGraded"].ToString().ToLower() == "true" ? true : false);
float points = (assignmentRow["Points"] == System.DBNull.Value) ? 0 : System.Convert.ToSingle(assignmentRow["Points"]);
string instructorComments = assignmentRow["TeacherComments"].ToString();
//to minimize sql queries the UserAssignments table contains all assignments for the class
//so we need to check if this row is for the assignment currently being processed
if (assignmentId == userAssignmentTableID)
{
//find this user in list of users from classes.xml
CS4User user = classData.Users.GetByUserId(userId);
if (user != null)
{
//see if this user is for transfer in classes.xml
if (user.Transfer)
{
//see if this user is a learner member on SLK site
SlkUser slkUser;
if (allLearners.TryGetValue(user.UserLoginWithDomain, out slkUser))
{
properties.Learners.Add(slkUser);
//save grading info for this learner to be used later
if (isAssignmentGraded)
{
gradingPoints.Add(slkUser.UserId, points);
gradingComments.Add(slkUser.UserId, instructorComments);
}
}
else
{
//user not found on slk site, log
logText += String.Format(TextResources.UserNotRegisteredWithSLKSite, user.UserLoginWithDomain, assignmentSiteUrl, assignmentId) + Environment.NewLine;
}
}
else
{
//user assignments will not be transferred as user is marked "not for transfer"
logText += String.Format(TextResources.UserNotForTransfer, user.UserLoginWithDomain) + Environment.NewLine;
}
}
else
{
//user is not found in xml file, log
logText += String.Format(TextResources.UserNotFoundInXMLFile, userId, assignmentSiteUrl, SiteBuilder.Default.ClassStructureXML, assignmentId) + Environment.NewLine;
}
}
//create the assignment
AssignmentItemIdentifier assignmentIdSLK = slkStore.CreateAssignment(assignmentWeb, packageLocation, 0, SlkRole.Instructor, properties);
//transfer the grading results for the assignments
AssignmentProperties basicAssignmentProperties;
ReadOnlyCollection <GradingProperties> gradingPropertiesList =
slkStore.GetGradingProperties(assignmentIdSLK, out basicAssignmentProperties);
for (int learnerIndex = 0; learnerIndex < gradingPropertiesList.Count; learnerIndex++)
{
// set <gradingProperties> to information about this learner assignment
GradingProperties gradingProperties = gradingPropertiesList[learnerIndex];
if (gradingPoints.ContainsKey(gradingProperties.LearnerId))
{
//assignment has been graded, transfer grade and comment to SLK
gradingProperties.Status = LearnerAssignmentState.Final;
gradingProperties.FinalPoints = (float)gradingPoints[gradingProperties.LearnerId];
gradingProperties.InstructorComments = gradingComments[gradingProperties.LearnerId].ToString();
}
}
//this call will not save the grade, but it will set the correct state and
//put the teacher's comment.
logText += slkStore.SetGradingProperties(assignmentIdSLK, gradingPropertiesList) + Environment.NewLine;
//calling the second time to save grades
for (int learnerIndex = 0; learnerIndex < gradingPropertiesList.Count; learnerIndex++)
{
gradingPropertiesList[learnerIndex].Status = null;
}
logText += slkStore.SetGradingProperties(assignmentIdSLK, gradingPropertiesList) + Environment.NewLine;
logText += String.Format(TextResources.TransferredAssignment, assignmentId.ToString(), assignmentIdSLK.GetKey().ToString()) + Environment.NewLine;
}
}
catch (System.Exception ex)
{
//exception when transferring an assignment
logText += TextResources.AnError + ex.Message + Environment.NewLine;
}
}
}
