static void CreateDatabase(SlkSPSiteMapping mapping, string databaseName, string appPoolAccountName, string databaseSchema)
{
// restrict the characters in <databaseName>
if (!Regex.Match(databaseName, @"^\w+$").Success)
{
throw new SafeToDisplayException(SlkCulture.GetResources().InvalidDatabaseName, databaseName);
}
// if <appPoolAccountName> is null, set it to the name of the application pool account
// (e.g. "NT AUTHORITY\NETWORK SERVICE"); set <appPoolSid> to its SID
byte[] appPoolSid = null;
if (appPoolAccountName == null)
{
using (SPSite site = new SPSite(mapping.SPSiteGuid))
{
appPoolAccountName = site.WebApplication.ApplicationPool.Username;
}
}
NTAccount appPoolAccount = new NTAccount(appPoolAccountName);
SecurityIdentifier securityId =
(SecurityIdentifier)appPoolAccount.Translate(typeof(SecurityIdentifier));
appPoolSid = new byte[securityId.BinaryLength];
securityId.GetBinaryForm(appPoolSid, 0);
SlkUtilities.ImpersonateAppPool(delegate()
{
CreateDatabase(mapping.DatabaseServerConnectionString, databaseName,
mapping.DatabaseConnectionString, appPoolAccountName,
appPoolSid, databaseSchema);
});
}
int DeleteMapping(out string output)
{
string guidValue = Value("guid");
if (string.IsNullOrEmpty(guidValue))
{
output = FormatString(culture.Resources.StsMissingParameter, "guid");
return((int)ErrorCodes.SyntaxError);
}
Guid guid = new Guid(guidValue);
// set <mapping> to the mapping between <spSiteGuid> and the LearningStore connection information for that SPSite
SlkSPSiteMapping mapping = SlkSPSiteMapping.GetMapping(guid);
if (mapping == null)
{
output = FormatString(culture.Resources.StsInvalidGuid, guid);
return((int)ErrorCodes.GeneralError);
}
else
{
mapping.Delete();
output = FormatString(culture.Resources.StsMappingDeleted, guid);
return(0);
}
}
/// <summary>
/// Retrieves the SLK Settings XML for a given SPSite.
/// </summary>
///
/// <param name="spSiteGuid">The GUID of the SPSite to retrieve SLK Settings for.</param>
///
/// <returns>
/// A string containing SLK Settings XML, or null if <pr>spSiteGuid</pr> is not configured for
/// use with SLK.
/// </returns>
///
/// <remarks>
/// This method is static so it can used outside the context of IIS. Only SharePoint
/// administrators can perform this function.
/// </remarks>
///
/// <exception cref="SafeToDisplayException">
/// An error occurred that can be displayed to a browser user.
/// </exception>
///
public static string GetSettingsXml(Guid spSiteGuid)
{
// only SharePoint administrators can perform this action
CheckPermissions();
// set <mapping> to the mapping between <spSiteGuid> and the LearningStore connection
// information for that SPSite
SlkSPSiteMapping mapping = SlkSPSiteMapping.GetMapping(spSiteGuid);
if (mapping == null)
{
return(null);
}
// return the SLK Settings XML for this SPSite
LearningStore learningStore = new LearningStore(mapping.DatabaseConnectionString,
String.Empty, ImpersonationBehavior.UseOriginalIdentity);
using (LearningStorePrivilegedScope privilegedScope = new LearningStorePrivilegedScope())
{
LearningStoreJob job = learningStore.CreateJob();
LearningStoreQuery query = learningStore.CreateQuery(Schema.SiteSettingsItem.ItemTypeName);
query.AddColumn(Schema.SiteSettingsItem.SettingsXml);
query.AddCondition(Schema.SiteSettingsItem.SiteGuid, LearningStoreConditionOperator.Equal, spSiteGuid);
job.PerformQuery(query);
DataRowCollection dataRows = job.Execute <DataTable>().Rows;
if (dataRows.Count != 1)
{
throw new SafeToDisplayException(LoadCulture(spSiteGuid).Resources.SlkSettingsNotFound, spSiteGuid);
}
DataRow dataRow = dataRows[0];
return((string)dataRow[0]);
}
}
int EnumMappings(out string output)
{
System.Text.StringBuilder builder = new System.Text.StringBuilder();
foreach (SlkSPSiteMapping mapping in SlkSPSiteMapping.GetMappings())
{
string siteLabel = null;
try
{
using (SPSite spSite = new SPSite(mapping.SPSiteGuid))
{
siteLabel = spSite.Url;
}
}
catch (System.IO.FileNotFoundException)
{
SPFarm farm = SPFarm.Local;
SPWebApplication webApp = farm.GetObject(mapping.SPSiteGuid) as SPWebApplication;
siteLabel = webApp.Name;
}
builder.AppendFormat(culture.Resources.StsEnumMappingLine, siteLabel, mapping.SPSiteGuid, mapping.DatabaseServer, mapping.DatabaseName);
builder.AppendLine();
}
output = builder.ToString();
return(0);
}
/// <summary>Finds all Slk members of a site.</summary>
/// <param name="web">The site to get the members for.</param>
/// <param name="store">The ISlkStore to use.</param>
/// <param name="instructorsOnly">Whether to only get instructors or not.</param>
public void FindAllSlkMembers(SPWeb web, ISlkStore store, bool instructorsOnly)
{
if (web == null)
{
throw new ArgumentNullException("web");
}
this.store = store;
// keep track of when this method started, for timeout purposes
startTime = DateTime.Now;
// Verify that the SPWeb is in the SPSite associated with this SlkStore, because if it
// isn't then the code below below may be using the wrong SLK instructor and learner
// permission names; for example, the SPSite of this SlkStore may name the instructor
// permission "SLK Instructor", but <web> may be in a different SPSite which might name
// the instructor permission "SLK Teacher"
if (web.Site.ID != store.SPSiteGuid)
{
throw new InvalidOperationException(culture.Resources.SPWebDoesNotMatchSlkSPSite);
}
// Security checks: Fails if the user isn't an instructor and a Reader (implemented by EnsureInstructor)
// since we use SPSecurity.RunWithElevatedPrivileges, we need to make sure the current user is an instructor
if (instructorsOnly == false)
{
store.EnsureInstructor(web);
}
SlkSPSiteMapping mapping = store.Mapping;
SPRoleDefinition instructorRole = FindRole(web, mapping.InstructorPermission);
SPRoleDefinition learnerRole = FindRole(web, mapping.LearnerPermission);
domainGroupEnumeratorType = store.Settings.DomainGroupEnumeratorType;
domainGroupEnumeratorAssembly = store.Settings.DomainGroupEnumeratorAssembly;
SPSecurity.RunWithElevatedPrivileges(delegate()
{
using (SPSite site2 = new SPSite(web.Url))
{
using (SPWeb elevatedWeb = site2.OpenWeb())
{
IterateWebRoles(elevatedWeb, instructorRole, learnerRole, instructorsOnly, store.Settings.HideDisabledUsers);
}
}
});
store.AssignUserItemIdentifier(users.Values);
// populate the Users property of each item in <learnerGroups>
foreach (SlkGroup learnerGroup in learnerGroups)
{
foreach (string userKey in learnerGroup.UserKeys)
{
learnerGroup.AddUser(users[userKey]);
}
}
learnerGroups.Sort();
}
/// <summary>Loads SLK configuration information from WSS and LearningStore, in a form that's
/// suitable for copying to Configure.aspx form fields. </summary>
///
/// <param name="spSiteGuid">The GUID of the SPSite to retrieve configuration information
/// from.</param>
///
/// <returns>An AdministrationConfiguration.</returns>
///
/// <remarks>
/// This method is static so it can used outside the context of IIS. Only SharePoint
/// administrators can perform this function.
/// </remarks>
///
/// <exception cref="SafeToDisplayException">
/// An error occurred that can be displayed to a browser user.
/// </exception>
///
public static AdministrationConfiguration LoadConfiguration(Guid spSiteGuid)
{
AdministrationConfiguration configuration = new AdministrationConfiguration(spSiteGuid);
// only SharePoint administrators can perform this action
CheckPermissions();
// set <mapping> to the mapping between <spSiteGuid> and the LearningStore connection
// information for that SPSite
SlkSPSiteMapping mapping = SlkSPSiteMapping.GetMapping(spSiteGuid);
// set "out" parameters based on <mappingExists> and <mapping>
if (mapping != null)
{
// the mapping exists -- set "out" parameters based on <mapping>
configuration.DatabaseServer = mapping.DatabaseServer;
configuration.DatabaseName = mapping.DatabaseName;
configuration.InstructorPermission = mapping.InstructorPermission;
configuration.LearnerPermission = mapping.LearnerPermission;
// The below given condition will be true only during the migration of SLK from
// 'SLK without Observer role' to 'SLK with Observer role' implementation
if (mapping.ObserverPermission == null)
{
mapping.ObserverPermission = LoadCulture(spSiteGuid).Resources.DefaultSlkObserverPermissionName;
}
configuration.ObserverPermission = mapping.ObserverPermission;
}
else
{
SlkCulture siteCulture = LoadCulture(spSiteGuid);
AppResourcesLocal adminResources = SlkCulture.GetResources();
configuration.IsNewConfiguration = true;
mapping = SlkSPSiteMapping.CreateMapping(spSiteGuid);
// the mapping doesn't exist -- set "out" parameters to default values
SPWebService adminWebService = SlkAdministration.GetAdminWebService();
configuration.DatabaseServer = adminWebService.DefaultDatabaseInstance.Server.Address;
configuration.DatabaseName = adminResources.DefaultSlkDatabaseName;
mapping.DatabaseServer = configuration.DatabaseServer;
mapping.DatabaseName = configuration.DatabaseName;
configuration.InstructorPermission = siteCulture.Resources.DefaultSlkInstructorPermissionName;
configuration.LearnerPermission = siteCulture.Resources.DefaultSlkLearnerPermissionName;
configuration.ObserverPermission = siteCulture.Resources.DefaultSlkObserverPermissionName;
}
// set "out" parameters that need to be computed
bool createDatabaseResult = false;
SlkUtilities.ImpersonateAppPool(delegate()
{
createDatabaseResult = !DatabaseExists(mapping.DatabaseServerConnectionString, mapping.DatabaseName);
});
configuration.CreateDatabase = createDatabaseResult;
return(configuration);
}
/// <summary>
/// Retrieves the SPSite-to-LearningStore mapping represented by a given SPSite GUID. If no
/// such mapping exists, a new mapping object is created -- in that case, the caller should
/// set the properties of the <c>SlkSPSiteMapping</c> object to their correct values and then
/// call <c>Update</c> to store the mapping into the SharePoint configuration database.
/// </summary>
/// <param name="spSiteGuid">The GUID of the SPSite to retrieve a mapping for.</param>
/// <returns>
/// <c>true</c> if an existing mapping was found; <c>false</c> if a new mapping is created.
/// In the latter case, the new mapping is not stored in the SharePoint configuration
/// database until <c>Update</c> is called.
/// </returns>
///
public static SlkSPSiteMapping GetMapping(Guid spSiteGuid)
{
SlkSPSiteMappingCollection mappingCollection = GetMappingInfo();
// set <mapping> to the SlkSPSiteMapping corresponding to <spSiteGuid>
string persistedObjectName = String.Format(CultureInfo.InvariantCulture, PersistedObjectNameFormat, spSiteGuid);
SlkSPSiteMapping mapping = mappingCollection.GetValue <SlkSPSiteMapping>(persistedObjectName);
return(mapping);
}
/// <summary>
/// Saves SLK configuration information. This method accepts information in a form that's
/// compatible with Configure.aspx form fields.
/// </summary>
///
/// <param name="spSiteGuid">The GUID of the SPSite being configured.</param>
///
/// <param name="databaseServer">The name of the database server to associate with the
/// specified SPSite. By default, integrated authentication is used to connect to the
/// database; to use a SQL Server user ID and password instead, append the appropriate
/// connection string information to the database server name -- for example, instead of
/// "MyServer", use "MyServer;user id=myacct;password=mypassword". For security reasons,
/// integrated authentication is strongly recommended.</param>
///
/// <param name="databaseName">The name of the database to associate with the specified
/// SPSite. This database must exist if <paramref name="schemaToCreateDatabase"/> is
/// <c>null</c>, and must not exist if <paramref name="schemaToCreateDatabase"/> is
/// non-<c>null</c>, otherwise an error message is returned.</param>
///
/// <param name="schemaToCreateDatabase">If non-<c>null</c>, this is the SlkSchema.sql file
/// containing the schema of the database, and an SLK database named
/// <paramref name="databaseName"/> is created using this schema. If <c>null</c>,
/// <paramref name="databaseName"/> specifies an existing database.</param>
///
/// <param name="instructorPermission">The name of the SharePoint permission that
/// identifies instructors.</param>
///
/// <param name="learnerPermission">The name of the SharePoint permission that
/// identifies learners.</param>
///
/// <param name="observerPermission">The name of the SharePoint permission that
/// identifies observers.</param>
///
/// <param name="createPermissions">If <c>true</c>, the permissions specified by
/// <paramref name="instructorPermission"/> and <paramref name="learnerPermission"/>
/// are added to the root SPWeb of the specified SPSite (if they don't already
/// exist).</param>
///
/// <param name="settingsFileContents">If not <c>null</c>, this is the contents of a SLK
/// Settings file to associate with this SPSite. If <c>null</c>, the previous SLK
/// Settings file is used if one exists, or the default SLK settings file is used if a
/// database is being created.</param>
///
/// <param name="defaultSettingsFileContents">The contents of the default SLK Settings file.
/// Must not be <n>null</n>.</param>
///
/// <param name="appPoolAccountName">The name of the application pool account; for example,
/// "NT AUTHORITY\NETWORK SERVICE". If <n>null</n>, then the current Windows identity is
/// used, or, if the current identity is impersonated, the original Windows identity is
/// used.</param>
///
/// <remarks>
/// This method is static so it can used outside the context of IIS. Only SharePoint
/// administrators can perform this function.
/// </remarks>
///
/// <exception cref="SafeToDisplayException">
/// An error occurred that can be displayed to a browser user.
/// </exception>
///
public static void SaveConfiguration(Guid spSiteGuid, string databaseServer,
string databaseName, string schemaToCreateDatabase, string instructorPermission,
string learnerPermission, string observerPermission, bool createPermissions, string settingsFileContents,
string defaultSettingsFileContents, string appPoolAccountName)
{
CheckParameters(databaseServer, databaseName, instructorPermission, learnerPermission, observerPermission, defaultSettingsFileContents);
// only SharePoint administrators can perform this action
CheckPermissions();
// set <mapping> to the mapping between <spSiteGuid> and the LearningStore connection information for that SPSite
SlkSPSiteMapping mapping = SlkSPSiteMapping.GetMapping(spSiteGuid);
if (mapping == null)
{
mapping = SlkSPSiteMapping.CreateMapping(spSiteGuid);
}
mapping.DatabaseServer = databaseServer;
mapping.DatabaseName = databaseName;
mapping.InstructorPermission = instructorPermission;
mapping.LearnerPermission = learnerPermission;
mapping.ObserverPermission = observerPermission;
if (mapping.IsDirty)
{
mapping.Update();
}
// create the database if specified
if (schemaToCreateDatabase != null)
{
CreateDatabase(mapping, databaseName, appPoolAccountName, schemaToCreateDatabase);
}
// create permissions if specified
if (createPermissions)
{
SlkCulture culture = LoadCulture(spSiteGuid);
// create the permissions if they don't exist yet
CreatePermission(spSiteGuid, instructorPermission, culture.Resources.SlkInstructorPermissionDescription, 0);
CreatePermission(spSiteGuid, learnerPermission, culture.Resources.SlkLearnerPermissionDescription, 0);
CreatePermission(spSiteGuid, observerPermission, culture.Resources.SlkObserverPermissionDescription, 0);
}
UpdateSlkSettings(mapping.DatabaseConnectionString, spSiteGuid, settingsFileContents, defaultSettingsFileContents);
}
/// <summary>
/// Returns the SPSite-to-LearningStore mapping represented by a given SPSite GUID. If no
/// such mapping exists, an exception is thrown.
/// </summary>
///
/// <param name="site">The SPSite to retrieve a mapping for.</param>
///
/// <exception cref="SlkNotConfiguredException">
/// SLK is not configured for SharePoint site collection.
/// (This configuration is performed in SharePoint Central Administration.)
/// </exception>
///
public static SlkSPSiteMapping GetRequiredMapping(SPSite site)
{
SlkSPSiteMapping mapping = GetMapping(site.ID);
if (mapping == null)
{
mapping = GetMapping(site.WebApplication.Id);
}
if (mapping == null)
{
throw new SlkNotConfiguredException(SlkCulture.GetResources().SlkNotEnabled);
}
else
{
return(mapping);
}
}
private static SlkSettings LoadSettings(SlkSPSiteMapping mapping, SPSite site, XmlSchema xmlSchema)
{
// create a LearningStore. Read is in privileged scope so irrelevant what key is.
// Cannot use current user as may be be called in a page PreInit event when it's not necessarily valid
string learningStoreKey = "SHAREPOINT\\System";
LearningStore learningStore = new LearningStore(mapping.DatabaseConnectionString, learningStoreKey, ImpersonationBehavior.UseOriginalIdentity);
// read the SLK Settings file from the database into <settings>
SlkSettings settings;
using (LearningStorePrivilegedScope privilegedScope = new LearningStorePrivilegedScope())
{
LearningStoreJob job = learningStore.CreateJob();
LearningStoreQuery query = learningStore.CreateQuery(Schema.SiteSettingsItem.ItemTypeName);
query.AddColumn(Schema.SiteSettingsItem.SettingsXml);
query.AddColumn(Schema.SiteSettingsItem.SettingsXmlLastModified);
query.AddCondition(Schema.SiteSettingsItem.SiteGuid, LearningStoreConditionOperator.Equal, mapping.SPSiteGuid);
job.PerformQuery(query);
DataRowCollection dataRows = job.Execute <DataTable>().Rows;
if (dataRows.Count != 1)
{
throw new SafeToDisplayException(SlkCulture.GetResources().SlkSettingsNotFound, site.Url);
}
DataRow dataRow = dataRows[0];
string settingsXml = (string)dataRow[0];
DateTime settingsXmlLastModified = ((DateTime)dataRow[1]);
using (StringReader stringReader = new StringReader(settingsXml))
{
XmlReaderSettings xmlSettings = new XmlReaderSettings();
xmlSettings.Schemas.Add(xmlSchema);
xmlSettings.ValidationType = ValidationType.Schema;
using (XmlReader xmlReader = XmlReader.Create(stringReader, xmlSettings))
{
settings = new SlkSettings(xmlReader, settingsXmlLastModified);
}
}
}
return(settings);
}
/// <summary>Get the anonymous store.</summary>
/// <param name="site">The site to get the settings for.</param>
/// <returns></returns>
public static AnonymousSlkStore GetStore(SPSite site)
{
Guid siteId = site.ID;
// set <httpContext> to the current HttpContext (null if none)
HttpContext httpContext = HttpContext.Current;
// if an AnonymousSlkStore corresponding to <spSiteGuid> is cached, retrieve it, otherwise
// create one
string cacheItemName = null;
AnonymousSlkStore anonymousSlkStore;
if (httpContext != null)
{
cacheItemName = String.Format(CultureInfo.InvariantCulture, "SlkStore_{0}", siteId);
anonymousSlkStore = (AnonymousSlkStore)httpContext.Cache.Get(cacheItemName);
if (anonymousSlkStore != null)
{
return(anonymousSlkStore);
}
}
// set <mapping> to the SlkSPSiteMapping corresponding to <siteId>; if no such
// mapping, exists, a SafeToDisplayException is thrown
SlkSPSiteMapping mapping = SlkSPSiteMapping.GetRequiredMapping(site);
// load "SlkSettings.xsd" from a resource into <xmlSchema>
XmlSchema xmlSchema;
using (StringReader schemaStringReader = new StringReader(SlkCulture.GetDefaultResources().SlkSettingsSchema))
{
xmlSchema = XmlSchema.Read(schemaStringReader,
delegate(object sender2, ValidationEventArgs e2)
{
// ignore warnings (already displayed when SLK Settings file was uploaded)
});
}
SlkSettings settings = null;
try
{
settings = LoadSettings(mapping, site, xmlSchema);
}
catch (SqlException)
{
// Try again in case temporary error
try
{
settings = LoadSettings(mapping, site, xmlSchema);
}
catch (SqlException e)
{
SlkCulture culture = new SlkCulture(CultureInfo.InvariantCulture);
SlkStore.LogError(culture.Resources.SlkSettingsSqlErrorLoad + " {0}", culture, e);
throw new SafeToDisplayException(culture.Resources.SlkSettingsSqlErrorLoad);
}
}
// create and (if possible) cache the new AnonymousSlkStore object
anonymousSlkStore = new AnonymousSlkStore(siteId, mapping, settings);
DateTime cacheExpirationTime = DateTime.Now.AddSeconds(HttpContextCacheTime);
if (httpContext != null)
{
httpContext.Cache.Add(cacheItemName, anonymousSlkStore, null, cacheExpirationTime,
System.Web.Caching.Cache.NoSlidingExpiration,
System.Web.Caching.CacheItemPriority.Normal, null);
}
return(anonymousSlkStore);
}
///////////////////////////////////////////////////////////////////////////////////////////////
// Public Methods
//
/// <summary>
/// Initializes an instance of this class.
/// </summary>
///
/// <param name="spSiteGuid">The value to use to initialize the <c>SPSiteGuid</c> property.
/// </param>
///
/// <param name="mapping">The value to use to initialize the <c>Mapping</c> property.
/// </param>
///
/// <param name="settings">The value to use to initialize the <c>Settings</c> property.
/// </param>
///
public AnonymousSlkStore(Guid spSiteGuid, SlkSPSiteMapping mapping, SlkSettings settings)
{
m_spSiteGuid = spSiteGuid;
m_mapping = mapping;
m_settings = settings;
}
