private void AddWeb(SEActivities activities, SEActivities.Thread thread, DataRow tr)
{
bool found = activities.webs.Any(w => w.id == thread.webId);
if (found)
{
return;
}
lock (_locker)
{
found = activities.webs.Any(w => w.id == thread.webId);
if (found)
{
return;
}
activities.webs.Add(new SEActivities.Web
{
id = thread.webId,
title = (string)tr["WebTitle"],
url = (string)tr["WebUrl"]
});
}
}
private static void SortThreadActivities(SEActivities activities)
{
Parallel.ForEach(activities.threads,
thread => { thread.activities = thread.activities.OrderByDescending(a => a.time).ToList(); });
activities.threads = activities.threads.OrderByDescending(t => t.lastActivityOn).ToList();
}
private void GetData(SEActivities activities, Guid threadId, string kind, DateTime offset)
{
SPWeb web = SPContext.Current.Web;
int userId = web.CurrentUser.ID;
_regionalSettings = SPContext.Current.RegionalSettings;
using (var connectionManager = new DBConnectionManager(web))
{
DBConnectionManager manager = connectionManager;
List <DataRow> threadRows = GetThreads(manager, userId, web, 0, 0, threadId).AsEnumerable().ToList();
List <SEActivities.Thread> threads =
threadRows.Select(tr => BuildThread(tr, manager, userId, 0, 0, activities, offset, kind))
.ToList();
foreach (SEActivities.Thread thread in threads)
{
activities.threads.Add(thread);
}
}
SortThreadActivities(activities);
}
public SEActivities GetActivities()
{
var activities = new SEActivities();
try
{
int limit;
int page;
int activityLimit;
int commentLimit;
DateTime offset;
ParseMetaData(out page, out limit, out activityLimit, out commentLimit, out offset);
GetData(page, limit, activityLimit, commentLimit, activities);
return(activities);
}
catch (Exception exception)
{
if (exception is AggregateException)
{
exception = ((AggregateException)exception).Flatten();
}
activities.error = new Error
{
message = exception.Message,
stackTrace = exception.StackTrace,
kind = typeof(Exception).ToString()
};
}
return(activities);
}
private void AddUser(SEActivities activities, SEActivities.Thread.Activity activity, DataRow ar)
{
bool found = activities.users.Any(u => u.id == activity.userId);
if (found)
{
return;
}
lock (_locker)
{
found = activities.users.Any(u => u.id == activity.userId);
if (found)
{
return;
}
activities.users.Add(new SEActivities.User
{
id = activity.userId,
name = (string)ar["UserName"],
displayName = (string)ar["UserDisplayName"],
picture = ((ar["UserPicture"] as string) ?? string.Empty).Split(',')[0]
});
}
}
private void BuildComments(IEnumerable <DataRow> commentRows, SEActivities activities, SEActivities.Thread thread)
{
Parallel.ForEach(commentRows, r =>
{
foreach (string column in _activityDateTimeColumns)
{
SetLocalDateTime(r, column, _utcTimeDict, _regionalSettings);
}
SEActivities.Thread.Activity activity = BuildActivity(r, activities);
thread.comments.Add(activity);
});
}
private SEActivities.Thread.Activity BuildActivity(DataRow ar, SEActivities activities)
{
var activity = new SEActivities.Thread.Activity
{
id = (Guid)ar["ActivityId"],
key = ar["ActivityKey"] as string,
data = ar["ActivityData"] as string,
kind = ((ActivityKind)ar["ActivityKind"]).ToString(),
time = ((DateTime)ar["ActivityDate"]).ToString(DATE_FORMAT),
isBulkOperation = (bool)ar["ActivityIsMassOperation"],
userId = (int)ar["UserId"]
};
AddUser(activities, activity, ar);
return(activity);
}
public SEActivities GetSUId(string listId, string itemId)
{
var activities = new SEActivities();
try
{
var lId = new Guid(listId);
int iId = int.Parse(itemId);
const string SQL = @"
SELECT TOP (1) dbo.SS_Activities.ActivityKey
FROM dbo.SS_Threads INNER JOIN dbo.SS_Activities ON dbo.SS_Threads.Id = dbo.SS_Activities.ThreadId
WHERE (dbo.SS_Threads.Deleted = 0) AND (dbo.SS_Threads.ListId = @ListId) AND
(dbo.SS_Threads.ItemId = @ItemId) AND (dbo.SS_Activities.Kind = 0)";
using (var connectionManager = new DBConnectionManager(SPContext.Current.Web))
{
using (var sqlCommand = new SqlCommand(SQL, connectionManager.SqlConnection))
{
sqlCommand.Parameters.AddWithValue("@ListId", lId);
sqlCommand.Parameters.AddWithValue("@ItemId", iId);
activities.suid = new Guid(sqlCommand.ExecuteScalar().ToString());
}
}
}
catch (Exception exception)
{
if (exception is AggregateException)
{
exception = ((AggregateException)exception).Flatten();
}
activities.error = new Error
{
message = exception.Message,
stackTrace = exception.StackTrace,
kind = typeof(Exception).ToString()
};
}
return(activities);
}
// Private Methods (17)
private void AddList(SEActivities.Thread thread, SEActivities activities, DataRow tr)
{
if (!thread.listId.HasValue)
{
return;
}
bool found = activities.lists.Any(list => list.id == thread.listId.Value);
if (found)
{
return;
}
lock (_locker)
{
found = activities.lists.Any(list => list.id == thread.listId.Value);
if (found)
{
return;
}
string url = string.Format("{0}/{1}?action=gotolist&webid={2}&listid={3}&nodlg=true",
GetSafeWebUrl(tr["WebUrl"]), PROXY_URL, thread.webId, thread.listId);
if (((ObjectKind)tr["ThreadKind"]) == ObjectKind.List)
{
tr["ListName"] = tr["ThreadTitle"];
}
activities.lists.Add(new SEActivities.ItemList
{
id = thread.listId.Value,
name = tr["ListName"] as string,
icon = tr["ListIcon"] as string,
url = url
});
}
}
private void GetData(int page, int limit, int activityLimit, int commentLimit, SEActivities activities)
{
SPWeb web = SPContext.Current.Web;
int userId = web.CurrentUser.ID;
_regionalSettings = SPContext.Current.RegionalSettings;
using (var connectionManager = new DBConnectionManager(web))
{
DBConnectionManager manager = connectionManager;
List <DataRow> threadRows = GetThreads(manager, userId, web, page, limit, null).AsEnumerable().ToList();
List <SEActivities.Thread> threads =
threadRows.Select(
tr => BuildThread(tr, manager, userId, activityLimit, commentLimit, activities, null))
.ToList();
foreach (SEActivities.Thread thread in threads)
{
if (thread.activities.Count != 0 || thread.comments.Count != 0)
{
activities.threads.Add(thread);
}
}
}
activities.threads = activities.threads.Distinct().ToList();
activities.webs = activities.webs.Distinct().ToList();
activities.lists = activities.lists.Distinct().ToList();
activities.users = activities.users.Distinct().ToList();
SortThreadActivities(activities);
}
private SEActivities.Thread BuildThread(DataRow tr, DBConnectionManager manager, int userId, int activityLimit,
int commentLimit, SEActivities activities, DateTime?offset, string kind = null)
{
foreach (string column in _threadDateTimeColumns)
{
SetLocalDateTime(tr, column, _utcTimeDict, _regionalSettings);
}
var activityRows = new List <DataRow>();
var commentRows = new List <DataRow>();
var totalComments = (int)tr["TotalComments"];
var threadKind = (ObjectKind)tr["ThreadKind"];
bool ignoreAccess = threadKind == ObjectKind.StatusUpdate;
if (!string.IsNullOrEmpty(kind))
{
kind = kind.ToLower();
if (kind.Equals("activities"))
{
activityRows =
GetThreadActivities(manager, userId, 0, 3, activityLimit, tr, offset, ignoreAccess)
.AsEnumerable()
.ToList();
}
else if (kind.Equals("comments"))
{
commentRows =
GetThreadActivities(manager, userId, 4, 4, commentLimit, tr, offset, ignoreAccess)
.AsEnumerable()
.ToList();
}
}
else
{
activityRows =
GetThreadActivities(manager, userId, 0, 3, activityLimit, tr, null, ignoreAccess)
.AsEnumerable()
.ToList();
if (totalComments > 0)
{
commentRows =
GetThreadActivities(manager, userId, 4, 4, commentLimit, tr, null, ignoreAccess)
.AsEnumerable()
.ToList();
}
}
int totalActivities = activityRows.Count;
var webId = (Guid)tr["WebId"];
var listId = tr["ListId"] as Guid?;
var itemId = tr["ItemId"] as int?;
var url = tr["ThreadUrl"] as string;
if (listId.HasValue && itemId.HasValue)
{
url = string.Format("{0}/{1}?action=view&webid={2}&listid={3}&id={4}",
GetSafeWebUrl(tr["WebUrl"]), PROXY_URL, webId, listId.Value, itemId.Value);
}
var thread = new SEActivities.Thread
{
id = (Guid)tr["ThreadId"],
title = HttpUtility.HtmlDecode(HttpUtility.HtmlDecode((string)tr["ThreadTitle"])),
url = url,
kind = ((ObjectKind)tr["ThreadKind"]).ToString(),
lastActivityOn = ((DateTime)tr["ThreadLastActivityOn"]).ToString(DATE_FORMAT),
firstActivityOn = ((DateTime)tr["ThreadFirstActivityOn"]).ToString(DATE_FORMAT),
webId = webId,
listId = listId,
itemId = itemId,
totalActivities = totalActivities,
totalComments = totalComments
};
var threadTasks = new[]
{
Task.Factory.StartNew(() => BuildActivities(activityRows, activities, thread)),
Task.Factory.StartNew(() => BuildComments(commentRows, activities, thread)),
Task.Factory.StartNew(() => AddWeb(activities, thread, tr)),
Task.Factory.StartNew(() => AddList(thread, activities, tr))
};
Task.WaitAll(threadTasks);
thread.activities = thread.activities.Distinct().ToList();
thread.comments = thread.comments.Distinct().ToList();
return(thread);
}
