/// <summary>
/// Registers an event receiver if required.
/// </summary>
/// <param name="this">
/// The this.
/// </param>
/// <param name="eventReceiverType">
/// The event receiver type.
/// </param>
/// <param name="assemblyName">
/// The assembly name.
/// </param>
/// <param name="className">
/// The class name.
/// </param>
/// <param name="synchronization">
/// The synchronization.
/// </param>
public static void RegisterEventReceiverIfRequired(this SPList @this, SPEventReceiverType eventReceiverType, string assemblyName, string className, SPEventReceiverSynchronization synchronization = SPEventReceiverSynchronization.Default)
{
// Validation.ArgumentIsNotNull(() => @this);
// Validation.ArgumentIsNotNullOrWhitespace(() => assemblyName);
// Validation.ArgumentIsNotNullOrWhitespace(() => className);
SPEventReceiverDefinition eventReceiverDefinition = @this.EventReceivers.OfType<SPEventReceiverDefinition>().FirstOrDefault(receiver => receiver.Type == eventReceiverType && receiver.Assembly.Equals(assemblyName) && receiver.Class.Equals(className));
if (eventReceiverDefinition == null)
{
@this.EventReceivers.Add(eventReceiverType, assemblyName, className);
eventReceiverDefinition = @this.EventReceivers.OfType<SPEventReceiverDefinition>().First(receiver => receiver.Type == eventReceiverType && receiver.Assembly.Equals(assemblyName) && receiver.Class.Equals(className));
eventReceiverDefinition.Synchronization = synchronization;
eventReceiverDefinition.Update();
Type type = Type.GetType(string.Format(CultureInfo.InvariantCulture, "{0}, {1}", className, assemblyName));
if (type != null && typeof(StateMachineItemEventReceiverBase).IsAssignableFrom(type) && [email protected](SystemFieldNames.ChangeDetectionFieldName))
{
@this.Fields.Add(SystemFieldNames.ChangeDetectionFieldName, SPFieldType.Text, false);
@this.Update();
IEnumerable<SPField> changeDetectionFields = @this.Fields.OfType<SPField>().Where(field => SystemFieldNames.ChangeDetectionFieldName.Equals(field.Title)).ToList();
foreach (SPField changeDetectionField in changeDetectionFields)
{
changeDetectionField.Hidden = true;
changeDetectionField.Update();
}
@this.Update();
}
}
}
/// <summary>
/// Event Receiver Info (List)
/// </summary>
/// <param name="list">The list</param>
/// <param name="type">The event receiver type</param>
/// <param name="syncType">The synchronization type</param>
public EventReceiverInfo(ListInfo list, SPEventReceiverType type, SPEventReceiverSynchronization syncType)
{
this.List = list;
this.EventOwner = EventReceiverOwner.List;
this.ReceiverType = type;
this.SynchronizationType = syncType;
}
public EventInfos(Guid listID, string recClass, string recAssembly, SPEventReceiverType recType)
{
ListID = listID;
SClass = recClass;
SAssembly = recAssembly;
Type = recType;
}
/// <summary>
/// Adds the event handler to the content type.
/// </summary>
/// <param name="contentType">The content type.</param>
/// <param name="name">The name of the event.</param>
/// <param name="assembly">The assembly containin the event receiver.</param>
/// <param name="className">Name of the event receiver class.</param>
/// <param name="type">The event receiver type.</param>
/// <param name="sequence">The sequence.</param>
/// <param name="sync">The synchronization type.</param>
public void AddEventHandler(
SPContentType contentType,
string name,
string assembly,
string className,
SPEventReceiverType type,
int sequence,
SPEventReceiverSynchronization sync)
{
// Guard
if (contentType == null)
{
throw new ArgumentNullException("contentType");
}
SPEventReceiverDefinition definition = GetEventHandler(contentType.EventReceivers, name, type);
if (definition == null)
{
contentType.EventReceivers.Add(type, assembly, className);
definition = GetEventHandler(contentType.EventReceivers, className, type);
}
definition.Name = name;
definition.SequenceNumber = sequence;
definition.Synchronization = sync;
definition.Update();
}
private void OkButton_Click(object sender, EventArgs e)
{
try
{
foreach (string typeName in this.TypesCheckedListBox.CheckedItems)
{
try
{
Type selectedObjectType = this.SelectedObject.GetType();
SPEventReceiverType eventType = (SPEventReceiverType)Enum.Parse(typeof(SPEventReceiverType), typeName);
int maxSequence = 9999;
SPEventReceiverDefinitionCollection definitions = null;
string parentName = string.Empty;
if (typeof(SPWeb).IsAssignableFrom(selectedObjectType))
{
SPWeb web = (SPWeb)this.SelectedObject;
parentName = web.Name;
definitions = web.EventReceivers;
}
else if (typeof(SPList).IsAssignableFrom(selectedObjectType))
{
SPList list = (SPList)this.SelectedObject;
parentName = list.Title;
definitions = list.EventReceivers;
}
else
{
throw new NotSupportedException("The selected object type is not supported.");
}
if (definitions != null)
{
this.m_ParentForm.LastSelectedGACObjectType = this.SelectedType;
Utility.ProcessEventHookAction(this, this.SelectedObject, typeName, this.SelectedAssembly, this.SelectedType, this.UseNextSequenceNumberCheckBox.Checked);
}
}
catch (Exception exception)
{
MessageBox.Show(exception.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Hand);
}
}
MessageBox.Show(this, "The selected events have been hooked. The event sequence should be reviewed to ensure that events execute in the expected order.", "Event Hooks Added", MessageBoxButtons.OK, MessageBoxIcon.Information);
this.DialogResult = System.Windows.Forms.DialogResult.OK;
this.Close();
}
catch (Exception ex)
{
this.HandleException(ex);
}
}
public void HandleSecurityRules(SPListItem listItem, SPEventReceiverType eventType)
{
SPSecurity.RunWithElevatedPrivileges(delegate()
{
SecuritySettings settings = listItem.ParentList.GetCustomSettings<SecuritySettings>(TVMCORPFeatures.TVS);
if (settings == null) return;
settings.Rules.Sort(delegate(Rule rule1, Rule rule2)
{
return rule1.Order.CompareTo(rule2.Order);
});
foreach (Rule r in settings.Rules)
{
bool ruleQualified = ValidateRule(r, listItem, eventType);
if (ruleQualified)
{
bool itemQuailfied = ValidateItem(listItem, r);
if (itemQuailfied)
{
ApplySecuritySettings(listItem, r);
break;
}
}
}
});
}
public bool EventReceiverDefinitionExist(SPEventReceiverDefinitionCollection collection, SPEventReceiverType type, string assemblyFullName, string classFullName)
{
if (collection == null)
{
throw new ArgumentNullException("collection");
}
if (string.IsNullOrEmpty(assemblyFullName))
{
throw new ArgumentNullException("assemblyFullName");
}
if (string.IsNullOrEmpty(classFullName))
{
throw new ArgumentNullException("classFullName");
}
// If there is nothing in the collection we don't even need to check.
if (collection.Count <= 0)
{
return false;
}
// Get the event receiver if it exists.
SPEventReceiverDefinition eventReceiver = this.GetEventReceiverDefinition(collection, type, assemblyFullName, classFullName);
return eventReceiver != null;
}
/// <summary>
/// Event Receiver Info (List)
/// </summary>
/// <param name="list">The list</param>
/// <param name="type">The event receiver type</param>
/// <param name="syncType">The synchronization type</param>
public EventReceiverInfo(ListInfo list, SPEventReceiverType type, SPEventReceiverSynchronization syncType)
{
this.List = list;
this.EventOwner = EventReceiverOwner.List;
this.ReceiverType = type;
this.SynchronizationType = syncType;
}
public SPEventReceiverDefinition GetEventReceiverDefinition(SPEventReceiverDefinitionCollection collection, SPEventReceiverType type, string assemblyFullName, string classFullName)
{
if (collection == null)
{
throw new ArgumentNullException("collection");
}
if (string.IsNullOrEmpty(assemblyFullName))
{
throw new ArgumentNullException("assemblyFullName");
}
if (string.IsNullOrEmpty(classFullName))
{
throw new ArgumentNullException("classFullName");
}
foreach (SPEventReceiverDefinition eventReceiver in collection)
{
bool isCorrectType = eventReceiver.Type == type;
bool isCorrectAssembly = string.Compare(eventReceiver.Assembly, assemblyFullName, StringComparison.OrdinalIgnoreCase) == 0;
bool isCorrectClass = string.Compare(eventReceiver.Class, classFullName, StringComparison.OrdinalIgnoreCase) == 0;
if (isCorrectType && isCorrectAssembly && isCorrectClass)
{
return eventReceiver;
}
}
return null;
}
// Uncomment the method below to handle the event raised before a feature is deactivated.
public override void FeatureDeactivating(SPFeatureReceiverProperties properties)
{
using (SPSite site = properties.Feature.Parent as SPSite)
{
using (SPWeb web = site.RootWeb)
{
SPList oList = web.Lists[Constants.WebRegistry.ListTitle];
const SPEventReceiverType _eventType = SPEventReceiverType.ItemAdding;
const SPEventReceiverType _eventType2 = SPEventReceiverType.ItemDeleting;
const SPEventReceiverType _eventType3 = SPEventReceiverType.ItemUpdating;
for (int i = oList.EventReceivers.Count - 1; i >= 0; i--)
{
if (oList.EventReceivers[i].Type.Equals(_eventType) || oList.EventReceivers[i].Type.Equals(_eventType2) || oList.EventReceivers[i].Type.Equals(_eventType3))
{
try
{
oList.EventReceivers[i].Delete();
}
catch (Exception e)
{
Logger.WriteLog(Logger.Category.High, "DevyatkinEventReceiver", e.ToString());
}
}
}
SPList list = web.Lists.TryGetList(Constants.WebRegistry.ListTitle);
web.Lists.Delete(list.ID);
}
}
}
/// <summary>
/// Event Receiver Info (Content Type)
/// </summary>
/// <param name="contentType">The content type</param>
/// <param name="type">The event receiver type</param>
/// <param name="syncType">The synchronization type</param>
public EventReceiverInfo(ContentTypeInfo contentType, SPEventReceiverType type, SPEventReceiverSynchronization syncType)
{
this.ContentType = contentType;
this.ReceiverType = type;
this.EventOwner = EventReceiverOwner.ContentType;
this.SynchronizationType = syncType;
}
/// <summary>
/// Event Receiver Info (Content Type)
/// </summary>
/// <param name="contentType">The content type</param>
/// <param name="type">The event receiver type</param>
/// <param name="syncType">The synchronization type</param>
public EventReceiverInfo(ContentTypeInfo contentType, SPEventReceiverType type, SPEventReceiverSynchronization syncType)
{
this.ContentType = contentType;
this.ReceiverType = type;
this.EventOwner = EventReceiverOwner.ContentType;
this.SynchronizationType = syncType;
}
public static void Register(SPList list, SPEventReceiverType eventType, SPEventReceiverSynchronization synchronization, int sequenceNumber, string className)
{
if (!IsRegistered(list, eventType, className))
{
list.ParentWeb.AllowUnsafeUpdates = true;
var assemblyName = typeof(IronItemEventReceiver).Assembly.FullName;
var typeName = typeof(IronItemEventReceiver).FullName;
var receiver = list.EventReceivers.Add();
receiver.Type = eventType;
receiver.Assembly = assemblyName;
receiver.Synchronization = synchronization;
receiver.HostType = SPEventHostType.List;
receiver.HostId = list.ID;
receiver.Class = typeName;
receiver.Name = className;
receiver.Data = className;
receiver.SequenceNumber = sequenceNumber;
receiver.Update();
list.Update();
list.ParentWeb.AllowUnsafeUpdates = false;
}
}
private SPEventReceiverDefinition AddEventReceiverDefinition(SPList list, SPEventReceiverType type, string assemblyName, string className, SPEventReceiverSynchronization syncType, int sequenceNumber)
{
SPEventReceiverDefinition eventReceiverDefinition = null;
// Try Parse the Assembly Name
var classType = Type.GetType(string.Format(CultureInfo.InvariantCulture, "{0}, {1}", className, assemblyName));
if (classType != null)
{
var assembly = Assembly.GetAssembly(classType);
var isAlreadyDefined = list.EventReceivers.Cast <SPEventReceiverDefinition>().Any(x => (x.Class == className) && (x.Type == type));
// If definition isn't already defined, add it to the list
if (!isAlreadyDefined)
{
eventReceiverDefinition = list.EventReceivers.Add();
eventReceiverDefinition.Type = type;
eventReceiverDefinition.Assembly = assembly.FullName;
eventReceiverDefinition.Synchronization = syncType;
eventReceiverDefinition.Class = className;
eventReceiverDefinition.SequenceNumber = sequenceNumber;
eventReceiverDefinition.Update();
list.Update();
}
}
return(eventReceiverDefinition);
}
public ListDefinition AndEvent <TEventClass>(SPEventReceiverType eventType)
{
if (!events.ContainsKey(eventType))
{
events.Add(eventType, typeof(TEventClass));
}
return(this);
}
/// <summary>
/// Event Receiver Info (Content Type)
/// </summary>
/// <param name="contentType">The content type</param>
/// <param name="type">The event receiver type</param>
/// <param name="syncType">The synchronization type</param>
/// <param name="assemblyName">The full name of the Assembly</param>
/// <param name="className">The fullname of the Type/Class </param>
public EventReceiverInfo(ContentTypeInfo contentType, SPEventReceiverType type, SPEventReceiverSynchronization syncType, string assemblyName, string className)
{
this.ContentType = contentType;
this.ReceiverType = type;
this.SynchronizationType = syncType;
this.AssemblyName = assemblyName;
this.ClassName = className;
}
/// <summary>
/// Event Receiver Info (Content Type)
/// </summary>
/// <param name="contentType">The content type</param>
/// <param name="type">The event receiver type</param>
/// <param name="syncType">The synchronization type</param>
/// <param name="assemblyName">The full name of the Assembly</param>
/// <param name="className">The fullname of the Type/Class </param>
public EventReceiverInfo(ContentTypeInfo contentType, SPEventReceiverType type, SPEventReceiverSynchronization syncType, string assemblyName, string className)
{
this.ContentType = contentType;
this.ReceiverType = type;
this.SynchronizationType = syncType;
this.AssemblyName = assemblyName;
this.ClassName = className;
}
/// <summary>
/// Event Receiver Info (List)
/// </summary>
/// <param name="list">The list</param>
/// <param name="type">The event receiver type</param>
/// <param name="syncType">The synchronization type</param>
/// <param name="assemblyName">The full name of the Assembly</param>
/// <param name="className">The fullname of the Type/Class </param>
public EventReceiverInfo(ListInfo list, SPEventReceiverType type, SPEventReceiverSynchronization syncType, string assemblyName, string className)
{
this.List = list;
this.ReceiverType = type;
this.SynchronizationType = syncType;
this.AssemblyName = assemblyName;
this.ClassName = className;
}
public static void Unregister(SPList list, SPEventReceiverType eventType, string className)
{
var receiver = list.EventReceivers.OfType <SPEventReceiverDefinition>().FirstOrDefault(e => e.Class == className && (e.Type & eventType) == eventType);
if (receiver != null)
{
receiver.Delete();
}
}
public static void Unregister(SPContentType ct, SPEventReceiverType eventType, string className, bool updateChildren)
{
var receiver = ct.EventReceivers.OfType <SPEventReceiverDefinition>().FirstOrDefault(e => e.Class == className && (e.Type & eventType) == eventType);
if (receiver != null)
{
receiver.Delete();
ct.Update(updateChildren);
}
}
private void AddEventReceiverToWeb(SPWeb currentWeb, SPEventReceiverType type)
{
SPEventReceiverDefinition def = currentWeb.EventReceivers.Add();
def.Name = "Web Event Receiver - " + type.ToString();
def.Type = type;
def.Assembly = Assembly.GetExecutingAssembly().FullName;
def.Class = eventRcvClass;
def.Update();
currentWeb.Update();
}
/// <summary>
/// This method is fake. All the parameters are required, even though not all of them are used
/// </summary>
private void AddEventReceiver(
EventReceiverManager eventReceiver,
SPList list,
string assembly,
string className,
SPEventReceiverType type,
ref XElement element)
{
element.Add(DummyString);
AddEventReceiverWasCalled = true;
}
public bool HasEventReceiver(SPList taskList, SPEventReceiverType type, string assembly, string className)
{
string assemblyLow = assembly.ToLowerInvariant();
string classNameLow = className.ToLowerInvariant();
Func <SPEventReceiverDefinition, bool> predicate = er => er.Assembly.ToLowerInvariant() == assemblyLow &&
er.Class.ToLowerInvariant() == classNameLow &&
er.Type == type;
return(taskList.EventReceivers.Cast <SPEventReceiverDefinition>().Any(predicate));
}
//public static List<SPFile> GetRelateddocuments(this SPListItem item)
//{
// List<SPFile> listFile = new List<SPFile>();
// string contractNumberFieldName = item.Web.Site.GetFeaturePropertyValue(Constants.Workflow.INTEL_WF_FEATURE_ID, Constants.Workflow.CONTRACT_NUMBER_FIELD_NAME);
// if (string.IsNullOrEmpty(contractNumberFieldName) || !item.Fields.ContainsField(contractNumberFieldName))
// return null;
// if (item[contractNumberFieldName] == null) return null;
// string contentTypeFieldName = item.Web.Site.GetFeaturePropertyValue(Constants.Workflow.INTEL_WF_FEATURE_ID, Constants.Workflow.CONTENT_TYPE_FIELD_NAME);
// if (string.IsNullOrEmpty(contentTypeFieldName) || !item.Web.Site.RootWeb.AvailableFields.ContainsField(contentTypeFieldName))
// return null;
// string includeWithDeliveryFieldName = item.Web.Site.GetFeaturePropertyValue(Constants.Workflow.INTEL_WF_FEATURE_ID, Constants.Workflow.INCLUDE_WITH_DELIVERY_FIELD_NAME);
// if (string.IsNullOrEmpty(includeWithDeliveryFieldName) || !item.Web.Site.RootWeb.AvailableFields.ContainsField(includeWithDeliveryFieldName))
// return null;
// string relatedContractNumberFieldName = item.Web.Site.GetFeaturePropertyValue(Constants.Workflow.INTEL_WF_FEATURE_ID, Constants.Workflow.RELATED_CONTRACT_NUMBER_FIELD_NAME);
// if (string.IsNullOrEmpty(relatedContractNumberFieldName) || !item.Web.Site.RootWeb.AvailableFields.ContainsField(relatedContractNumberFieldName))
// return null;
// SPField contractNumberField = item.Fields[contractNumberFieldName];
// SPField contentTypeField = item.Web.Site.RootWeb.AvailableFields[contentTypeFieldName];
// SPField includeWithDeliveryField = item.Web.Site.RootWeb.AvailableFields[includeWithDeliveryFieldName];
// SPField relatedContractNumberField = item.Web.Site.RootWeb.AvailableFields[relatedContractNumberFieldName];
// SearchCriteria criteriaContentType = new SearchCriteria();
// criteriaContentType.FieldId = contentTypeField.Id.ToString();
// criteriaContentType.FieldType = contentTypeField.Type;
// criteriaContentType.Operator = Operators.Equal;
// criteriaContentType.Value = "Attachment";
// SearchCriteria criteriaIncludeWithDelivery = new SearchCriteria();
// criteriaIncludeWithDelivery.FieldId = includeWithDeliveryField.Id.ToString();
// criteriaIncludeWithDelivery.FieldType = includeWithDeliveryField.Type;
// criteriaIncludeWithDelivery.Operator = Operators.Equal;
// criteriaIncludeWithDelivery.Value = "1";
// SearchCriteria criteriaRelatedContractNumber = new SearchCriteria();
// criteriaRelatedContractNumber.FieldId = relatedContractNumberField.Id.ToString();
// criteriaRelatedContractNumber.FieldType = relatedContractNumberField.Type;
// criteriaRelatedContractNumber.Operator = Operators.Equal;
// criteriaRelatedContractNumber.Value = item[contractNumberFieldName].ToString();
// List<SearchCriteria> searchCriteriaList = new List<SearchCriteria>();
// searchCriteriaList.Add(criteriaContentType);
// searchCriteriaList.Add(criteriaIncludeWithDelivery);
// searchCriteriaList.Add(criteriaRelatedContractNumber);
// SearchDefinition searchDefinition = new SearchDefinition();
// searchDefinition.UseGlobalOperatorOR = false;
// searchDefinition.SearchCriteriaList = searchCriteriaList;
// FieldSetting contractNumberFieldResult = new FieldSetting();
// contractNumberFieldResult.FieldId = contractNumberField.Id.ToString();
// List<FieldSetting> resultFields = new List<FieldSetting>();
// resultFields.Add(contractNumberFieldResult);
// string strCAML = CAMLHelper.GetCAMLQueryFromSearchDefinition(searchDefinition);
// SPSiteDataQuery dataQuery = new SPSiteDataQuery();
// dataQuery.Query = strCAML;
// dataQuery.Lists = CAMLHelper.GetCAMLListBaseTypeSearch(SearchListBaseType.DocumentLibrary);
// dataQuery.ViewFields = CAMLHelper.GetCAMLFieldsResult(item.Web, null, resultFields);
// dataQuery.Webs = CAMLHelper.GetCAMLScopeSearch(0);
// try
// {
// DataTable searchResultsData = null;
// searchResultsData = item.Web.GetSiteData(dataQuery);
// foreach (DataRow row in searchResultsData.Rows)
// {
// SPList list = item.Web.Lists.GetList(new Guid(row["ListId"].ToString()), false);
// SPListItem itemGet = list.GetItemById(Convert.ToInt32(row["ID"].ToString()));
// if (itemGet.File != null)
// listFile.Add(itemGet.File);
// }
// }
// catch { }
// return listFile;
//}
public static void AddEventReceiver(this SPList list, string eventName, SPEventReceiverType type, string assemblyName, string className)
{
SPEventReceiverDefinition eventDefinition = list.EventReceivers.Add();
eventDefinition.Name = eventName;
eventDefinition.Type = type;
eventDefinition.Synchronization = SPEventReceiverSynchronization.Synchronous;
eventDefinition.Assembly = assemblyName;
eventDefinition.Class = className;
eventDefinition.Update();
}
public void DeleteEventReceiverDefinition(SPContentType contentType, SPEventReceiverType type, string className)
{
var eventReceiverDefinition = contentType.EventReceivers.Cast<SPEventReceiverDefinition>().FirstOrDefault(x => (x.Class == className) && (x.Type == type));
// If definition isn't already defined, add it to the content type
if (eventReceiverDefinition != null)
{
var eventToDelete = contentType.EventReceivers.Cast<SPEventReceiverDefinition>().Where(eventReceiver => eventReceiver.Type == eventReceiverDefinition.Type).ToList();
eventToDelete.ForEach(c => c.Delete());
contentType.Update(true);
}
}
public void UnlinkEventHandlerToList(string assemblyName, string className, string aspEventReceiverType)
{
try
{
var obj = new Helper(SiteUrl, WebUrl, ListName);
SPList list = obj.GetList();
var erdc = list.EventReceivers;
var eventsToDelete = new List <SPEventReceiverDefinition>();
SPEventReceiverType eventType = SPEventReceiverType.InvalidReceiver;
if (aspEventReceiverType == "ItemUpdated")
{
eventType = SPEventReceiverType.ItemUpdated;
}
if (aspEventReceiverType == "ItemAdded")
{
eventType = SPEventReceiverType.ItemAdded;
}
if (aspEventReceiverType == "ItemDeleting")
{
eventType = SPEventReceiverType.ItemDeleting;
}
foreach (SPEventReceiverDefinition erd in erdc)
{
if (erd != null && erd.Assembly == assemblyName && erd.Type == eventType && erd.Class == className)
{
try
{
eventsToDelete.Add(erd);
}
catch (Exception e)
{
Utilities.LogException("Error in Clist.UnlinkEventHandlerToList: " + e.Message);
}
}
}
foreach (SPEventReceiverDefinition er in eventsToDelete)
{
er.Delete();
}
}
catch (SPException ex)
{
Utilities.LogException("Error in Clist.UnlinkEventHandlerToList: " + ex.Message);
}
}
public void DeleteListEventReceiverDefinition(SPList list, SPEventReceiverType type, string className)
{
var eventReceiverDefinition = list.EventReceivers.Cast <SPEventReceiverDefinition>().FirstOrDefault(x => (x.Class == className) && (x.Type == type));
// If definition isn't already defined, add it to the content type
if (eventReceiverDefinition != null)
{
var eventToDelete = list.EventReceivers.Cast <SPEventReceiverDefinition>().Where(eventReceiver => eventReceiver.Type == eventReceiverDefinition.Type).ToList();
eventToDelete.ForEach(c => c.Delete());
list.Update();
}
}
/// <summary>
/// Adds an event receiver to the specified target
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="contentTypeName">Name of the content type.</param>
/// <param name="target">The target.</param>
/// <param name="assembly">The assembly.</param>
/// <param name="className">Name of the class.</param>
/// <param name="type">The type.</param>
/// <param name="sequence">The sequence.</param>
/// <param name="name">The name.</param>
public static void Add(string url, string contentTypeName, TargetEnum target, string assembly, string className, SPEventReceiverType type, int sequence, string name)
{
using (SPSite site = new SPSite(url))
using (SPWeb web = site.OpenWeb())
{
SPContentType contentType = null;
SPEventReceiverDefinitionCollection eventReceivers;
if (target == TargetEnum.List)
{
SPList list = Utilities.GetListFromViewUrl(web, url);
if (list == null)
{
throw new Exception("List not found.");
}
eventReceivers = list.EventReceivers;
}
else if (target == TargetEnum.Site)
eventReceivers = web.EventReceivers;
else
{
try
{
contentType = web.AvailableContentTypes[contentTypeName];
}
catch (ArgumentException)
{
}
if (contentType == null)
throw new SPSyntaxException("The specified content type could not be found.");
eventReceivers = contentType.EventReceivers;
}
SPEventReceiverDefinition def = Add(eventReceivers, type, assembly, className, name);
if (sequence >= 0)
{
def.SequenceNumber = sequence;
def.Update();
}
if (contentType != null)
{
try
{
contentType.Update((contentType.ParentList == null));
}
catch (Exception ex)
{
Exception ex1 = new Exception("An error occured updating the content type. Most likely the content type was updated but changes may not have been pushed down to any children.", ex);
Logger.WriteException(new ErrorRecord(ex1, null, ErrorCategory.NotSpecified, contentType));
}
}
}
}
/// <summary>
/// Log the event to the specified list
/// </summary>
/// <param name="web"></param>
/// <param name="listName"></param>
/// <param name="eventType"></param>
/// <param name="details"></param>
public static void LogEvent(SPWeb web, string listName, SPEventReceiverType eventType, string details)
{
SPList logList = Common.EnsureLogList(web, listName);
SPListItem logItem = logList.Items.Add();
logItem["Title"] = string.Format("{0} triggered at {1}", eventType, DateTime.Now);
logItem["Event"] = eventType.ToString();
logItem["Before"] = Common.IsBeforeEvent(eventType);
logItem["Date"] = DateTime.Now;
logItem["Details"] = details;
logItem.Update();
}
//Invoke Added/Updated/Deleted receivers
private void InvokeEdReceiver(SPItemEventProperties properties, SPEventReceiverType eventReceiverType, string methodName)
{
try
{
var receiverProps = GetEventReceiverType(properties, eventReceiverType);
var receiver = Activator.CreateInstance(receiverProps.EventReceiverType);
SetParentWeb(receiver, properties.Web);
var method = receiverProps.EventReceiverType.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public);
var receiverParam = method.GetParameters().First();
var eventDisabled = GetEventFiringDisabled(method);
bool origDisabledValue = false;
try
{
if (eventDisabled)
{
origDisabledValue = base.EventFiringEnabled;
base.EventFiringEnabled = false;
}
switch (eventReceiverType)
{
case SPEventReceiverType.ItemDeleted:
method.Invoke(receiver, new[] { (object)properties.ListItemId });
break;
default:
var entityType = EntityMapper.ToEntity(receiverParam.ParameterType, properties.ListItem);
method.Invoke(receiver, new[] { entityType });
break;
}
}
finally
{
if (eventDisabled)
{
base.EventFiringEnabled = origDisabledValue;
}
}
ProccessCancel(receiver, properties);
}
catch (TargetInvocationException tex)
{
throw tex.InnerException;
}
}
/// <summary>
/// Removes the event receiver.
/// </summary>
/// <param name="spList">The sp list.</param>
/// <param name="assembly">The assembly.</param>
/// <param name="className">Name of the class.</param>
/// <param name="spEventReceiverType">Type of the sp event receiver.</param>
/// <param name="eventReceiverElement">The event receiver element.</param>
private void RemoveEventReceiver(SPList spList, string assembly, string className,
SPEventReceiverType spEventReceiverType, ref XElement eventReceiverElement)
{
var eventElement = new XElement("EventReceiver", new XAttribute("Type", spEventReceiverType.ToString()),
new XAttribute("Assembly", assembly), new XAttribute("Class", className),
new XAttribute("SiteId", spList.ParentWeb.Site.ID),
new XAttribute("WebId", spList.ParentWeb.ID),
new XAttribute("ListId", spList.ID),
new XAttribute("Status", 0));
bool found = false;
var events = new List <SPEventReceiverDefinition>();
foreach (SPEventReceiverDefinition spEventReceiverDefinition in
spList.EventReceivers.Cast <SPEventReceiverDefinition>()
.Where(spEventReceiverDefinition =>
spEventReceiverDefinition.Assembly.Equals(assembly) &&
spEventReceiverDefinition.Class.Equals(className) &&
spEventReceiverDefinition.Type == spEventReceiverType))
{
found = true;
events.Add(spEventReceiverDefinition);
}
if (found)
{
foreach (SPEventReceiverDefinition spEventReceiverDefinition in events)
{
spEventReceiverDefinition.Delete();
}
spList.Update();
eventElement.SetValue("Event receiver successfully uninstalled.");
}
else
{
// ReSharper disable PossibleNullReferenceException
eventElement.Attribute("Status").SetValue(1);
// ReSharper restore PossibleNullReferenceException
eventElement.SetValue("Operation not performed. Event receiver was not found.");
}
eventReceiverElement.Add(new XElement("Data", eventElement));
}
private static void AddReceiverToList(SPList list, string rName, SPEventReceiverType rType, int seq)
{
if (!list.EventReceivers.Cast <SPEventReceiverDefinition>().Any(r => r.Name == rName))
{
SPEventReceiverDefinition _def = list.EventReceivers.Add();
_def.Assembly = Assembly.GetExecutingAssembly().FullName;
_def.Class = "Roster.Presentation.EventReceivers.SyncDataReceiver";
_def.Name = rName;
_def.Type = rType;
_def.SequenceNumber = seq;
_def.Synchronization = SPEventReceiverSynchronization.Default;
_def.Update();
}
}
// 取消对以下方法的注释，以便处理激活某个功能后引发的事件。
public override void FeatureActivated(SPFeatureReceiverProperties properties)
{
SPWeb oWeb = (SPWeb)properties.Feature.Parent;
SPEventReceiverType _eventType = SPEventReceiverType.ItemUpdated;
foreach (SPList myList in oWeb.Lists)
{
if (myList.Title.ToLower().Contains("task") || myList.Title.Contains("任务"))
{
oWeb.Lists[myList.Title].EventReceivers.Add(_eventType, Assembly.GetExecutingAssembly().FullName, "TaskEventHandler.TaskEventReceiver");
oWeb.Lists[myList.Title].Update();
}
}
}
/// <summary>
/// ��ȡ�¼�����������
/// </summary>
/// <param name="list"></param>
/// <param name="t"></param>
/// <param name="eventType"></param>
/// <returns></returns>
public static SPEventReceiverDefinition GetEventDefinition(SPList list, Type t, SPEventReceiverType eventType)
{
string assambly = t.Assembly.FullName;
string className = t.FullName;
for (int i = list.EventReceivers.Count - 1; i >= 0; i--)
{
SPEventReceiverDefinition def = list.EventReceivers[i];
if (def.Class == className && def.Type == eventType)
return def;
}
return null;
}
/// <summary>
/// Adds the event handler to the content type.
/// </summary>
/// <param name="contentType">The content type.</param>
/// <param name="name">The name of the event.</param>
/// <param name="receiver">The type reference of the event receiver class.</param>
/// <param name="type">The event receiver type.</param>
/// <param name="sequence">The sequence.</param>
/// <param name="sync">The synchronization type.</param>
public void AddEventHandler(
SPContentType contentType,
string name,
Type receiver,
SPEventReceiverType type,
int sequence,
SPEventReceiverSynchronization sync)
{
// Guard
if (receiver == null)
{
throw new ArgumentNullException("receiver");
}
AddEventHandler(contentType, name, receiver.Assembly.FullName, receiver.FullName, type, sequence, sync);
}
public static void Register(this SPEventReceiverDefinitionCollection collection, string name, Type receiverType, SPEventReceiverType actionsToHandle, SPEventReceiverSynchronization synchronization = SPEventReceiverSynchronization.Synchronous, int sequenceNumber = 11000)
{
SPEventReceiverDefinition receiverDefinition = collection.Cast<SPEventReceiverDefinition>()
.SingleOrDefault(receiver => string.Equals(receiver.Name, name));
if (receiverDefinition == null)
{
receiverDefinition = collection.Add();
receiverDefinition.Name = name;
receiverDefinition.Synchronization = synchronization;
receiverDefinition.Type = actionsToHandle;
receiverDefinition.SequenceNumber = sequenceNumber;
receiverDefinition.Assembly = receiverType.Assembly.ToString();
receiverDefinition.Class = receiverType.FullName;
receiverDefinition.Update();
}
}
public virtual SPEventReceiverDefinition RegisterEventReceiver(SPEventReceiverDefinitionCollection collection, string eventReceiverName, string assembly, string className, SPEventReceiverType type, SPEventReceiverSynchronization sync, int? sequenceNumber)
{
var result = collection.Add();
result.Name = eventReceiverName;
result.Assembly = assembly;
result.Class = className;
result.Type = type;
result.Synchronization = sync;
if (sequenceNumber.HasValue)
result.SequenceNumber = sequenceNumber.Value;
result.Update();
return result;
}
/// <summary>
/// Register even receiver for content Type
/// </summary>
/// <param name="contentType">Content type need to register</param>
/// <param name="eventReceiverType">Type of Content Type</param>
/// <param name="receiverClassType">Type of class event receiver</param>
public static void RegisterEventReceiver(SPContentType contentType, SPEventReceiverType eventReceiverType, Type receiverClassType)
{
if (contentType == null)
{
return;
}
try
{
// unRegister Event Receiver first
UnRegisterEventReceiver(contentType, eventReceiverType);
contentType.EventReceivers.Add(eventReceiverType, receiverClassType.Assembly.FullName, receiverClassType.FullName);
contentType.Update(true);
}
catch (Exception ex)
{
ULSLogging.LogError(ex);
}
}
/// <summary>
/// Gets a specific event handler.
/// </summary>
/// <param name="sperdcol">The event receiver definitions.</param>
/// <param name="className">The event receiver class name.</param>
/// <param name="type">The event type.</param>
/// <returns>The existing event handler or <c>null</c> if the event handler was not found.</returns>
private static SPEventReceiverDefinition GetEventHandler(
SPEventReceiverDefinitionCollection sperdcol, string className, SPEventReceiverType type)
{
if (sperdcol == null)
{
throw new ArgumentNullException("sperdcol");
}
for (int i = 0; i < sperdcol.Count; i++)
{
SPEventReceiverDefinition definition = sperdcol[i];
if ((definition.Type == type) && (definition.Class == className))
{
return definition;
}
}
return null;
}
/// <summary>
/// Runs the specified command.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="keyValues">The key values.</param>
/// <param name="output">The output.</param>
/// <returns></returns>
public override int Execute(string command, StringDictionary keyValues, out string output)
{
output = string.Empty;
string url = Params["url"].Value.TrimEnd('/');
Common.Lists.AddEventReceiver.TargetEnum target = (Common.Lists.AddEventReceiver.TargetEnum)Enum.Parse(typeof(Common.Lists.AddEventReceiver.TargetEnum), Params["target"].Value, true);
SPEventReceiverType type = (SPEventReceiverType)Enum.Parse(typeof(SPEventReceiverType), Params["type"].Value, true);
string assembly = Params["assembly"].Value;
string className = Params["class"].Value;
string contentTypeName = Params["contenttype"].Value;
string name = Params["name"].Value;
int sequence = -1;
if (Params["sequence"].UserTypedIn)
{
sequence = int.Parse(Params["sequence"].Value);
}
Common.Lists.AddEventReceiver.Add(url, contentTypeName, target, assembly, className, type, sequence, name);
return((int)ErrorCodes.NoError);
}
public static void Register(SPContentType ct, SPEventReceiverType eventType, SPEventReceiverSynchronization synchronization, int sequenceNumber, string className, bool updateChildren)
{
if (!IsRegistered(ct, eventType, className))
{
ct.ParentWeb.AllowUnsafeUpdates = true;
var assemblyName = typeof(IronItemEventReceiver).Assembly.FullName;
var typeName = typeof(IronItemEventReceiver).FullName;
var receiver = ct.EventReceivers.Add();
receiver.Type = eventType;
receiver.Assembly = assemblyName;
receiver.Synchronization = synchronization;
receiver.Class = typeName;
receiver.Name = className;
receiver.Data = className;
receiver.SequenceNumber = sequenceNumber;
receiver.Update();
ct.Update(updateChildren);
ct.ParentWeb.AllowUnsafeUpdates = false;
}
}
/// <summary>
/// UnRegister Event Receiver
/// </summary>
/// <param name="contentType">Content Type need to unregister</param>
/// <param name="eventReceiverType">Receiver Type</param>
public static void UnRegisterEventReceiver(SPContentType contentType, SPEventReceiverType eventReceiverType)
{
if (contentType == null)
{
return;
}
try
{
for (var i = 0; i < contentType.EventReceivers.Count; i++)
{
var receiver = contentType.EventReceivers[i];
if (receiver.Type.Equals(eventReceiverType))
{
receiver.Delete();
break;
}
}
}
catch (Exception ex)
{
ULSLogging.LogError(ex);
}
}
// Uncomment the method below to handle the event raised after a feature has been activated.
public override void FeatureActivated(SPFeatureReceiverProperties properties)
{
using (SPSite site = properties.Feature.Parent as SPSite)
{
using (SPWeb web = site.RootWeb)
{
SPList webRegistry = web.Lists.TryGetList(Constants.WebRegistry.ListTitle);
if (webRegistry != null)
{
const SPEventReceiverType _eventType = SPEventReceiverType.ItemAdding;
web.Lists[Constants.WebRegistry.ListTitle].EventReceivers.Add(_eventType, Assembly.GetExecutingAssembly().FullName, "Devyatkin.TracingCreationSites.EventRecivers.WebRegistryEventReceiver.WebRegistryEventReceiver");
const SPEventReceiverType _eventType2 = SPEventReceiverType.ItemDeleting;
web.Lists[Constants.WebRegistry.ListTitle].EventReceivers.Add(_eventType2, Assembly.GetExecutingAssembly().FullName, "Devyatkin.TracingCreationSites.EventRecivers.WebRegistryEventReceiver.WebRegistryEventReceiver");
const SPEventReceiverType _eventType3 = SPEventReceiverType.ItemUpdating;
web.Lists[Constants.WebRegistry.ListTitle].EventReceivers.Add(_eventType3, Assembly.GetExecutingAssembly().FullName, "Devyatkin.TracingCreationSites.EventRecivers.WebRegistryEventReceiver.WebRegistryEventReceiver");
}
else
{
//throw new Exception("WebRegistryList Error");
Logger.WriteLog(Logger.Category.Unexpected, "Devyatkin.TracingCreationSites.Features.Devyatkin.TracingCreationSites_Feature", "Error in feature activating");
}
}
}
}
/// <summary>
/// Adds the event handler to the content type.
/// </summary>
/// <param name="contentType">The content type.</param>
/// <param name="name">The name of the event.</param>
/// <param name="receiver">The type reference of the event receiver class.</param>
/// <param name="type">The event receiver type.</param>
/// <param name="sequence">The sequence.</param>
/// <param name="sync">The synchronization type.</param>
public static void AddEventHandler(
SPContentType contentType,
string name,
Type receiver,
SPEventReceiverType type,
int sequence,
SPEventReceiverSynchronization sync)
{
// Guard
if (receiver == null)
{
throw new ArgumentNullException("receiver");
}
AddEventHandler(contentType, name, receiver.Assembly.FullName, receiver.FullName, type, sequence, sync);
}
private SPEventReceiverDefinition AddEventReceiverDefinition(SPContentType contentType, SPEventReceiverType type, Assembly assembly, string className, SPEventReceiverSynchronization syncType)
{
SPEventReceiverDefinition eventReceiverDefinition = null;
var isAlreadyDefined = contentType.EventReceivers.Cast<SPEventReceiverDefinition>()
.Any(x => (x.Class == className) && (x.Type == type));
// If definition isn't already defined, add it to the content type
if (!isAlreadyDefined)
{
eventReceiverDefinition = contentType.EventReceivers.Add();
eventReceiverDefinition.Type = type;
eventReceiverDefinition.Assembly = assembly.FullName;
eventReceiverDefinition.Synchronization = syncType;
eventReceiverDefinition.Class = className;
eventReceiverDefinition.Update();
contentType.Update(true);
}
return eventReceiverDefinition;
}
public virtual void UpdateEventReceiver(SPEventReceiverDefinition eventReceiver, string eventReceiverName, string assembly, string className, SPEventReceiverType type, SPEventReceiverSynchronization sync, int? sequenceNumber)
{
eventReceiver.Name = eventReceiverName;
eventReceiver.Assembly = assembly;
eventReceiver.Class = className;
eventReceiver.Synchronization = sync;
if (sequenceNumber.HasValue)
eventReceiver.SequenceNumber = sequenceNumber.Value;
eventReceiver.Update();
}
static void AddEventReceiver(SPContentType contentType, SPEventReceiverType type, Type target, int sequenceNumber)
{
// Remove event receiver it is already attached
RemoveEventReceiver(contentType, type, target);
// Add event receiver
var eventReceiver = contentType.EventReceivers.Add();
eventReceiver.Type = type;
eventReceiver.Assembly = target.Assembly.FullName;
eventReceiver.Class = target.FullName;
eventReceiver.SequenceNumber = sequenceNumber;
eventReceiver.Update();
contentType.Update(true, false);
}
/// <summary>
/// Event Receiver Info (List)
/// </summary>
/// <param name="list">The list</param>
/// <param name="type">The event receiver type</param>
public EventReceiverInfo(ListInfo list, SPEventReceiverType type)
: this(list, type, SPEventReceiverSynchronization.Default)
{
}
/// <summary>
/// Event Receiver Info (Content Type)
/// </summary>
/// <param name="contentType">The content type</param>
/// <param name="type">The event receiver type</param>
public EventReceiverInfo(ContentTypeInfo contentType, SPEventReceiverType type)
: this(contentType, type, SPEventReceiverSynchronization.Default)
{
}
public static void AddEventReceiverToContentType(string className, SPContentType contentType, string assemblyName, SPEventReceiverType eventReceiverType, SPEventReceiverSynchronization eventReceiverSynchronization)
{
className.RequireNotNullOrEmpty("className");
contentType.RequireNotNull("contentType");
assemblyName.RequireNotNullOrEmpty("assemblyName");
eventReceiverType.RequireNotNull("eventReceiverType");
eventReceiverSynchronization.RequireNotNull("eventReceiverSynchronization");
SPEventReceiverDefinition eventReceiver = contentType.EventReceivers.Add();
eventReceiver.Synchronization = eventReceiverSynchronization;
eventReceiver.Type = eventReceiverType;
eventReceiver.Assembly = assemblyName;
eventReceiver.Class = className;
eventReceiver.Update();
}
private SPEventReceiverDefinition AddEventReceiverDefinition(SPList list, SPEventReceiverType type, string assemblyName, string className, SPEventReceiverSynchronization syncType, int sequenceNumber)
{
SPEventReceiverDefinition eventReceiverDefinition = null;
// Try Parse the Assembly Name
var classType = Type.GetType(string.Format(CultureInfo.InvariantCulture, "{0}, {1}", className, assemblyName));
if (classType != null)
{
var assembly = Assembly.GetAssembly(classType);
var isAlreadyDefined = list.EventReceivers.Cast<SPEventReceiverDefinition>().Any(x => (x.Class == className) && (x.Type == type));
// If definition isn't already defined, add it to the list
if (!isAlreadyDefined)
{
eventReceiverDefinition = list.EventReceivers.Add();
eventReceiverDefinition.Type = type;
eventReceiverDefinition.Assembly = assembly.FullName;
eventReceiverDefinition.Synchronization = syncType;
eventReceiverDefinition.Class = className;
eventReceiverDefinition.SequenceNumber = sequenceNumber;
eventReceiverDefinition.Update();
list.Update();
}
}
return eventReceiverDefinition;
}
/// <summary>
/// Event Receiver Info (List)
/// </summary>
/// <param name="list">The list</param>
/// <param name="type">The event receiver type</param>
/// <param name="syncType">The synchronization type</param>
/// <param name="assemblyName">The full name of the Assembly</param>
/// <param name="className">The fullname of the Type/Class </param>
public EventReceiverInfo(ListInfo list, SPEventReceiverType type, SPEventReceiverSynchronization syncType, string assemblyName, string className)
{
this.List = list;
this.ReceiverType = type;
this.SynchronizationType = syncType;
this.AssemblyName = assemblyName;
this.ClassName = className;
}
/// <summary>
/// Adds an event receiver to a the specified event receiver definition collection.
/// </summary>
/// <param name="eventReceivers">The event receivers.</param>
/// <param name="eventReceiverType">Type of the event receiver.</param>
/// <param name="assembly">The assembly.</param>
/// <param name="className">Name of the class.</param>
/// <param name="name">The name.</param>
/// <returns></returns>
public static SPEventReceiverDefinition Add(SPEventReceiverDefinitionCollection eventReceivers, SPEventReceiverType eventReceiverType, string assembly, string className, string name)
{
SPEventReceiverDefinition def = GetEventReceiver(eventReceivers, eventReceiverType, assembly, className);
if (def == null)
{
eventReceivers.Add(eventReceiverType, assembly, className);
def = GetEventReceiver(eventReceivers, eventReceiverType, assembly, className);
if (def != null && !String.IsNullOrEmpty(name))
{
def.Name = name;
def.Update();
}
return def;
}
return def;
}
/// <summary>
/// Adds the event handler to the content type.
/// </summary>
/// <param name="contentType">The content type.</param>
/// <param name="name">The name of the event.</param>
/// <param name="assembly">The assembly containing the event receiver.</param>
/// <param name="className">Name of the event receiver class.</param>
/// <param name="type">The event receiver type.</param>
/// <param name="sequence">The sequence.</param>
/// <param name="sync">The synchronization type.</param>
public static void AddEventHandler(
SPContentType contentType,
string name,
string assembly,
string className,
SPEventReceiverType type,
int sequence,
SPEventReceiverSynchronization sync)
{
// Guard
if (contentType == null)
{
throw new ArgumentNullException("contentType");
}
SPEventReceiverDefinition definition = GetEventHandler(contentType.EventReceivers, name, type);
if (definition == null)
{
contentType.EventReceivers.Add(type, assembly, className);
definition = GetEventHandler(contentType.EventReceivers, className, type);
}
definition.Name = name;
definition.SequenceNumber = sequence;
definition.Synchronization = sync;
definition.Update();
}
/// <summary>
/// Gets a specific event handler.
/// </summary>
/// <param name="sperdcol">The event receiver definitions.</param>
/// <param name="className">The event receiver class name.</param>
/// <param name="type">The event type.</param>
/// <returns>The existing event handler or <c>null</c> if the event handler was not found.</returns>
private static SPEventReceiverDefinition GetEventHandler(
SPEventReceiverDefinitionCollection sperdcol, string className, SPEventReceiverType type)
{
if (sperdcol == null)
{
throw new ArgumentNullException("sperdcol");
}
for (int i = 0; i < sperdcol.Count; i++)
{
SPEventReceiverDefinition definition = sperdcol[i];
if ((definition.Type == type) && (definition.Class == className))
{
return definition;
}
}
return null;
}
/// <summary>
/// Gets the event receiver.
/// </summary>
/// <param name="eventReceivers">The event receivers.</param>
/// <param name="eventReceiverType">Type of the event receiver.</param>
/// <param name="assembly">The assembly.</param>
/// <param name="className">Name of the class.</param>
/// <returns></returns>
private static SPEventReceiverDefinition GetEventReceiver(SPEventReceiverDefinitionCollection eventReceivers, SPEventReceiverType eventReceiverType, string assembly, string className)
{
foreach (SPEventReceiverDefinition erd in eventReceivers)
{
if (erd.Assembly.ToLower() == assembly.ToLower() && erd.Class.ToLower() == className.ToLower() && erd.Type == eventReceiverType)
{
return erd;
}
}
return null;
}
/// <summary>
/// Event Receiver Info (Content Type)
/// </summary>
/// <param name="contentType">The content type</param>
/// <param name="type">The event receiver type</param>
/// <param name="syncType">The synchronization type</param>
public EventReceiverInfo(ContentTypeInfo contentType, SPEventReceiverType type, SPEventReceiverSynchronization syncType)
: this(contentType, type, syncType, string.Empty, string.Empty)
{
}
private bool ValidateRule(Rule r, SPListItem item, SPEventReceiverType eventType)
{
if (r.RunOnAdded && eventType == SPEventReceiverType.ItemAdded)
return true;
if (r.RunOnAnyUpdate == true &&
eventType == SPEventReceiverType.ItemUpdated &&
item.Level != SPFileLevel.Checkout)
return true;
if (r.RunOnFirstUpdate == true &&
eventType == SPEventReceiverType.ItemUpdated &&
item.Level != SPFileLevel.Checkout)
{
if (item[SPBuiltInFieldId.owshiddenversion].ToString() == "2")
{
return true;
}
}
return false;
}
/// <summary>
/// Event Receiver Info (List)
/// </summary>
/// <param name="list">The list</param>
/// <param name="type">The event receiver type</param>
/// <param name="syncType">The synchronization type</param>
public EventReceiverInfo(ListInfo list, SPEventReceiverType type, SPEventReceiverSynchronization syncType)
: this(list, type, syncType, string.Empty, string.Empty)
{
}
static void RemoveEventReceiver(SPContentType contentType, SPEventReceiverType type, Type target)
{
foreach (SPEventReceiverDefinition definition in contentType.EventReceivers)
{
if (definition.Class == target.FullName && definition.Assembly == target.Assembly.FullName && definition.Type == type)
{
definition.Delete();
contentType.Update(true, false);
break;
}
}
}
