/// <summary>
/// Converts assignment properties from Class Server 4 database format into
/// AssignmentProperties SLK format
/// </summary>
/// <param name="propertiesRow">datarow from Class Servr 4 database</param>
/// <returns>converted assignment properties</returns>
private AssignmentProperties ReadAssignmentPropertiesFromDataRow(DataRow propertiesRow)
{
AssignmentProperties properties = new AssignmentProperties();
properties.Title = propertiesRow["Title"].ToString();
properties.Description = propertiesRow["StudentInstructions"].ToString();
float maxPoints;
if (float.TryParse(propertiesRow["MaxPoints"].ToString(), out maxPoints))
{
properties.PointsPossible = maxPoints;
}
if (!propertiesRow.IsNull("StartDate"))
{
properties.StartDate = (DateTime)propertiesRow["StartDate"];
}
if (!propertiesRow.IsNull("DueDate"))
{
properties.DueDate = (DateTime)propertiesRow["DueDate"];
}
properties.AutoReturn = (propertiesRow["IsAutoReturned"].ToString() == "1" ? true : false);
properties.ShowAnswersToLearners = (propertiesRow["ShowCorrectAnswersToStudents"].ToString() == "1" ? true : false);
return(properties);
}
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>
/// This function uploads the instructor commented files
/// to the corresponding student folder on the dropbox list.
/// </summary>
/// <param name="zippedFileName">The name of the zipped file</param>
/// <param name="tempFolderPath">Temp directory path</param>
private List <AssignmentUploadTracker> UploadCommentedFiles(string zippedFileName, string tempFolderPath)
{
//Keeps track of the uploading progress;
List <AssignmentUploadTracker> uploadTrackers = new List <AssignmentUploadTracker>();
AssignmentUploadTracker currentUploadTracker;
try
{
AssignmentProperties assignmentProperties = SlkStore.LoadAssignmentProperties(AssignmentItemIdentifier, SlkRole.Instructor);
using (SPSite site = new SPSite(assignmentProperties.SPSiteGuid, SPContext.Current.Site.Zone))
{
using (SPWeb web = site.OpenWeb(assignmentProperties.SPWebGuid))
{
SPList dropBoxList = web.Lists[PageCulture.Resources.DropBoxDocLibName];
//Gets the name of the assignment folder.
string assignmentFolderName = zippedFileName.Split('.')[0];
/* Searching for the assignment folder using the naming format: "AssignmentTitle AssignmentCreationDate"
* (This is the naming format defined in AssignmentProperties.aspx.cs page) */
SPQuery query = new SPQuery();
query.Folder = dropBoxList.RootFolder;
query.Query = "<Where><Eq><FieldRef Name='FileLeafRef'/><Value Type='Text'>" + assignmentFolderName + "</Value></Eq></Where>";
SPListItemCollection assignmentFolders = dropBoxList.GetItems(query);
try
{
if (assignmentFolders.Count == 0)
{
// The assignment folder does not exits on the dropbox list.
throw new Exception(assignmentFolderName + " " + PageCulture.Resources.CommentedFilesNoAssignmentFolderException);
}
}
catch (Exception assignmetNotFoundEx)
{
this.contentPanel.Visible = false;
this.errorBanner.Clear();
errorBanner.AddError(ErrorType.Error, assignmetNotFoundEx.Message);
return(null);
}
//Gets the assignment SP folder on the dropbox list.
SPFolder assignmentFolder = assignmentFolders[0].Folder;
string[] commentedFilesPaths;
string extractedFolderPath = tempFolderPath + "\\" + assignmentFolderName;
DirectoryInfo extractedAssignmentfolder = new DirectoryInfo(extractedFolderPath);
Stream assignmentFileStream;
byte[] assignmentContents;
string studentFolderName = string.Empty;
string[] studentFolders;
string assignmentFileName = string.Empty;
int uploadFilescounter = 0;
int ignoredFilescounter = 0;
int missedFilescounter = 0;
SPFileCollection orgFiles;
bool fileFound = false;
bool commentedFileFound = false;
if (extractedAssignmentfolder.Exists)
{
//Gets an array of the students assignment folders paths.
studentFolders = Directory.GetDirectories(extractedFolderPath);
//loop on each student folder to upload the instuctor commented files.
foreach (string studentFolderPath in studentFolders)
{
//keeps track of the current upload status
currentUploadTracker = new AssignmentUploadTracker();
//Gets the student assignment folder
studentFolderName = studentFolderPath.Split('\\')[studentFolderPath.Split('\\').Length - 1];
//Tracking the upload operation: save the student folder name
currentUploadTracker.StudentFolderName = studentFolderName;
//Gets the student assignment SP folder of the current assignment
query = new SPQuery();
query.Folder = assignmentFolder;
query.Query = "<Where><Eq><FieldRef Name='FileLeafRef'/><Value Type='Text'>" + studentFolderName + "</Value></Eq></Where>";
SPListItemCollection assignmentSubFolders = dropBoxList.GetItems(query);
if (assignmentSubFolders.Count == 0)
{
//Tracking the upload operation: The student folder does not exists
currentUploadTracker.IsCompleted = false;
//throw new Exception(PageCulture.Resources.SubmittedFilesNoAssignmentSubFolderException);
}
else
{
SPFolder assignmentSubFolder = assignmentSubFolders[0].Folder;
//Gets the commented files of the current student assignment
commentedFilesPaths = Directory.GetFiles(studentFolderPath);
//Gets the assignment original files
orgFiles = assignmentSubFolder.Files;
//Reset tracking counters
uploadFilescounter = 0;
ignoredFilescounter = 0;
missedFilescounter = 0;
//loop on each file to upload it to the student assignment SP folder
foreach (string assignmentFilePath in commentedFilesPaths)
{
fileFound = false;
foreach (SPFile assignmentFile in orgFiles)
{
//Gets ths assignment file name
assignmentFileName = assignmentFilePath.Split('\\')[assignmentFilePath.Split('\\').Length - 1];
//checks that file exists on ths SP assignment folder
if (assignmentFile.Name == assignmentFileName)
{
fileFound = true;
}
}
//The file exists
if (fileFound)
{
uploadFilescounter++;
assignmentFileStream = File.OpenRead(assignmentFilePath);
assignmentContents = new byte[assignmentFileStream.Length];
assignmentFileStream.Read(assignmentContents, 0, (int)assignmentFileStream.Length);
assignmentFileStream.Close();
web.AllowUnsafeUpdates = true;
//Uploads the current file.
assignmentSubFolder.Files.Add(assignmentFileName, assignmentContents, true);
}
else
{
ignoredFilescounter++;
}
}
//loop on each file on the student assignment SP folder
// to check if there files missed
foreach (SPFile assignmentFile in orgFiles)
{
if ((bool)assignmentFile.Item["IsLatest"])
{
commentedFileFound = false;
foreach (string assignmentFilePath in commentedFilesPaths)
{
//Gets ths assignment file name
assignmentFileName = assignmentFilePath.Split('\\')[assignmentFilePath.Split('\\').Length - 1];
//checks that file exists on ths SP assignment folder
if (assignmentFile.Name == assignmentFileName)
{
commentedFileFound = true;
}
}
//The file does not exists
if (!commentedFileFound)
{
missedFilescounter++;
}
}
}
//Tracking the upload operation: The number of files missed
currentUploadTracker.MissedFilesCount = missedFilescounter;
//Tracking the upload operation: The number of files uploaded
currentUploadTracker.UploadedFilesCount = uploadFilescounter;
//Tracking the upload operation: The number of files ignored.
currentUploadTracker.IgnoredFilesCount = ignoredFilescounter;
//Tracking the upload operation: The upload operation is completed.
currentUploadTracker.IsCompleted = true;
}
uploadTrackers.Add(currentUploadTracker);
}
bool studentFolderFound = false;
AssignmentUploadTracker currentTracker;
//checks if a sttudent folder was not uploaded by the teacher.
if (assignmentFolder.SubFolders.Count != studentFolders.Length)
{
//loops on each student folder under the assignment folder
foreach (SPFolder studentFolder in assignmentFolder.SubFolders)
{
studentFolderFound = false;
//loops on each student folder upload by the teacher
foreach (string studentFolderPath in studentFolders)
{
//Gets the student assignment folder name
studentFolderName = studentFolderPath.Split('\\')[studentFolderPath.Split('\\').Length - 1];
if (studentFolder.Name == studentFolderName)
{
studentFolderFound = true;
}
}
//student folder was not uploaded
if (!studentFolderFound)
{
//tracking the student.
currentTracker = new AssignmentUploadTracker();
currentTracker.StudentFolderName = studentFolder.Name;
currentTracker.IsCompleted = false;
currentTracker.UploadedFilesCount = -1;
uploadTrackers.Add(currentTracker);
}
}
}
web.Update();
web.Dispose();
//Delete the compressed file and extracted folder
//from the windows temp directory
File.Delete(tempFolderPath + "\\" + zippedFileName);
Directory.Delete(tempFolderPath + "\\" + assignmentFolderName, true);
}
}
}
}
catch (Exception ex)
{
this.contentPanel.Visible = false;
this.errorBanner.Clear();
this.errorBanner.AddException(SlkStore, ex);
}
return(uploadTrackers);
}
protected void BtnOk_Click(object sender, EventArgs e)
{
// the user clicked the OK button...
// ensure the user is an administrator, then execute the remaining code within a
// LearningStorePrivilegedScope (which grants full access to database views)
if (!SPFarm.Local.CurrentUserIsAdministrator())
{
throw new UnauthorizedAccessException(
"Access is denied. Only adminstrators can access this page.");
}
using (new LearningStorePrivilegedScope())
{
// if the user didn't select an "original instructor", do nothing
if (OriginalInstructor.SelectedValue.Length == 0)
{
return; // real code would display an error message here
}
// if the user didn't enter any "new instructors", do nothing
if (NewInstructors.Accounts.Count == 0)
{
return; // the <NewInstructors> control already displays a validation error
}
// set <originalInstructorId> to the SLK identifier of the selected "original
// instructor"
UserItemIdentifier originalInstructorId = new UserItemIdentifier(
long.Parse(OriginalInstructor.SelectedValue, CultureInfo.InvariantCulture));
// execute the following code within the context of the current SharePoint Web site;
// in fact, the operations below are actually done across the entire site *collection*,
// but SlkStore.GetStore needs to be passed a Web site, so we use the current site
using (SPWeb spWeb = SPControl.GetContextWeb(HttpContext.Current))
{
// set <assignmentIds> to a list containing the IDs of the assignments for which
// <originalInstructorId> is an instructor
List <AssignmentItemIdentifier> assignmentIds = new List <AssignmentItemIdentifier>();
SlkStore slkStore = SlkStore.GetStore(spWeb);
LearningStoreJob job = slkStore.LearningStore.CreateJob();
LearningStoreQuery query = slkStore.LearningStore.CreateQuery("AllAssignmentIds");
query.AddCondition("SPSiteGuid", LearningStoreConditionOperator.Equal,
spWeb.Site.ID);
query.AddCondition("InstructorId", LearningStoreConditionOperator.Equal,
originalInstructorId);
query.AddColumn("AssignmentId");
job.PerformQuery(query);
DataRowCollection rows = job.Execute <DataTable>().Rows;
OriginalInstructor.Items.Add(String.Empty);
foreach (DataRow row in rows)
{
assignmentIds.Add(new AssignmentItemIdentifier(
(LearningStoreItemIdentifier)row["AssignmentId"]));
}
// set <newInstructorIds> to a list of SLK numeric user IDs corresponding to the
// users in the <NewInstructors> control
List <UserItemIdentifier> newInstructorIds = new List <UserItemIdentifier>();
foreach (string loginName in NewInstructors.Accounts)
{
// set <spUser> to the SharePoint SPUser corresponding to <loginName> (which
// was retrieved from the <NewInstructors> control>; quit with an error
// message if that user isn't in "All People" for this site collection
SPUser spUser;
try
{
spUser = spWeb.AllUsers[loginName];
}
catch (SPException)
{
NewInstructors.ErrorMessage = "User isn't in \"All People\": " +
loginName;
return;
}
// set <userKey> to the SLK "user key", which is a string used to identify a
// user in the SLK database; SLK uses a user's security identifier (SID) if
// they have one, or their login name if they don't (e.g. in the case of forms
// authentication)
string userKey = String.IsNullOrEmpty(spUser.Sid)
? spUser.LoginName : spUser.Sid;
// set <userId> to the SLK UserItemIdentifier of the user <spUser> by
// searching the SLK UserItem table; if the user isn't found in UserItem,
// add them
UserItemIdentifier userId;
job = slkStore.LearningStore.CreateJob();
query = slkStore.LearningStore.CreateQuery("UserItem");
query.AddCondition("Key", LearningStoreConditionOperator.Equal, userKey);
query.AddColumn("Id");
job.PerformQuery(query);
rows = job.Execute <DataTable>().Rows;
if (rows.Count != 0)
{
// found user in the SLK UserItem table
userId = new UserItemIdentifier(
(LearningStoreItemIdentifier)rows[0]["Id"]);
}
else
{
// user not found in SLK UserItem table -- add them; we use
// LearningStoreJob.AddOrUpdateItem rather than LearningStoreJob.AddItem
// to account for the rare case where the user may be added simultaneously
// by another process
job = slkStore.LearningStore.CreateJob();
Dictionary <string, object> findProperties = new Dictionary <string, object>();
findProperties["Key"] = userKey;
Dictionary <string, object> setProperties = new Dictionary <string, object>();
setProperties["Name"] = spUser.Name;
job.AddOrUpdateItem("UserItem", findProperties, setProperties, null, true);
userId = new UserItemIdentifier(
job.Execute <LearningStoreItemIdentifier>());
}
// update <newInstructorIds>
newInstructorIds.Add(userId);
}
// add each user in <newInstructorIds> as an instructor to each assignment in
// <assignmentIds>; set <updatedAssignmentCount> to the number of assignments that
// were updated (note that we don't update assignments for which the new
// instructors are already instructors)
Dictionary <UserItemIdentifier, bool> oldInstructors =
new Dictionary <UserItemIdentifier, bool>();
int updatedAssignmentCount = 0;
foreach (AssignmentItemIdentifier assignmentId in assignmentIds)
{
AssignmentProperties assignmentProperties =
slkStore.GetAssignmentProperties(assignmentId, SlkRole.Instructor);
oldInstructors.Clear();
foreach (SlkUser slkUser in assignmentProperties.Instructors)
{
oldInstructors[slkUser.UserId] = true;
}
int oldInstructorCount = oldInstructors.Count;
foreach (UserItemIdentifier userId in newInstructorIds)
{
if (!oldInstructors.ContainsKey(userId))
{
assignmentProperties.Instructors.Add(new SlkUser(userId));
}
}
if (assignmentProperties.Instructors.Count != oldInstructorCount)
{
slkStore.SetAssignmentProperties(assignmentId, assignmentProperties);
updatedAssignmentCount++;
}
}
// provide user feedback
SuccessPanel.Visible = true;
SuccessLabel.Text =
String.Format("Found {0} assignment(s); updated {1} assignment(s).",
assignmentIds.Count, updatedAssignmentCount);
OriginalInstructorSection.Visible = false;
NewInstructorsSection.Visible = false;
ButtonSection.Visible = false;
}
}
}
private void LoadAssignmentObjects()
{
assignmentProperties = SlkStore.LoadAssignmentPropertiesForLearner(LearnerAssignmentGuidId, SlkRole.Learner);
learnerAssignmentProperties = assignmentProperties.Results[0];
}
/// <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;
}
}
}
/// <summary>
/// Checks the number of the assignment submitted files.
/// </summary>
/// <param name="learnerAssignmentGUID">The assignment GUID</param>
/// <returns> If one assignment submitted, returns its URL.
/// If more than one, returns an empty string.</returns>
private string CheckSubmittedFilesNumber(Guid learnerAssignmentGUID)
{
AssignmentProperties properties = SlkStore.LoadAssignmentPropertiesForLearner(learnerAssignmentGUID, SlkRole.Learner);
return(PerformFilesNumberChecking(properties));
}