Today I added the following changes to the solution:

1 – Added a ReplicatorLogger Class to the solution.

2 – Updated the Feature Receiver code to create a Replicator logger list in the Web.

3 – Updated the ItemUpdated method in the Event Receiver to write to the Replicator Logger list when an item is added or updated.

The following code is the new ReplicatorLogger Class:

internal class ReplicatorLogger

 {

publicvoid writeToLog(string title, string logDate, string modifiedBy, string action, string copySource, string fileName, SPWeb web)

{

 // Get the current httpcontext

 System.Web.HttpContext currentContext = System.Web.HttpContext.Current;

 // Set the httpcontext to null;

 HttpContext.Current = null;

 using (web)

{

 try

 {

 // Create an item the Replicator Logger list to record the event

 SPList spList = web.Lists[“Replicator Logger”];

 SPListItem logItem = spList.Items.Add();

logItem[“Title”] = title;

logItem[“Log Date”] = logDate;

logItem[“Modified By”] = modifiedBy;

logItem[“Action”] = action;

logItem[“Copy Source”] = copySource;

logItem[“File Name”] = fileName;

logItem.Update();

 }

 catch (SPException spEx)

{

 }

 finally

 {

 // Set the httpcontext back to the original

 System.Web.HttpContext.Current = currentContext;

}

}

}

}

The following code was added to the Feature Receiver to create the Replicator logger list:

 // Create the replicator logging list

 spWeb.Lists.Add(“Replicator Logger”, “Document Library Replicator Logging List”, spWeb.ListTemplates[“Custom List”]);

 SPList replicatorLoggingList = spWeb.Lists[“Replicator Logger”];

replicatorLoggingList.NoCrawl = true;

replicatorLoggingList.Fields.Add(“Log Date”, SPFieldType.Text, true);

replicatorLoggingList.Fields.Add(“Modified By”, SPFieldType.Text, true);

replicatorLoggingList.Fields.Add(“Action”, SPFieldType.Text, true);

replicatorLoggingList.Fields.Add(“Copy Source”, SPFieldType.Text, true);

replicatorLoggingList.Fields.Add(“File Name”, SPFieldType.Text, true);

replicatorLoggingList.Update();

 // Update the default view to show the new fields

SPView spLogView = replicatorLoggingList.DefaultView;

spLogView.ViewFields.Add(“Log Date”);

spLogView.ViewFields.Add(“Modified By”);

spLogView.ViewFields.Add(“Action”);

spLogView.ViewFields.Add(“Copy Source”);

spLogView.ViewFields.Add(“File Name”);

spLogView.Update();

The code below updates the Event Receiver to also write the properties to the Replicator Logger list:

public overridevoid ItemUpdated(SPItemEventProperties properties)

{

 base.ItemUpdated(properties);

 using (SPSite spsite = newSPSite(properties.WebUrl))

 try

 {

EventFiringEnabled = false;

 if (properties.ListItem.ParentList.Title != “Replicator Logger”)

{

 SPWeb siteForLogger = spsite.OpenWeb();

 // determine target filename – the same as the source

 string targetfilename = properties.ListItem.Name.ToString();

 string SourceLib = properties.WebUrl + “/” + properties.ListItem.ParentList.ToString();

  // Copy the file to the destination library (targetlibrary)

 properties.ListItem.File.CopyTo(properties.WebUrl + “/” + “targetlibrary” + “/” + targetfilename, true

);

 // Write to the Replicator Log – in test mode…

 ReplicatorLogger replogger = newReplicatorLogger();

 // Get the current Date and Time

 DateTime dtime = DateTime.Now;

 // Create the title for the logger list item

 string title = (dtime.Date.ToString() + “_” + dtime.Hour.ToString() + “_” + dtime.Minute.ToString() + “_” + dtime.Second.ToString() + “_” + targetfilename.ToString());

 // Write the information to the logger list

 EventFiringEnabled = false;

replogger.writeToLog(title, dtime.ToShortDateString(), properties.UserDisplayName.ToString(),“New/Updated Document”, SourceLib, targetfilename, siteForLogger);

}

}

catch (SPException spEx) { }

 finally

 {

  // Enable Event Firing

 EventFiringEnabled = true;

}

}

Here is an example of the item created in the Replicator Logger list when an item is uploaded or updated:

In my previous post I demonstrated how easy it was to have a document copied, on upload, to another document library with very few lines of code. This involved utilizing an Event Receiver which performed an override using the ItemUpdated method. This would also support document updates as the code utilized the ItemUpated method.

 Since then I have been working on a feature receiver which that creates a SharePoint list that defines the source and target document libraries for the copy operation.

The ideal approach is to code this so that when the Document Library Replicator feature is activated (the event receiver), we would like the replication configuration list to be created at the same time in the current Web. This has been achieved by created a Feature Receiver within the project that does the following:

1 – Create the “Replicator Configuration” list.

2 – Sets the crawl attribute for the list to none.

3 – Create two text fields for the source and target path and name

4 – Adds the two new text fields to the default view.

The feature receiver only overrides the FeatureActivated method, and does not remove the list when the Document Library Replicator feature is de-activated.

The code for the feature receiver is below:

public class Document_Library_ReplicatorEventReceiver: SPFeatureReceiver

{

.public override void FeatureActivated(SPFeatureReceiverProperties properties)

{

try

{

using (SPWeb spWeb = (SPWeb)properties.Feature.Parent)

{

// Create the replicator configuration list

SPSite spSite = spWeb.Site;

spWeb.Lists.Add(“Replicator Configuration”, “Document Library Replicator Configuration”, spWeb.ListTemplates[“Custom List”]);

SPList replicatorConfigList = spWeb.Lists[“Replicator Configuration”];

replicatorConfigList.NoCrawl = true;

replicatorConfigList.Fields.Add(“Source Library Path and Name”, SPFieldType.Text, true);

replicatorConfigList.Fields.Add(“Target Library Path and Name”, SPFieldType.Text, true);

replicatorConfigList.Update();

// Update the default view to show the new fields

SPView spView = replicatorConfigList.DefaultView;

spView.ViewFields.Add(“Source Library Path and Name”);

spView.ViewFields.Add(“Target Library Path and Name”);

spView.Update();

}

}

catch (SPException spEx)

{

}

finally

{

}

}

}

I have been recently working on coding a SharePoint document library replicator. Everytime an item is updated in one library, I wanted to ensure a copy of the updated document is written to another library within the same Web.

Even though I am still working in the final solution, I wanted to share a small code snippet which is a SharePoint 2010 Event Receiver that copies a file from one library to a specified target document library named “targetlibrary”. To perform this basic function the code was very straight forward, and any libraries that get updated would get the file copied to the target library within the Web.

The properties are hard-coded in this sample, but in my final solution I may have a list which manages source and destination library urls. It could also handle and manage SPFolders from the source to the target libraries. I’m also adding a log writer to show the copied files with a timestamp that shows properties such as the last user who edited the file. The log writer will write the information to a SharePoint list.

*** You may want to add some code to skip the block if an update is made to the target library ***

using System;

using System.Security.Permissions;

using Microsoft.SharePoint;

using Microsoft.SharePoint.Security;

using Microsoft.SharePoint.Utilities;

using Microsoft.SharePoint.Workflow;

using System.IO;

namespace DocLibraryReplicator.Document_Library_Receiver

{

///<summary>

/// List Item Events///</summary>

publicclass Document_Library_Receiver : SPItemEventReceiver

{

///<summary>/// An item was added.///</summary>

publicoverridevoid ItemAdded(SPItemEventProperties properties)

{

base.ItemAdded(properties);

}

///<summary>/// An item was updated.///</summary>

publicoverridevoid ItemUpdated(SPItemEventProperties properties)

{

base.ItemUpdated(properties);

using (SPSite spsite = newSPSite(properties.WebUrl))

try

{

// determine target filename – the same as the source

string targefilename = properties.ListItem.Name.ToString();

// Disable Event Firing as the target will try to copy to itself

EventFiringEnabled = false;

 // Copy the file to the destination library (targetlibrary) ** BEWARE ** Target file overwritten with true directive

properties.ListItem.File.CopyTo(properties.WebUrl + “/” + “targetlibrary” + “/” + targefilename, true);

 // Enable Event Firing

EventFiringEnabled = true;

}

catch (SPException spEx) { }

finally { }

}

}

}