/// <summary>
/// Registers a remote event receiver
/// </summary>
/// <param name="web">The web to process</param>
/// <param name="name">The name of the event receiver (needs to be unique among the event receivers registered on this list)</param>
/// <param name="url">The URL of the remote WCF service that handles the event</param>
/// <param name="eventReceiverType"></param>
/// <param name="synchronization"></param>
/// <param name="sequenceNumber"></param>
/// <param name="force">If True any event already registered with the same name will be removed first.</param>
/// <returns>Returns an EventReceiverDefinition if succeeded. Returns null if failed.</returns>
public static EventReceiverDefinition AddRemoteEventReceiver(this Web web, string name, string url, EventReceiverType eventReceiverType, EventReceiverSynchronization synchronization, int sequenceNumber, bool force)
{
var query = from receiver
in web.EventReceivers
where receiver.ReceiverName == name
select receiver;
web.Context.LoadQuery(query);
web.Context.ExecuteQueryRetry();
var receiverExists = query.Any();
if (receiverExists && force)
{
var receiver = query.FirstOrDefault();
receiver.DeleteObject();
web.Context.ExecuteQueryRetry();
receiverExists = false;
}
EventReceiverDefinition def = null;
if (!receiverExists)
{
EventReceiverDefinitionCreationInformation receiver = new EventReceiverDefinitionCreationInformation();
receiver.EventType = eventReceiverType;
receiver.ReceiverUrl = url;
receiver.ReceiverName = name;
receiver.SequenceNumber = sequenceNumber;
receiver.Synchronization = synchronization;
def = web.EventReceivers.Add(receiver);
web.Context.Load(def);
web.Context.ExecuteQueryRetry();
}
return(def);
}
public void GetEventReceiverTest()
{
using (var scope = new PSTestScope(true))
{
EventReceiverDefinition receiver = null;
using (var ctx = TestCommon.CreateClientContext())
{
receiver = ctx.Web.AddRemoteEventReceiver("TestEventReceiver", "https://testserver.com/testeventreceiver.svc", EventReceiverType.ListAdded, EventReceiverSynchronization.Asynchronous, true);
}
var results = scope.ExecuteCommand("Get-PnPEventReceiver");
Assert.IsTrue(results.Any());
Assert.IsTrue(results[0].BaseObject.GetType() == typeof(EventReceiverDefinition));
results = scope.ExecuteCommand("Get-PnPEventReceiver",
new CommandParameter("Identity", receiver.ReceiverId));
Assert.IsTrue(results.Any());
using (var ctx = TestCommon.CreateClientContext())
{
receiver = ctx.Web.GetEventReceiverByName("TestEventReceiver");
receiver.DeleteObject();
ctx.ExecuteQueryRetry();
}
}
}
private void DeleteReceiver(ClientContext clientContext, EventReceiverDefinition receiver)
{
try
{
Trace.WriteLine("Removing ItemAdded receiver at " + receiver.ReceiverUrl);
receiver.DeleteObject();
clientContext.ExecuteQuery();
}
catch (Exception ex)
{
Trace.TraceError(ex.Message);
Trace.TraceInformation("DeleteReceiver failed");
}
}
private static void MapEventReceiverProperties(
EventReceiverDefinition definition,
SPEventReceiverDefinition existingReceiver,
bool isNew)
{
existingReceiver.Name = definition.Name;
existingReceiver.Data = definition.Data;
if (isNew)
{
existingReceiver.Type = (SPEventReceiverType)Enum.Parse(typeof(SPEventReceiverType), definition.Type);
}
existingReceiver.Assembly = definition.Assembly;
existingReceiver.Class = definition.Class;
existingReceiver.SequenceNumber = definition.SequenceNumber;
existingReceiver.Synchronization = (SPEventReceiverSynchronization)Enum.Parse(typeof(SPEventReceiverSynchronization), definition.Synchronization);
}
private void DeployEventReceiver(object modelHost, SPEventReceiverDefinitionCollection eventReceivers,
EventReceiverDefinition definition)
{
var existingReceiver = FindEventReceiverDefinition(eventReceivers, definition);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = existingReceiver,
ObjectType = typeof(SPEventReceiverDefinition),
ObjectDefinition = definition,
ModelHost = modelHost
});
bool isNew = false;
if (existingReceiver == null)
{
existingReceiver = CreateNewEventReceiverDefinition(modelHost, eventReceivers, out isNew);
}
MapEventReceiverProperties(definition, existingReceiver, isNew);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = existingReceiver,
ObjectType = typeof(SPEventReceiverDefinition),
ObjectDefinition = definition,
ModelHost = modelHost
});
existingReceiver.Update();
}
public void RemoveEventReceiverTest()
{
using (var scope = new PSTestScope(true))
{
EventReceiverDefinition receiver = null;
using (var ctx = TestCommon.CreateClientContext())
{
receiver = ctx.Web.AddRemoteEventReceiver("TestEventReceiver", "https://testserver.com/testeventreceiver.svc", EventReceiverType.ListAdded, EventReceiverSynchronization.Asynchronous, true);
}
var results = scope.ExecuteCommand("Remove-PnPEventReceiver",
new CommandParameter("Identity", receiver.ReceiverId),
new CommandParameter("Force"));
using (var ctx = TestCommon.CreateClientContext())
{
receiver = ctx.Web.GetEventReceiverByName("TestEventReceiver");
Assert.IsNull(receiver);
}
}
}
public static TModelNode AddEventReceiver <TModelNode>(this TModelNode model, EventReceiverDefinition definition,
Action <EventReceiverModelNode> action)
where TModelNode : ModelNode, IEventReceiverHostModelNode, new()
{
return(model.AddTypedDefinitionNode(definition, action));
}
public override void FeatureActivated(SPFeatureReceiverProperties properties)
{
try
{
const string assembly = "SkillWillCorp.SP.Offices, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f54f8a30b400bb4c";
const string eventReceiverClasss = "SkillWillCorp.SP.Offices.EventReceiver.OfficesEventReceiver";
var spWeb = properties.Feature.Parent as SPWeb;
if (spWeb == null)
{
throw new Exception("Critical error: SPWeb is not found.");
}
Logger.WriteMessage("SkillWillCorp.SP.Offices.SkillWillCorpSPOfficesEventReceiver: Initialize fields");
var nameField = new FieldDefinition
{
Title = "Name",
InternalName = Constants.Fields.NameFieldInternalName,
Group = "SWC.Offices",
Id = new Guid(Constants.Fields.NameFieldInternalNameId),
AddToDefaultView = true,
FieldType = BuiltInFieldTypes.Text,
Required = true
};
var directorField = new FieldDefinition
{
Title = "Director (User)",
InternalName = Constants.Fields.DirectorFieldInternalName,
Group = "SWC.Offices",
Id = new Guid(Constants.Fields.DirectorFieldInternalNameId),
AddToDefaultView = true,
FieldType = BuiltInFieldTypes.User,
Required = true
};
var descriptionField = new FieldDefinition
{
Title = "Description",
InternalName = "swc_Description",
Group = "SWC.Offices",
Id = new Guid("ADD8A4AF-0BDD-438E-886F-7767368B56FB"),
AddToDefaultView = true,
FieldType = BuiltInFieldTypes.Note
};
var officeCodeField = new FieldDefinition
{
Title = "Office Code",
InternalName = "swc_OfficeCode",
Group = "SWC.Offices",
Id = new Guid("438893A6-3D5C-4B84-86B8-C0C8D8F1183B"),
AddToDefaultView = true,
FieldType = BuiltInFieldTypes.Text
};
var officeMembersField = new FieldDefinition
{
Title = "Office Members (Users)",
InternalName = Constants.Fields.MembersFieldInternalName,
Group = "SWC.Offices",
Id = new Guid(Constants.Fields.MembersFieldInternalNameId),
AddToDefaultView = true,
FieldType = BuiltInFieldTypes.UserMulti,
Required = true,
AdditionalAttributes =
new List <FieldAttributeValue>(new List <FieldAttributeValue>
{
new FieldAttributeValue("Mult", "TRUE")
})
};
var fieldIsCopiedField = new FieldDefinition
{
Title = "Field is copied",
InternalName = Constants.Fields.FieldIsCopiedFieldInternalName,
Group = "SWC.Offices",
AddToDefaultView = false,
Hidden = true,
Id = new Guid(Constants.Fields.FieldIsCopiedFieldInternalNameId),
FieldType = BuiltInFieldTypes.Boolean
};
Logger.WriteMessage("SkillWillCorp.SP.Offices.SkillWillCorpSPOfficesEventReceiver: Initialize Lists");
var officesList = new ListDefinition
{
Title = "Offices",
Description = "",
TemplateType = BuiltInListTemplateTypeId.GenericList,
Url = "Offices",
OnQuickLaunch = true
};
var officesList2 = new ListDefinition
{
Title = "Offices2",
Description = "",
TemplateType = BuiltInListTemplateTypeId.GenericList,
Url = "Offices2",
OnQuickLaunch = true
};
Logger.WriteMessage("SkillWillCorp.SP.Offices.SkillWillCorpSPOfficesEventReceiver: Initialize EventReceivers");
var officesEventReceiverItemAdded = new EventReceiverDefinition
{
Assembly = assembly,
Class = eventReceiverClasss,
Synchronization = BuiltInEventReceiverSynchronization.Synchronous,
Type = BuiltInEventReceiverType.ItemAdded,
Name = "officesEventReceiverItemAdded",
SequenceNumber = 10000
};
var officesEventReceiverItemDeleted = new EventReceiverDefinition
{
Assembly = assembly,
Class = eventReceiverClasss,
Synchronization = BuiltInEventReceiverSynchronization.Synchronous,
Type = BuiltInEventReceiverType.ItemDeleted,
Name = "officesEventReceiverItemDeleted",
SequenceNumber = 10000
};
var officesEventReceiverItemUpdated = new EventReceiverDefinition
{
Assembly = assembly,
Class = eventReceiverClasss,
Synchronization = BuiltInEventReceiverSynchronization.Synchronous,
Type = BuiltInEventReceiverType.ItemUpdated,
Name = "officesEventReceiverItemUpdated",
SequenceNumber = 10000
};
Logger.WriteMessage("SkillWillCorp.SP.Offices.SkillWillCorpSPOfficesEventReceiver: Initialize site model");
var siteModel = SPMeta2Model.NewWebModel(site =>
{
site.AddFields(new List <FieldDefinition>
{
nameField,
directorField,
descriptionField,
officeCodeField,
officeMembersField,
fieldIsCopiedField
});
});
Logger.WriteMessage("SkillWillCorp.SP.Offices.SkillWillCorpSPOfficesEventReceiver: Initialize web model");
var model = SPMeta2Model.NewWebModel(web =>
{
web.AddList(officesList, list =>
{
list.AddField(nameField);
list.AddField(directorField);
list.AddField(descriptionField);
list.AddField(officeCodeField);
list.AddField(officeMembersField);
list.AddField(fieldIsCopiedField);
list.AddEventReceivers(new List <EventReceiverDefinition>
{
officesEventReceiverItemAdded,
officesEventReceiverItemUpdated,
officesEventReceiverItemDeleted
});
});
web.AddList(officesList2, list =>
{
list.AddField(nameField);
list.AddField(directorField);
});
});
Logger.WriteMessage("SkillWillCorp.SP.Offices.SkillWillCorpSPOfficesEventReceiver: Initialize SSOMProvisionService");
var csomProvisionService = new SSOMProvisionService();
Logger.WriteMessage("SkillWillCorp.SP.Offices.SkillWillCorpSPOfficesEventReceiver: Deploy siteModel");
csomProvisionService.DeploySiteModel(spWeb.Site, siteModel);
Logger.WriteMessage("SkillWillCorp.SP.Offices.SkillWillCorpSPOfficesEventReceiver: Deploy webModel");
csomProvisionService.DeployWebModel(spWeb, model);
Logger.WriteMessage("SkillWillCorp.SP.Offices.SkillWillCorpSPOfficesEventReceiver: Create timer jobs");
CreateDeleteJob(spWeb);
}
catch (Exception ex)
{
Logger.WriteError("SkillWillCorp.SP.Offices.SkillWillCorpSPOfficesEventReceiver: Error on feature activating", ex, TraceSeverity.Unexpected);
throw;
}
}
private void DeployWebEventReceiver(object modelHost, WebModelHost listModelHost, EventReceiverDefinition definition)
{
DeployEventReceiver(modelHost, listModelHost.HostWeb.EventReceivers, definition);
}
private void DeploySiteEventReceiver(object modelHost, SiteModelHost siteModelHost, EventReceiverDefinition definition)
{
DeployEventReceiver(modelHost, siteModelHost.HostSite.EventReceivers, definition);
}
public EventReceiverPipeBind(EventReceiverDefinition eventReceiverDefinition)
{
_eventReceiverDefinition = eventReceiverDefinition;
}
public EventReceiverPipeBind()
{
_eventReceiverDefinition = null;
_id = Guid.Empty;
_name = string.Empty;
}
static public void CreateAnnouncementsList(ClientContext clientContext)
{
string listTitle = "Announcements";
// delete list if it exists
ExceptionHandlingScope scope = new ExceptionHandlingScope(clientContext);
using (scope.StartScope()) {
using (scope.StartTry()) {
clientContext.Web.Lists.GetByTitle(listTitle).DeleteObject();
}
using (scope.StartCatch()) { }
}
// create and initialize ListCreationInformation object
ListCreationInformation listInformation = new ListCreationInformation();
listInformation.Title = listTitle;
listInformation.Url = "Lists/Announcements";
listInformation.QuickLaunchOption = QuickLaunchOptions.On;
listInformation.TemplateType = (int)ListTemplateType.Announcements;
// Add ListCreationInformation to lists collection and return list object
List list = clientContext.Web.Lists.Add(listInformation);
// modify additional list properties and update
list.OnQuickLaunch = true;
list.EnableAttachments = false;
list.Update();
// send command to server to create list
clientContext.ExecuteQuery();
clientContext.Load(list);
clientContext.ExecuteQuery();
string urlEventReceiver = HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Authority) +
@"/Services/AnnouncementsEventReceiver.svc";
EventReceiverDefinitionCreationInformation erci1 = new EventReceiverDefinitionCreationInformation();
erci1.ReceiverName = "ItemAdding";
erci1.EventType = EventReceiverType.ItemAdding;
erci1.ReceiverUrl = urlEventReceiver;
erci1.SequenceNumber = 1000;
EventReceiverDefinition er1 = list.EventReceivers.Add(erci1);
er1.Update();
EventReceiverDefinitionCreationInformation erci2 = new EventReceiverDefinitionCreationInformation();
erci2.ReceiverName = "ItemUpdating";
erci2.EventType = EventReceiverType.ItemUpdating;
erci2.ReceiverUrl = urlEventReceiver;
erci2.SequenceNumber = 1000;
EventReceiverDefinition er2 = list.EventReceivers.Add(erci2);
er2.Update();
clientContext.ExecuteQuery();
ListItemCreationInformation lici = new ListItemCreationInformation();
var item1 = list.AddItem(lici);
item1["Title"] = "SharePoint introduces new app model";
item1["Body"] = "<div>Developers wonder what happened to solutions.</div>";
item1["Expires"] = DateTime.Today.AddYears(10);
item1.Update();
var item2 = list.AddItem(lici);
item2["Title"] = "All SharePoint developers must now learn JavaScript";
item2["Body"] = "<div>Some developers are more excited than others.</div>";
item2["Expires"] = DateTime.Today.AddYears(1);
item2.Update();
var item3 = list.AddItem(lici);
item3["Title"] = "CSOM programming is super fun";
item3["Body"] = "<div>Just ask my mom.</div>";
item3["Expires"] = DateTime.Today.AddDays(7);
item3.Update();
clientContext.ExecuteQuery();
}
public static ModelNode AddEventReceiver(this ModelNode model, EventReceiverDefinition definition, Action <ModelNode> action)
{
return(model.AddDefinitionNode(definition, action));
}
public static ModelNode AddEventReceiver(this ModelNode model, EventReceiverDefinition definition)
{
return(AddEventReceiver(model, definition, null));
}
private void DeployContentTypeEventReceiver(object modelHost, SPContentType contentType, EventReceiverDefinition definition)
{
DeployEventReceiver(modelHost, contentType.EventReceivers, definition);
}
public SPOEventReceiverDefinition(EventReceiverDefinition erd, EventReceiverDefinitionCollection parentCollection)
{
_erd = erd;
_parentCollection = parentCollection;
}
private void DeployListEventReceiver(object modelHost, ListModelHost listModelHost, EventReceiverDefinition definition)
{
DeployEventReceiver(modelHost, listModelHost.HostList.EventReceivers, definition);
}
public static TModelNode AddEventReceiver <TModelNode>(this TModelNode model, EventReceiverDefinition definition)
where TModelNode : ModelNode, IEventReceiverHostModelNode, new()
{
return(AddEventReceiver(model, definition, null));
}
protected SPEventReceiverDefinition FindEventReceiverDefinition(SPEventReceiverDefinitionCollection receivers, EventReceiverDefinition definition)
{
var receiverName = definition.Name.ToUpper();
return(receivers.OfType <SPEventReceiverDefinition>()
.FirstOrDefault(r =>
!string.IsNullOrEmpty(r.Name) &&
r.Name.ToUpper() == receiverName));
}
public SPOEventReceiverDefinition(EventReceiverDefinition erd, EventReceiverDefinitionCollection parentCollection)
{
_erd = erd;
_parentCollection = parentCollection;
}
