/// <summary>
/// Removes the rule.
/// </summary>
/// <param name="id">The id of the rule to remove</param>
public static void RemoveRule(Guid id)
{
WebSiteControllerConfig rules = GetFromConfigDB();
rules.rules.Remove(id);
rules.Update();
}
/// <summary>
/// Removes the rule.
/// </summary>
/// <param name="id">The id of the rule to remove</param>
public static void RemoveRule(string id)
{
WebSiteControllerConfig rules = GetFromConfigDB();
rules.rules.Remove(new Guid(id));
rules.Update();
}
/// <summary>
/// Adds the module.
/// </summary>
/// <param name="fullyQualifiedClassName">Name of the fully qualified class of the module being added.</param>
public static void AddModule(string fullyQualifiedClassName)
{
WebSiteControllerConfig config = GetFromConfigDB();
IWebSiteControllerModule module = GetModuleFromClassName(fullyQualifiedClassName);
config.modules.Add(new PersistedWebSiteControllerModule(Guid.NewGuid(), module.RuleType, fullyQualifiedClassName, config));
}
public static void AddModule(IWebSiteControllerModule module, string fullyQualifiedClassName)
{
WebSiteControllerConfig config = GetFromConfigDB();
PersistedWebSiteControllerModule mod = new PersistedWebSiteControllerModule(Guid.NewGuid(), module.RuleType, fullyQualifiedClassName, config);
mod.Update();
//config.modules.Add(new PersistedWebSiteControllerModule(module.Id, module.RuleType, fullyQualifiedClassName, config));
}
/// <summary>
/// Checks if the WebSiteControllerRules exist
/// </summary>
/// <returns>true if they exist; otherwise false</returns>
public static bool Exists()
{
if (WebApp == null && HttpContext.Current != null) // && HttpContext.Current.Request != null)
{
HttpRequest request = HttpContext.Current.Request;
string url = HttpContext.Current.Request.Url.OriginalString;
//try
//{
if (SPSite.Exists(HttpContext.Current.Request.Url))
{
SPSite site = new SPSite(HttpContext.Current.Request.Url.OriginalString);
WebApp = site.WebApplication;
}
//}
//catch { return false; };
}
if (WebApp != null)
{
if (WebApp != SPAdministrationWebApplication.Local)
{
WebSiteControllerConfig config = WebApp.GetChild <WebSiteControllerConfig>(OBJECTNAME);
return(config != null);
}
/*
* else
* {
*
* return SPFarm.Local.GetObject(ID) != null;
* }
*/
}
return(false);
/*
* try
* {
* return SPContext.Current.Site.WebApplication.GetChild<WebSiteControllerConfig>(OBJECTNAME) != null;
* }
* catch (Exception ex)
* {
* //WebSiteControllerConfig config = SPContext.Current.Site.WebApplication.GetChild<WebSiteControllerConfig>();
* //config.Delete();
* }
* return false;
*/
}
/// <summary>
/// Adds a new WebSiteControllerRule.
/// </summary>
/// <param name="siteCollection">The site collection.</param>
/// <param name="page">The page to which the rule applied</param>
/// <param name="ruleType">Type of the rule.</param>
/// <param name="principal">The principal.</param>
/// <param name="principalType">Type of the principal.</param>
/// <param name="disabled">if set to <c>true</c> the rule is disabled.</param>
/// <param name="appliesToSsl">if set to <c>true</c> the rule applies to SSL.</param>
/// <param name="sequence">The sequence of the rule compared to other rules.</param>
/// <param name="properties">The properties.</param>
/// <returns>The resulting WebSiteControllerRule</returns>
public static WebSiteControllerRule AddRule(
SPWebApplication Webapp,
string siteCollection,
string page,
string ruleType,
string principal,
WebSiteControllerPrincipalType principalType,
bool disabled,
bool appliesToSsl,
int sequence,
Hashtable properties)
{
WebApp = Webapp;
WebSiteControllerConfig config = GetFromConfigDB();
WebSiteControllerRule rule = new WebSiteControllerRule(
siteCollection,
page,
ruleType,
principal,
principalType,
disabled,
appliesToSsl,
sequence,
config);
rule.Name = rule.Id.ToString();
if (properties != null)
{
foreach (DictionaryEntry property in properties)
{
rule.Properties.Add(property.Key, property.Value);
}
}
if (!IsDuplicateRule(rule))
{
config.rules.Add(rule);
config.Update();
}
else
{
throw new SPDuplicateObjectException(rule + " is the same as another rule in the WebSiteControllerRules collection");
}
return(rule);
}
public static void AddModule(SPWebApplication Webapp, IWebSiteControllerModule module, string fullyQualifiedClassName)
{
try
{
WebApp = Webapp;
WebSiteControllerConfig config = GetFromConfigDB();
PersistedWebSiteControllerModule mod = new PersistedWebSiteControllerModule(Guid.NewGuid(), module.RuleType, fullyQualifiedClassName, config);
mod.Update();
}
catch (Exception ex)
{
SPDiagnosticsService.Local.WriteTrace(0, new SPDiagnosticsCategory(ex.Source, TraceSeverity.High, EventSeverity.Error), TraceSeverity.High, ex.Message, ex.Data);
//ex.ToString();
}
//config.modules.Add(new PersistedWebSiteControllerModule(module.Id, module.RuleType, fullyQualifiedClassName, config));
}
//private SPWebApplication WebApp;
//private Guid guid;
/// <summary>
/// Creates the WebSiteControllerRules in config DB.
/// </summary>
public static void CreateInConfigDB()
{
if (!Exists())
{
if (HttpContext.Current != null)
{
try
{
SPSite site = new SPSite(HttpContext.Current.Request.Url.OriginalString);
WebApp = site.WebApplication;
}
catch { };
}
if (WebApp != null && WebApp != SPAdministrationWebApplication.Local)
{
lock (createlock)
{
WebSiteControllerConfig settings = new WebSiteControllerConfig(WebApp, Guid.NewGuid());
settings.Update();
}
}
/*
* else
* {
* lock (createlock)
* {
*
* WebSiteControllerConfig settings = new WebSiteControllerConfig();
* settings.Update();
* }
* }
*/
}
}
protected override bool ProcessWorkItems(SPContentDatabase contentDatabase, SPWorkItemCollection workItems, SPJobState jobState)
{
foreach (SPWorkItem workItem in workItems)
{
if (workItem != null)
{
try
{
SPSite site = new SPSite(workItem.SiteId);
IWebSiteControllerModule module = null;
WebSiteControllerRule rule = null;
bool _deleted = false;
//int ItemID = workItem.ItemId;
if (workItem.ItemId > 0)
{
rule = WebSiteControllerConfig.GetRule(contentDatabase.WebApplication, workItem.ItemGuid);
}
else
{
module = WebSiteControllerConfig.GetModule(contentDatabase.WebApplication, workItem.ItemGuid);
}
if (rule != null)
{
WebSiteControllerConfig.RemoveRule(rule.Id);
_deleted = true;
}
if (workItem.ItemId < 0 || _deleted)
{
string[] data = workItem.TextPayload.Split(new char[] { '#' });
string parameterRule = data[0];
string parameterProperties = data[1];
string[] rules = parameterRule.Split(new char[] { ';' });
string url = rules[0];
bool disabled = bool.Parse(rules[1]);
bool ssl = bool.Parse(rules[2]);
int sequence = int.Parse(rules[3]);
WebSiteControllerPrincipalType principalType = WebSiteControllerPrincipalType.None;
if (!String.IsNullOrEmpty(rules[4]))
{
principalType = (WebSiteControllerPrincipalType)Enum.Parse(typeof(WebSiteControllerPrincipalType), rules[4]);
}
string principal = rules[5];
string ruletype = string.Empty;
if (module != null || String.IsNullOrEmpty(rule.RuleType))
{
ruletype = module.RuleType;
}
else if (rule != null && ruletype == string.Empty)
{
ruletype = rule.RuleType;
}
string[] properties = parameterProperties.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
Hashtable props = new Hashtable();
foreach (string prop in properties)
{
try
{
if (!string.IsNullOrEmpty(prop))
{
string[] keyval = prop.Split(new char[] { ':' });
props.Add(keyval[0], keyval[1]);
}
}
catch { };
}
if (_deleted && workItem.ItemId != 1)
{
WebSiteControllerConfig.AddRule(contentDatabase.WebApplication,
site.Url + "/",
url,
rule.RuleType,
rule.Principal,
rule.PrincipalType,
disabled,
ssl,
sequence,
props
);
}
if (workItem.ItemId == -1)
{
WebSiteControllerConfig.AddRule(contentDatabase.WebApplication,
site.Url + "/",
url,
ruletype,
principal,
principalType,
disabled,
ssl,
sequence,
props
);
}
}
}
catch (Exception ex)
{
ex.ToString();
//throw (ex);
}
finally
{
DeleteWorkItem(workItems, workItem);
//using (SPSite site = new SPSite(workItem.SiteId))
//{
// using (SPWeb web = site.OpenWeb(workItem.WebId))
// {
// SPWorkItemCollection deletableCollection = workItems.SubCollection(site, web, (uint)workItem.i, (uint)itemIndex + 1);
// deletableCollection.DeleteWorkItem(currentItem.Id);
// //workItems.CompleteInProgressWorkItems(workItem.ParentId, workItem.Type, workItem.BatchId);
// //workItems.SubCollection(site, web, 0, (uint)workItems.Count).DeleteWorkItem(workItem.Id);
// }
//}
////workItems.DeleteWorkItem(workItem.Id);
}
}
}
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="WebSiteControllerModulesCollection"/> class.
/// </summary>
/// <param name="config">The config.</param>
internal WebSiteControllerModulesCollection(WebSiteControllerConfig config) :
base(config)
{
}
protected override bool ProcessWorkItems(SPContentDatabase contentDatabase, SPWorkItemCollection workItems, SPJobState jobState)
{
foreach (SPWorkItem workItem in workItems)
{
if (workItem != null)
{
if (workItem.ItemGuid != Guid.Empty)
{
WebSiteControllerConfig.RemoveModule(contentDatabase.WebApplication, workItem.ItemGuid);
}
if (!String.IsNullOrEmpty(workItem.TextPayload))
{
try
{
string[] param = workItem.TextPayload.Split(new char[] { ';' });
Assembly assembly = System.Reflection.Assembly.Load(param[1]);
Type moduletype = null;
Type[] types = assembly.GetTypes();
foreach (Type type in types)
{
string name = type.FullName;
if (name.Equals(param[0]))
{
moduletype = type;
break;
}
}
if (moduletype != null)
{
SPWebApplication WebApp = contentDatabase.WebApplication;
//WebSiteControllerConfig config = WebApp.GetChild<WebSiteControllerConfig>(WebSiteControllerConfig.OBJECTNAME);
IWebSiteControllerModule module = (IWebSiteControllerModule)Activator.CreateInstance(moduletype);
WebSiteControllerConfig.AddModule(WebApp, module, param[0] + "," + param[1]);
}
}
catch (Exception ex)
{
ex.ToString();
//throw (ex);
}
finally
{
DeleteWorkItem(workItems, workItem);
/*
* using (SPSite site = new SPSite(workItem.SiteId))
* {
*
* using (SPWeb web = site.OpenWeb(workItem.WebId))
* {
* workItems.CompleteInProgressWorkItems(workItem.ParentId, workItem.Type, workItem.BatchId);
* //workItems.SubCollection(site, web, 0, (uint)workItems.Count).DeleteWorkItem(workItem.Id);
*
* }
*
* }
*/
}
}
}
}
return(true);
}
