internal static void ValidateCreationActivity(this ProcessActivityEventArgs args)
{
var data = args.Data;
EnsureValideData(data);
if (EnsureNotIgnoredList(args, data))
{
return;
}
if (args.ActivityKind != ActivityKind.Created)
{
return;
}
Guid webId;
Guid listId;
int id;
ParseActivityVales(data, out webId, out listId, out id);
if (args.ActivityManager.ActivityExists(
ObjectKind.ListItem,
ActivityKind.Created,
webId,
listId,
id))
{
throw new SocialEngineException(AlreadyCreatedExceptionMessage, LogKind.Info);
}
}
private void ValidateCreationActivity(ProcessActivityEventArgs args)
{
Dictionary <string, object> data = args.Data;
new DataValidator(data).Validate(new Dictionary <string, DataType>
{
{ "Id", DataType.Guid },
{ "Title", DataType.String },
{ "URL", DataType.String },
{ "WebId", DataType.Guid },
{ "UserId", DataType.Int },
{ "ActivityTime", DataType.DateTime }
});
if (IsIgnoredList(args, data))
{
return;
}
if (args.ActivityManager.ActivityExists(ObjectKind.Workspace, ActivityKind.Created,
(Guid)data["WebId"], (Guid)data["Id"]))
{
throw new SocialEngineException(ALREADY_CREATED_EXCEPTION_MESSAGE, LogKind.Info);
}
}
public void ValidateCommentDeletionActivity_WhenCalled_ThrowsSameItemError()
{
// Arrange
const string settingValue = "somevalue";
const string expected = "Cannot register more than one deleted activity on the same item.";
var data = CreateDataObject();
var actual = string.Empty;
ShimCacheStore.CurrentGet = () => new ShimCacheStore()
{
GetStringStringFuncOfObjectBoolean = (_, _1, _2, _3) => new ShimCachedValue()
{
ValueGet = () => settingValue
}
};
ShimSqlCommand.AllInstances.ExecuteScalar = _ => 1;
var args = new ProcessActivityEventArgs(ObjectKind.List, ActivityKind.Deleted, data, spWeb, streamManager, threadManager, activityManager);
// Act
try
{
privateTypeValidator.InvokeStatic(ValidateCommentDeletionActivityMethod, args);
}
catch (SocialEngineException exception)
{
actual = exception.Message;
}
// Assert
actual.ShouldBe(expected);
}
private void RegisterDeletionActivity(ProcessActivityEventArgs args)
{
Dictionary <string, object> data = args.Data;
ThreadManager threadManager = args.ThreadManager;
Thread thread = threadManager.GetThread((Guid)data["WebId"], (Guid)data["ListId"], (int)data["Id"]) ??
threadManager.SaveThread(new Thread
{
Title = (string)data["Title"],
Url = (string)data["URL"],
Kind = args.ObjectKind,
WebId = (Guid)data["WebId"],
ListId = (Guid)data["ListId"],
ItemId = (int)data["Id"]
});
data.Add("#!Thread", thread);
if (args.ActivityKind != ActivityKind.Deleted)
{
return;
}
threadManager.DeleteThread(thread);
Activity activity = args.ActivityManager.RegisterActivity(new Activity
{
Kind = ActivityKind.Deleted,
UserId = (int)data["UserId"],
Thread = thread,
Date = (DateTime)data["ActivityTime"]
});
data.Add("#!Activity", activity);
}
private void ValidateDeletionActivity(ProcessActivityEventArgs args)
{
Dictionary <string, object> data = args.Data;
new DataValidator(data).Validate(new Dictionary <string, DataType>
{
{ "Id", DataType.Guid },
{ "Title", DataType.String },
{ "URL", DataType.String },
{ "WebId", DataType.Guid },
{ "UserId", DataType.Int },
{ "ActivityTime", DataType.DateTime }
});
if (IsIgnoredList(args, data))
{
return;
}
if (args.ActivityManager.ActivityExists(ObjectKind.List, ActivityKind.Deleted, (Guid)data["WebId"],
(Guid)data["Id"]))
{
throw new SocialEngineException(
"Cannot register more than one deleted activity on the same list.", LogKind.Info);
}
}
private void ValidateCreationActivity(ProcessActivityEventArgs args)
{
Dictionary <string, object> data = args.Data;
new DataValidator(data).Validate(new Dictionary <string, DataType>
{
{ "Id", DataType.Guid },
{ "WebId", DataType.Guid },
{ "ListId", DataType.Guid },
{ "ItemId", DataType.Int },
{ "Status", DataType.String },
{ "UserId", DataType.Int },
{ "ActivityTime", DataType.DateTime }
});
if (args.ActivityKind == ActivityKind.CommentAdded)
{
return;
}
if (args.ActivityManager.ActivityExists(ObjectKind.StatusUpdate, ActivityKind.Created,
(Guid)data["WebId"], (Guid)data["ListId"], (int)data["ItemId"], data["Id"].ToString()))
{
throw new SocialEngineException(ALREADY_CREATED_EXCEPTION_MESSAGE, LogKind.Info);
}
}
private void OnValidateActivity(ProcessActivityEventArgs args)
{
if (args.ObjectKind != ObjectKind.List)
{
return;
}
switch (args.ActivityKind)
{
case ActivityKind.Created:
ValidateCreationActivity(args);
break;
case ActivityKind.Deleted:
ValidateDeletionActivity(args);
break;
case ActivityKind.BulkOperation:
ValidateBulkOperationActivity(args);
break;
default:
throw new SocialEngineException("This activity cannot be performed on a list.", LogKind.Info);
}
}
private void OnActivityRegistration(ProcessActivityEventArgs args)
{
if (args.ObjectKind != ObjectKind.ListItem)
{
return;
}
switch (args.ActivityKind)
{
case ActivityKind.Created:
RegisterCreationActivity(args);
break;
case ActivityKind.Updated:
RegisterUpdationActivity(args);
break;
case ActivityKind.Deleted:
RegisterDeletionActivity(args);
break;
case ActivityKind.CommentAdded:
RegisterCommentCreationActivity(args);
break;
case ActivityKind.CommentUpdated:
RegisterCommentUpdationActivity(args);
break;
case ActivityKind.CommentRemoved:
RegisterCommentDeletionActivity(args);
break;
}
}
public void OnValidateActivityMethod_WhenCalled_CreationValidated()
{
// Arrange
const bool registerExpected = true;
var registerActual = false;
var processActivityEventArgs = new ProcessActivityEventArgs(ObjectKind.ListItem, ActivityKind.Created, CreateDataObject(), spWeb, streamManager, threadManager, activityManager);
ShimSqlCommand.AllInstances.ExecuteScalar = sqlCommand =>
{
if (sqlCommand.CommandText.StartsWith("SELECT COUNT(dbo.SS_Activities.Id) AS Total FROM dbo.SS_Activities"))
{
registerActual = true;
}
return(null);
};
privateObj.Invoke(
OnValidateActivityMethod,
BindingFlags.Instance | BindingFlags.NonPublic,
new object[] { processActivityEventArgs });
// Assert
registerActual.ShouldBe(registerExpected);
}
private void RegisterCommentCreationActivity(ProcessActivityEventArgs args)
{
Dictionary <string, object> data = args.Data;
Thread thread = args.ThreadManager.GetThread((Guid)data["WebId"], (Guid)data["ListId"],
(int)data["ItemId"]);
if (thread == null)
{
RegisterCreationActivity(args);
thread = (Thread)data["#!Thread"];
}
var act = new Activity
{
Kind = args.ActivityKind,
UserId = (int)data["UserId"],
Thread = thread,
Date = (DateTime)data["CommentTime"],
Key = data["CommentId"].ToString()
};
act.SetData(new { comment = data["Comment"] });
Activity activity = args.ActivityManager.RegisterActivity(act);
}
private void LogCancellation(ObjectKind objectKind, ActivityKind activityKind, Dictionary <string, object> data,
SPWeb spWeb,
ProcessActivityEventArgs args)
{
if (!string.IsNullOrEmpty(args.CancellationMessage))
{
_logger.Log(objectKind, activityKind, data, spWeb, args.CancellationMessage);
}
}
private void RegisterCommentDeletionActivity(ProcessActivityEventArgs args)
{
RegisterDeletionActivity(args);
args.ActivityManager.DeleteActivity(new Dictionary <string, object>
{
{ "ActivityKey", args.Data["CommentId"].ToString().ToUpper() }
});
}
private void OnPostActivityRegistration(ProcessActivityEventArgs args)
{
if (args.ObjectKind != ObjectKind.ListItem)
{
return;
}
PerformPostRegistrationSteps(args);
}
public void RegisterCommentCreationActivity_WhenThreadNotNull_RegistersActivity()
{
// Arrange
const bool registerExpected = true;
var registerActual = false;
var data = CreateDataObject();
data.Add(CommentIdString, 1);
data.Add(CommentString, CommentString);
data.Add(CommentersColumn, Commenters);
data.Add(ThreadValue, new Thread()
{
Id = guid
});
var threadTable = CreateThreadTable();
ShimSqlCommand.AllInstances.ExecuteNonQuery = sqlCommand =>
{
if (sqlCommand.CommandText.StartsWith("INSERT INTO SS_Activities"))
{
registerActual = true;
}
return(1);
};
ShimSqlCommand.AllInstances.ExecuteReader = sqlCommand =>
{
var reader = new ShimSqlDataReader()
{
Close = () => { }
};
return(reader);
};
ShimDataRowCollection.AllInstances.CountGet = _ => 1;
ShimDataRowCollection.AllInstances.ItemGetInt32 = (_, _1) =>
{
DataRow result = null;
ShimsContext.ExecuteWithoutShims(() =>
{
result = threadTable.Rows[0];
});
return(result);
};
var args = new ProcessActivityEventArgs(ObjectKind.List, ActivityKind.CommentAdded, data, spWeb, streamManager, threadManager, activityManager);
// Act
privateObj.Invoke(
RegisterCommentCreationActivityMethod,
BindingFlags.Instance | BindingFlags.NonPublic,
new object[] { args });
// Assert
registerActual.ShouldBe(registerExpected);
}
// Private Methods (7)
private void OnActivityRegistration(ProcessActivityEventArgs args)
{
if (args.ObjectKind != ObjectKind.Workspace)
{
return;
}
RegisterWorkspaceActivity(args.ActivityKind, args.Data, args.ContextWeb,
args.StreamManager, args.ThreadManager, args.ActivityManager);
}
internal static void ValidateUpdationActivity(this ProcessActivityEventArgs args)
{
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
var data = args.Data;
EnsureValideData(data);
EnsureNotIgnoredList(args, data);
}
// Private Methods (1)
private void OnValidateActivity(ProcessActivityEventArgs args)
{
var validObjectKinds = new ObjectKind[] {};
if (validObjectKinds.Contains(args.ObjectKind) ||
args.ContextWeb.CurrentUser.ID != args.ContextWeb.Site.SystemAccount.ID)
{
return;
}
args.Cancel = true;
args.CancellationMessage = "Ignoring activities performed by the System Account";
}
private static void UpdateThreadUsers(ProcessActivityEventArgs args, Thread thread)
{
if (args.ActivityKind == ActivityKind.CommentAdded ||
args.ActivityKind == ActivityKind.CommentUpdated ||
args.ActivityKind == ActivityKind.CommentRemoved)
{
ManageCommentUsers(args, thread);
return;
}
Dictionary <string, object> data = args.Data;
var users = new List <User> {
new User {
Id = (int)data["UserId"], Role = UserRole.Author
}
};
if (data.ContainsKey("AssignedTo"))
{
var assignedToUsers = data["AssignedTo"] as string;
if (!string.IsNullOrEmpty(assignedToUsers))
{
string[] asu = assignedToUsers.Split(',');
foreach (string user in asu)
{
int userId;
if (!int.TryParse(user.Trim(), out userId))
{
continue;
}
User tu = (from u in users where u.Id == userId select u).FirstOrDefault();
if (tu == null)
{
users.Add(new User {
Id = userId, Role = UserRole.Assignee
});
}
else
{
tu.Role |= UserRole.Assignee;
}
}
}
}
thread.Users = users.AsParallel().Distinct().ToArray();
args.ThreadManager.UpdateUsers(thread);
}
// Private Methods (9)
private static bool IsIgnoredList(ProcessActivityEventArgs args, Dictionary <string, object> data)
{
var listTitle = (string)data["Title"];
if (!Core.Utilities.IsIgnoredList(listTitle, args.ContextWeb))
{
return(false);
}
args.Cancel = true;
args.CancellationMessage = listTitle + " is part of ignored Social Stream lists.";
return(true);
}
private void ValidateBulkOperationActivity(ProcessActivityEventArgs args)
{
Dictionary <string, object> data = args.Data;
new DataValidator(data).Validate(new Dictionary <string, DataType>
{
{ "Id", DataType.Guid },
{ "WebId", DataType.Guid },
{ "SiteId", DataType.Guid },
{ "UserId", DataType.Int },
{ "TotalActivities", DataType.Int },
{ "ActivityTime", DataType.DateTime }
});
}
public void PerformPreRegistrationSteps_WhenCalled_ReturnsTimespan()
{
// Arrange
const bool expected = true;
var actual = false;
var readCount = 0;
var data = CreateDataObject();
ShimCacheStore.CurrentGet = () => new ShimCacheStore()
{
GetStringStringFuncOfObjectBoolean = (_, _1, _2, _3) => new ShimCachedValue()
{
ValueGet = () => new TimeSpan(0, 10, 0)
}
};
ShimSqlCommand.AllInstances.ExecuteNonQuery = sqlCommand =>
{
if (sqlCommand.CommandText.StartsWith("UPDATE SS_Activities SET MassOperation = 1"))
{
actual = true;
}
return(1);
};
ShimSqlCommand.AllInstances.ExecuteReader = sqlCommand => new ShimSqlDataReader()
{
Close = () => { },
Read = () =>
{
readCount++;
return(readCount == 1);
},
GetGuidInt32 = _ => guid,
GetBooleanInt32 = _ => false,
GetDateTimeInt32 = _ => DateTime.Now
};
var args = new ProcessActivityEventArgs(ObjectKind.List, ActivityKind.CommentAdded, data, spWeb, streamManager, threadManager, activityManager);
// Act
privateObj.Invoke(
PerformPreRegistrationStepsMethod,
BindingFlags.Instance | BindingFlags.NonPublic,
new object[] { args });
// Assert
actual.ShouldBe(expected);
}
// Private Methods (6)
private void OnActivityRegistration(ProcessActivityEventArgs args)
{
if (args.ObjectKind != ObjectKind.StatusUpdate)
{
return;
}
if (args.ActivityKind == ActivityKind.Created)
{
RegisterCreationActivity(args);
}
else if (args.ActivityKind == ActivityKind.CommentAdded)
{
RegisterCommentCreationActivity(args);
}
}
private void OnPreActivityRegistration(ProcessActivityEventArgs args)
{
if (args.ObjectKind != ObjectKind.ListItem)
{
return;
}
switch (args.ActivityKind)
{
case ActivityKind.CommentAdded:
case ActivityKind.CommentUpdated:
case ActivityKind.CommentRemoved:
return;
}
PerformPreRegistrationSteps(args);
}
public void ValidateCommentCreationActivity_WhenCalled_ThrowsNotRegisteredException()
{
// Arrange
const string settingValue = "somevalue";
const string expected = "Cannot register creation activity on the same comment more than once";
var queryCount = 0;
var data = CreateDataObject();
data.Add(CommentIdString, guid);
data.Add(CommentString, CommentString);
var actual = string.Empty;
ShimCacheStore.CurrentGet = () => new ShimCacheStore()
{
GetStringStringFuncOfObjectBoolean = (_, _1, _2, _3) => new ShimCachedValue()
{
ValueGet = () => settingValue
}
};
ShimSqlCommand.AllInstances.ExecuteScalar = _ =>
{
queryCount++;
if (queryCount == 1)
{
return(0);
}
return(1);
};
var args = new ProcessActivityEventArgs(ObjectKind.List, ActivityKind.Created, data, spWeb, streamManager, threadManager, activityManager);
// Act
try
{
args.ValidateCommentCreationActivity();
}
catch (SocialEngineException exception)
{
actual = exception.Message;
}
// Assert
actual.ShouldBe(expected);
}
public void UpdateThreadUsers_WhenCalled_UpdatesThreadUsers()
{
// Arrange
const bool expectedUpdate = true;
var actualUpdate = false;
var thread = new Thread()
{
Id = guid,
Users = new User[]
{
new User()
{
Id = 1,
Role = UserRole.Assignee
}
}
};
var data = CreateDataObject();
data.Add(AssignedToString, Commenters);
ShimSqlCommand.AllInstances.ExecuteScalar = _ => UserRole.Assignee;
ShimSqlCommand.AllInstances.ExecuteNonQuery = _ => 1;
ShimSqlCommand.AllInstances.ExecuteReader = _ =>
{
actualUpdate = true;
return(new ShimSqlDataReader()
{
Read = () => false,
Close = () => { }
});
};
var args = new ProcessActivityEventArgs(ObjectKind.List, ActivityKind.Updated, data, spWeb, streamManager, threadManager, activityManager);
// Act
privateObj.Invoke(
UpdateThreadUsersMethod,
BindingFlags.Static | BindingFlags.NonPublic,
new object[] { args, thread });
// Assert
actualUpdate.ShouldBe(expectedUpdate);
}
private void OnValidateActivity(ProcessActivityEventArgs args)
{
if (args.ObjectKind != ObjectKind.StatusUpdate)
{
return;
}
switch (args.ActivityKind)
{
case ActivityKind.Created:
ValidateCreationActivity(args);
break;
case ActivityKind.CommentAdded:
ValidateCommentCreationActivity(args);
break;
}
}
private void ValidateCommentCreationActivity(ProcessActivityEventArgs args)
{
ValidateCreationActivity(args);
Dictionary <string, object> data = args.Data;
new DataValidator(data).Validate(new Dictionary <string, DataType>
{
{ "CommentId", DataType.Guid },
{ "Comment", DataType.String },
{ "CommentTime", DataType.DateTime }
});
if (args.ActivityManager.ActivityExists(ObjectKind.StatusUpdate, ActivityKind.CommentAdded,
(Guid)data["WebId"], (Guid)data["ListId"], (int)data["ItemId"], data["CommentId"].ToString()))
{
throw new SocialEngineException("Cannot register creation activity on the same comment more than once",
LogKind.Info);
}
}
private void RegisterCommentUpdationActivity(ProcessActivityEventArgs args)
{
RegisterUpdationActivity(args);
Dictionary <string, object> data = args.Data;
args.ActivityManager.UpdateActivity(new Dictionary <string, object>
{
{
"Data", new JavaScriptSerializer().Serialize(new
{
comment = data["Comment"],
commenters = data["Commenters"]
})
}
}, new Dictionary <string, object>
{
{ "ActivityKey", data["CommentId"].ToString().ToUpper() }
});
}
private void RegisterBulkOperationActivity(ProcessActivityEventArgs args)
{
Dictionary <string, object> data = args.Data;
ThreadManager threadManager = args.ThreadManager;
ActivityManager activityManager = args.ActivityManager;
StreamManager streamManager = args.StreamManager;
var webId = (Guid)data["WebId"];
var activityDateTime = (DateTime)data["ActivityTime"];
Thread thread = threadManager.SaveThread(new Thread
{
Title = string.Empty,
Url = string.Empty,
Kind = ObjectKind.List,
WebId = webId,
ListId = (Guid)data["Id"],
FirstActivityDateTime = activityDateTime,
Users = new[] { new User {
Id = (int)data["UserId"], Role = UserRole.Author
} }
});
var activity = new Activity
{
Kind = args.ActivityKind,
UserId = (int)data["UserId"],
Thread = thread,
Date = activityDateTime
};
activity.SetData(new { totalActivities = data["TotalActivities"] });
activityManager.RegisterActivity(activity);
Guid streamId = streamManager.GetGlobalStreamId(webId);
threadManager.AssociateStreams(thread, new[] { streamId });
threadManager.UpdateUsers(thread);
}
internal static void ValidateCommentCreationActivity(this ProcessActivityEventArgs args)
{
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
ValidateCreationActivity(args);
var data = args.Data;
if (EnsureNotIgnoredList(args, data))
{
return;
}
new DataValidator(data).Validate(new Dictionary <string, DataType>
{
{ "CommentId", DataType.Guid },
{ "Comment", DataType.String }
});
Guid webId;
Guid listId;
int id;
ParseActivityVales(data, out webId, out listId, out id);
if (args.ActivityManager.ActivityExists(
ObjectKind.ListItem,
args.ActivityKind,
webId,
listId,
id,
data["CommentId"].ToString()))
{
throw new SocialEngineException(
"Cannot register creation activity on the same comment more than once",
LogKind.Info);
}
}
