At the very top of the UserProfile.ascx source code shown in Listing 11-1, you'll notice a number of Register statements that reference additional user controls. You'll now take a look at one of these specific user controls, the Friends.ascx control in order to better understand how this component of the User Profile is implemented and show how it uses the CommunityFramework API to display a list of the member's colleagues, as shown in code Listing 11-2.

<%@ Control Language="C#" AutoEventWireup="true" CodeFile="Friends.ascx.cs"
Inherits="Ektron.Profile.Friends" %>
<%@ Register Assembly="Ektron.Cms.Controls" Namespace="Ektron.Cms.Controls"
TagPrefix="CMS" %>

<div class="colleagues members">
    <asp:PlaceHolder ID="uxFindColleague" runat="server">
        <div class="findColleagues clearfix">
            <label for="colleagues">Find a colleague...</label>
            <input type="text" id="colleagues" name="colleagues"
                   maxlength="50" class="findFriend" value="" />
            <a href="#FindColleague"
               class="ui-button ui-widget ui-state-default
               ui-corner-all ui-button-text-icon"
               title="Find a colleague"

onclick="Ektron.Profile.Colleagues.find(this);return false;">
               <span class="ui-button-icon-primary ui-icon ui-icon-person"></span>
                <span class="ui-button-text">Find</span>
            </a>
        </div>
    </asp:PlaceHolder>
    <asp:MultiView ID="uxColleagues" runat="server">
        <asp:View ID="uxColleaguesUser" runat="server">
            <div class="types">
                <ul>
                    <li>
                        <a href="#colleagues-1">
                        <asp:Literal ID="uxFriendsLabel"
                                     runat="server" /></a>
                    </li>
                    <li id="uxColleaguesAwaitingTab" runat="server">
                        <a href="#<%= uxColleaguesInvitedPanel.ClientID %>">
                        <asp:Literal ID="uxOutgoingRequests"
                                     runat="server" /></a>
                    </li>
                    <li id="uxColleaguesNewInvitesTab" runat="server">
                        <a href="#<%= uxColleaguesPendingPanel.ClientID %>">
                        <asp:Literal ID="uxIncomingRequests"
                                     runat="server" />
                       <asp:Label id="uxNewInvites" runat="server">
                        <img id="uxColleaguesNewInvites"
                             runat="server" visible="false"
                            enableviewstate="false" /></asp:Label></a>
                    </li>
                </ul>
                <div id="colleagues-1">
                    <asp:Literal ID="uxColleaguesCurrent" runat="server" />
                </div>
                <div id="uxColleaguesInvitedPanel" runat="server">
                    <asp:Literal ID="uxColleaguesInvited" runat="server" />
                </div>
                <div id="uxColleaguesPendingPanel" runat="server">
                    <asp:Literal ID="uxColleaguesPending" runat="server" />
                </div>
            </div>
        </asp:View>
        <asp:View ID="uxColleaguesNone" runat="server">
            <p class="noColleagues">
                <asp:Image ID="uxNoColleagues" runat="server" />
            </p>
        </asp:View>
    </asp:MultiView>
    <CMS:Friends ID="cmsFriends" runat="server"
         Visible="false" MaxResults="200"  />
    <CMS:CommunityGroupMembers ID="cmsMembers"
         runat="server" Visible="false" />
</div>

The lines of particular interest are at the bottom, where you can see two references to two of the Ektron Framework's Server Controls, namely, the Friends Server Control (CMS:Friends) and the CommunityGroupMembers Server Control (CMS:CommunityGroupMembers). These two controls are placed side by side since this code file is shared across the implementation of the user and group profiles. On the user profile, the Friends Server Control is used to list a member's colleagues. On the group profile, the CommunityGroupMembers Server Control is used to display the group's members. Both of these controls have their visibility set to False, which means the display is being controlled through code. If you were to open its corresponding codebehind (Friends.ascx.cs), you would find the following code snippet:

private void GetUserProfile()
        {
            bool hasColleagues = false;
            string colleagues;
            XsltArgumentList xsltArgs;
            xsltArgs = new System.Xml.Xsl.XsltArgumentList();

            //Get Colleagues
            cmsFriends.DefaultUserID = this.ProfileId;
            cmsFriends.DisplayMode =
              Ektron.Cms.Controls.Friends.eDisplayMode.Directory;
            cmsFriends.DefaultFolderID = this.UserCookieData.CookieData.Colleagues.
Context[this.UserCookieData.CookieData.Colleagues.Context.Count - 1];
            cmsFriends.Hide = true;
            cmsFriends.Fill();
            xsltArgs.AddParam("mode", "", "colleagues");
            xsltArgs.AddParam("sitePath", "", this.contentApi.SitePath);
            xsltArgs.AddParam("permission", "", Enum.
GetName(typeof(UserPermission), this.UserProfileData.Permission).ToLower());
            xsltArgs.AddParam("profileMode", "", Enum.GetName(typeof(ProfileType),
this.Mode).ToLower());
            colleagues = EkXml.XSLTransform(cmsFriends.XmlDoc.InnerXml,
this.xsltPathCmsFriends, true, false, xsltArgs, false, null, Constants.
CacheProfileInterval);
            uxColleaguesCurrent.Text = colleagues;

In the underlying user control, the developer sets additional parameters to the Friends Server Control, namely, DefaultUserID, DisplayMode, and DefaultFolderID — the three most important parameters of the Friends Server Control.

The purpose of the DefaultUserID parameter is straightforward, with the specified value representing the default user ID that will be used by the control.

Since this server control has the ability to display four types of colleagues (current colleagues grouped by category, current colleagues listed in alphabetical order, pending colleagues, and invited colleagues), it is necessary to indicate which type you want returned. This is specified through the DisplayMode property, which is set to retrieve data in Directory mode (current colleagues grouped by category). The DefaultFolderID property correspondingly indicates which category colleagues should be selected from.

You may be wondering, though, why this code was manipulated in codebehind. Looking at this code further, it becomes apparent why the developer decided to set the control's visibility to False and to manipulate its display through codebehind: It presents a solution to a problem that many have run across previously. The problem is, when using the DisplayXSLT property of a server control, how can you pass along custom parameters to the transformation? The solution is one that can only be implemented in codebehind. You create an XsltArgumentList object, define your parameter values, and use the EkXml's transformation routine, which accepts an XSLTArgs object as a parameter. The result is the same had you used the DisplayXSLT property, with the exception and benefit that this transformation allows you to pass arguments.

Let's start by looking at how the ProcessRequest method defined in ~/Profile/Handlers/profile .colleagues.ashx handles various requests. It uses a switch statement to dispatch processing based on the type of action that is requested. The following snippet shows the relevant section of that ASHX handler:

public void ProcessRequest(HttpContext context)
        {
            //set header info
            context.Response.ContentType = "application/json";
            context.Response.Cache.SetNoStore();
            context.Response.Cache.SetRevalidation(
                HttpCacheRevalidation.AllCaches);

            GetTaxonomyTreeData();
            TaxonomyRequest taxonomyRequest;

            switch (this.Action)
            {
                case RequestAction.AddColleague:
                    this.friendsApi.AddPendingFriend(this.ColleagueId);
                    this.response = @"{""Status"":""OK""}";
                    break;
                case RequestAction.ApproveColleague:
                    this.friendsApi.AcceptPendingFriendForUser(this.ColleagueId,
                                                               this.UserId);
                    this.response = @"{""Status"":""OK""}";
                    break;

Reviewing the implementation details of some of the RequestAction handlers might not be necessary in some cases, as the source code spans only a few lines. However, there are others operations which are more complex, like the implementation for the RequestAction.AddFolder shown in the following code snippet, that need explaining:

case RequestAction.AddFolder:
                 try
                 {
                  //add new node
                  taxonomyData = new TaxonomyData();
                  taxonomyData.TaxonomyDescription = String.Empty;
                  taxonomyData.TaxonomyName = Convert.ToString(this.CategoryName);
                  // community items have no language;
                  taxonomyData.TaxonomyLanguage = 0;
                  taxonomyData.TaxonomyType = (this.Mode == ProfileType.User) ?
                      EkEnumeration.TaxonomyType.User : EkEnumeration.TaxonomyType.
Group;
                  taxonomyData.TaxonomyParentId =
                      long.Parse(this.RequestTaxonomyData.Id);
                  long newCategoryId =
                      contentApi.EkContentRef.CreateTaxonomy(taxonomyData);

                  //get new node
                  taxonomyRequest = new TaxonomyRequest();
                  taxonomyRequest.TaxonomyId = newCategoryId;
                  taxonomyRequest.TaxonomyType = EkEnumeration.TaxonomyType.User;

                  // limit the taxonomy to just the level required
                  taxonomyRequest.IncludeItems = false;
                  taxonomyRequest.ReadCount = false;
                  taxonomyRequest.Depth = 1;

                  taxonomyData = this.contentApi.LoadTaxonomy(ref taxonomyRequest);

                  //translate to treeview
                  TranslateTaxonomyData(taxonomyData);

                  //set response
                  this.response = this.jsonSerializer.Serialize(this.TreeView);
                 }

To understand the previous code snippet, you should first understand the use case for the code. In this instance, the use case is: "As a developer, I can create new folders for organizing colleagues." Allowing for this type of organization means that the user can place colleagues into logical groups based on their relationship to the colleague. For example, as a community member, you might choose to place all of marketing colleagues into a newly created folder called Marketing.

Looking at the implementation, you might be surprised to find references to Taxonomy APIs and Taxonomy data classes in code for creating a new folder. This is because taxonomy is actually an extremely central part of the Community Framework and it serves a number of important purposes. By default, every user in the system has a user taxonomy associated to it. Although there is only one user taxonomy per user (a one-to-one mapping between a user and user taxonomy), there are predefined user taxonomy categories created to manage the relationships between the user and other community-related items, such as community groups, colleagues, and content. These predefined categories are child categories of the root folder.

The two significant differences between user taxonomies and content taxonomies are that user taxonomies are not language-aware, and also, there is no UI for managing them in the Workarea.

Given this new information, it now becomes clearer why the RequestAction.AddFolder handler references the Taxonomy API to create a new "folder" for organizing colleagues. You're actually creating new categories for this information behind the scenes and through the process of categorizing colleagues, documents, and community groups. You're establishing an organized relationship between a user and these objects.

Exploring the ~/Profile/Handlers/profile.colleauges.ashx further, you will see a number of references to the Ektron.Cms.Community.FriendsAPI namespace. This provides an interface for performing many of the actions you'd expect to have, including the ability to issue friend requests and approve friend requests. The following code snippet from that file shows how to do each of these respectively.

case RequestAction.AddColleague:
                    this.friendsApi.AddPendingFriend(this.ColleagueId);
                    this.response = @"{""Status"":""OK""}";
                    break;
                case RequestAction.ApproveColleague:
                    this.friendsApi.AcceptPendingFriendForUser(this.ColleagueId,
                                                               this.UserId);
                    this.response = @"{""Status"":""OK""}";
                    break;

Another important point to know and highlight is how to retrieve a list of friends using the API. The following code snippet shows the procedures needed to get a list of colleagues for a given user. This code uses the same GetList/Criteria pattern that the Ektron's Framework APIs use (See Appendix B for more information about the Framework API, including cookbook style code snippets). The nice thing about the Framework API is its consistent use of GetList() for retrieving a list of items. Once you've used it, you know how to use it for other datatypes.

Ektron.Cms.API.Community.CommunityGroup groupApi =
          new Ektron.Cms.API.Community.CommunityGroup();

        Criteria<Ektron.Cms.CommunityGroupProperty> criteria =
          new Criteria<Ektron.Cms.CommunityGroupProperty>();
        criteria.AddFilter(Ektron.Cms.CommunityGroupProperty.GroupName,
                           CriteriaFilterOperator.StartsWith,
                           "H");
        List<Ektron.Cms.CommunityGroupData> groupList = groupApi.GetList(criteria);

        gvCommunitGroups.DataSource = groupList;
        gvCommunitGroups.DataBind();

The next code snippet shows how to retrieve a list of favorites using the same GetList/Criteria pattern. Notice the similarity between the two, despite the fact that they're querying for and returning entirely different datatypes.

Ektron.Cms.API.Community.CommunityGroup groupApi =
          new Ektron.Cms.API.Community.CommunityGroup();

        Criteria<Ektron.Cms.CommunityGroupProperty> criteria =

new Criteria<Ektron.Cms.CommunityGroupProperty>();
        criteria.AddFilter(Ektron.Cms.CommunityGroupProperty.GroupName,
                           CriteriaFilterOperator.StartsWith,
                           "H");
        List<Ektron.Cms.CommunityGroupData> groupList = groupApi.GetList(criteria);

        gvCommunitGroups.DataSource = groupList;
        gvCommunitGroups.DataBind();

In both cases you'll also notice that the lists are data-bound to data-bindable server controls like the .NET ListView Server Control and the GridView Server Control. This pattern can be replicated for many of the community datatypes, making the process of data retrieval intuitive and straightforward.

It is important to keep in mind that membership user groups and community groups are two completely different concepts and are used in entirely different use cases. There has been some confusion in the past about this, mostly because some use the terms "membership users" and "community members" interchangeably. To clarify this, CMS Administrators use membership user groups to grant content permissions to groups of membership users, whereas community groups are created by the community to facilitate information exchange around a topic or idea, as discussed here.

If you read through the previous section in this chapter titled "Users, Friends, and Profiles," recall that the OnTrek user profile had heavy client-side requirements and needed to use the Community Framework APIs for its implementation. If you haven't read that section yet, take a few minutes to do so. Much of what was described there, in terms of requirements and implementation approach, holds true for the group profile. In fact, OnTrek's group profile code is organized into the same three logical tiers discussed earlier (a presentation tier using jQuery, a middle tier encapsulating business logic using ASHX handlers, and a data tier using Ektron Framework APIs for CMS and data needs). In addition, it was implemented in such a way that a fair amount of the source code is shared across both the group and user profiles.

Community groups are used on the OnTrek website to facilitate conversations around the OnTrek product line. Since having this community group was a planned part of the initial site requirements and design, the group was created by a CMS admin. The following is a walkthrough of creating a new community group in the Workarea.

The source code for the Group Profile User Control can be found in ~/Profile/GroupProfile.ascx. As this was covered in the previous technical section, this section focuses on a few of the real workhorses of the profile, which are the user controls that are registered at the top of the document. These are:

Each is used to define the behavior of the main body of the profile. Which control is loaded is determined through the use of a .NET MultiView Server Control in the following way:

<asp:MultiView ID="mvProfileBody" runat="server">
                    <asp:View ID="vwGroup" runat="server">
                      <Ektron:Group ID="ucGroup" runat="server" Mode="Group" />
                    </asp:View>
                    <asp:View ID="vwMembers" runat="server">
                      <Ektron:Members ID="ucMembers" runat="server" Mode="Group" />
                    </asp:View>
                    <asp:View ID="vwDocuments" runat="server">
                      <Ektron:Documents ID="ucDocuments" runat="server"
                        Mode="Group" />
                    </asp:View>
                    <asp:View ID="vwBlog" runat="server">
                      <Ektron:Blog ID="ucBlog" runat="server" Mode="Group" />
                    </asp:View>
                    <asp:View ID="vwCalendar" runat="server">
                      <Ektron:Calendar ID="ucCalendar" runat="server"
                        Mode="Group" />
                    </asp:View>
                    <asp:View ID="vwForum" runat="server">
                      <Ektron:Forum ID="ucForum" runat="server" Mode="Group" />
                    </asp:View>
                    <asp:View ID="vwDashboard" runat="server">
                      <Ektron:Dashboard ID="ucDashboard" runat="server"
                        Mode="Group" />
                    </asp:View>
                    <asp:View ID="vwPhotos" runat="server">
                      <Ektron:Photos ID="ucPhotos" runat="server" Mode="Group" />
                    </asp:View>
                  </asp:MultiView>

When a user clicks the accordion item labeled "Members," the Members User Control is loaded. Looking up at the register statements on the top of the page, you can see that the Member control is defined in Friends.ascx. You might recall that you looked into this file in Listing 11-2 in the previous section, since the user and group profiles share this code file. In this section, you'll examine this file again, except this time you'll see how it is used to display a list of the group members. At the bottom of Listing 11-2, you'll find the following snippet:

<CMS:CommunityGroupMembers ID="cmsMembers" runat="server" Visible="false" />

The visibility for this control is set to false, which previously has meant that it is being used in codebehind. Opening ~/Profile/Accordion/Friends.ascx.cs, you see the following snippet defined for retrieving member information in the GetGroupProfile method. You can see it follows a very similar pattern to the User Profile implementation seen earlier. Specifically, it references the CommunityGroupMembers Server Control by its ID cmsMembers to populate the DefaultCommunityGroupID and DisplayMode properties.

private void GetGroupProfile()
        {
            this.communityGroupApi = new CommunityGroupAPI();

this.communityGroupData =
              communityGroupApi.GetCommunityGroupByID(this.ProfileId);

            this.xsltPathCmsFriends = this.contentApi.SitePath +
              "profile/xslt/cmsGroupMembers.xsl";
            bool hasColleagues = false;
            string colleagues;
            XsltArgumentList xsltArgs;
            xsltArgs = new System.Xml.Xsl.XsltArgumentList();

            //Get Members
            cmsMembers.DefaultCommunityGroupID = this.ProfileId;
            cmsMembers.DisplayMode = CommunityGroupMembers.eDisplayMode.Members;
            cmsMembers.Hide = true;
            cmsMembers.Fill();

            xsltArgs.AddParam("mode", "", "members");
            xsltArgs.AddParam("sitePath", "", this.contentApi.SitePath);
            xsltArgs.AddParam("permission", "",
                    Enum.GetName(
                      typeof(GroupPermission),
                      this.GroupProfileData.Permission).ToLower());
            xsltArgs.AddParam("isGroupAdmin", "",
                    this.GroupProfileData.IsGroupAdmin.ToString().ToLower());
            xsltArgs.AddParam("myId", "", this.UserId);
            xsltArgs.AddParam("groupAdminId", "",
                    this.communityGroupData.GroupAdmin.Id.ToString());
            colleagues = EkXml.XSLTransform(cmsMembers.XmlDoc.InnerXml,
                    this.xsltPathCmsFriends, true, false, xsltArgs, false,
                    null, Constants.CacheProfileInterval);
            uxColleaguesCurrent.Text = colleagues;

Table 11-3 shows a list of the commonly used properties of the CommunityGroupMembers Server Control, and a description of what the impact of each property is.

Another noteworthy section of the previous snippet is found at the top of the GetGroupProfile method, where you can see the CommunityGroupAPI being used to programmatically retrieve group information by the group's ID. This information gathers data that is passed as an XSLT argument into the XSLT transformation. At the bottom of the GetGroupProfile method, you can see that the result of this transformation is rendered to the page using an ASP.NET Literal Server Control.

To understand how to use an activity stream, look at the ActivityStream Widget illustrated in Figure 11-12. By default, this widget is configured to show all the activities from the current user's social network. When users log in and view this widget, they see all their colleagues' activities plus those activities that occur within the community groups to which the users belong. This activity stream also considers content and community group permissions; so for example, if a colleague posts a document to a private group that you do not belong to, you do not see it in your activity stream. Likewise, if you update private content that only you can see, none of your colleagues are notified of this event.

Figure 11.12. FIGURE 11-12

Users of the ActivityStream Widget can filter the activities by clicking the Filter button. Doing so opens a textbox that accepts the names of users and community groups and updates the widget's display to include the activities from only those names. The filtering defined on the widget persists in the widget storage (see Chapter 9). Therefore, you can use multiple ActivityStream Widgets on a PageBuilder Page or dashboard, with each instance of the widget having its own filter criteria. Users can also populate their dashboards with these widgets filtered in such a way as to improve the "signal to noise" ratio. For example, on an intranet, a marketing manager might filter the widget to display only activities from his direct reports. On a public website like OnTrek, site visitors might include only activities from OnTrek employees or other product experts.

A site visitor can also globally control what displays in the activity stream by managing activity preferences either through the site's membership profile settings or the Workarea (if they have Workarea permissions). Figure 11-13 shows the Activities settings screen, which has three sections:

In Figure 11-13 you'll also notice that, in addition to the Activity Stream column, there are two additional columns, SMS and Email, which you use to configure notification of activities on your mobile device or through your e-mail account. As you might have guessed from this screen, the activity stream system sits on top of a larger Notification Framework. This topic's "Under the Hood" section covers the Notification Framework and demonstrates its extensibility by showing how to create custom Notification Agents and custom Activity Types.

In addition to the ActivityStream Widget, there is a server control and APIs for working with and displaying activities. Much like its widget counterpart, the ActivityStream Server Control displays activities from the current user's social network of colleagues and community groups per their activity notification settings. The server control, however, does not provide the same type of user-driven filtering through the GUI as does the widget. Instead, you can programmatically control the ActivityStream Server Control through its API in codebehind; you must do any filtering using code like this:

// You can exclude the current user from the stream
activityStreamCtrl.ExcludeUserIds.Add(CurrentUserID);

// You can also choose to exclude certain groups
activityStreamCtrl.ExcludeGroupIds.Add(GroupId1);
activityStreamCtrl.ExcludeGroupIds.Add(GroupId2);

The control has a number of properties that modify its behavior, including displaying a particular community group or user's activities, or a set of users' activities. If you want to display the activity stream associated with a particular group instead of the logged-in user's activity stream, set the control's ObjectType property to User or Group to specify that the control is associated with a community group. Then set its DefaultObjectID property to the community group ID for the particular community group. The important point to note here is that once this configuration is made, the user who views this page will see the activities of this particular group, regardless if they're a member of the group or not.

This brings up a very important attribute of the activity and notification system. Although, by default, only those activities to which a user has permission to see will appear for them, developers can override this and force the server control to display activities from the global activities, which might not fall within the activities the logged-in user has specified in their settings. The ActivityStream API also has the same ability, that is to either retrieve activities and filter them according to community group, content permissions and configuration settings, or to allow a developer to define the logic that governs which activities display. A partial list of properties is listed in Table 11-4.

Looking through Table 11-4, you can see that you control the activity stream markup using XSLT by setting the DisplayXSLT property, just as you would for most Ektron server controls. Providing your own XSLT overrides the default presentation and allows you to customize how the activity stream displays. Keep in mind that any of the default functionality provided by the server control will be overridden as well, so you'll have to implement your own paging.

Another approach to customizing the activity stream markup is to query the activity stream using the Activity Stream API and then data-bind the results to a templatable server control like the ASP .NET ListView or Repeater Server Controls. This approach uses standard ASP.NET data binding and templating functionality and therefore means that your markup is controlled in an ASPX template or ASCX User Control. Listing 11-4 shows an ASPX template hosting an ASP.NET ListView Server Control to render a list of activities with custom markup.

<body>
  <form id="form1">
  <div>
    <h1>Activity Stream</h1>

    <asp:ListView ID="listViewActivityStream" runat="server">
       <LayoutTemplate>
          <div id="ActivityList">
            <asp:PlaceHolder ID="itemPlaceHolder" runat="server">
          </div>
       </LayoutTemplate>

       <ItemTemplate>
          <div id="ActivityMessage">
             <img class="ActivityAvatar" alt="Avatar"
                  src="<% #Eval("ActionUser.Avatar") %>"/>
             <span class="ActivityDisplayName">
               <%#Eval("ActionUser.DisplayName") %>
             </span>
             <div class="date"><%#Eval("Date") %></div>
             <div><%#Eval("Message") %></div>
          </div>

</ItemTemplate>

       <EmptyDataTemplate>
          <h3>No activities have been posted yet.</h3>
       </EmptyDataTemplate>
    </asp:ListView>

  </div>
  </form>
</body>

In Listing 11-5, you find the code that retrieves the activity list using the ActivityStream API. In this example, the GetUserActivityStream (long) method retrieves the activities from a particular user's social network. You can also use this API to retrieve a specific user's activities, or the activities for one or more community groups. Once you retrieve the activity list, the ASP.NET ListView's DataBind() method data-binds the activity list to the ListView Server Control.

Using Ektron.Cms;
using Ektron.Cms.Framework;
using Ektron.Cms.Activity;
using ActivityStreamApi = Ektron.CMS.Framework.Activity;

public partial class Developer_ActivityStream_CustomStreamDisplay :
    System.Web.UI.Page
{
   protected void Page_Load(object sender, EventArgs e)
   {
      DisplayActivityStream();
   }

   private void DisplayActivityStream()
   {
      PagingInfo pageInfo = new PagingInfo();
      pageInfo.TotalRecords = 10;

      ActivityStreamApi activityStreamApi = new ActivityStreamApi();
      long userId = activityStreamApi.RequestInformation.UserId;

      List<ActivityData> listActivities =
        activityStreamApi.GetUserActivityStream(userId);

      listViewActivityStream.DataSource = listActivities;
      listViewActivityStream.DataBind();
   }

The OnTrek site uses activity streams primarily to give site visitors a way to find the information being contributed (discovery), to give a greater understanding of what is happening within the community (awareness), and to allow site visitors to be notified of time-sensitive information, such as product security patches (notification). This is done through the activity stream integration on the community homepage, through the use of the ActivityStream Server Control. The implementation for this is very straightforward since it uses the standard ActivityStream Server Control with no customizations.

Although the activity stream framework is installed and enabled by default on all new installations of Ektron, upgrades from installations prior to version 8.0 have this feature disabled. The reason for this is that in order to enable the feature on upgrades, you must run a script that updates each user's default activity preference settings, which in some databases represents a very large number of records and could increase the time it takes to upgrade the site. For this reason, administrators wanting to use this feature must enable the feature manually once the upgrade process is complete. This is done in the Workarea by navigating to Settings

The messages that display in activity streams, although specific to the activity that has occurred (for example, "Derek is now friends with Gerson"), follow a general format that you define by following these steps:

The notification framework makes it possible to define custom activity types, which means that you can tailor the activities in an activity stream to the types of activities that are happening on that site. For example, on a website for stock traders, the activity stream could include messages such as "Bill rated the stock NAOC positively" or "Bill put the stock NNEJ on his favorites list." On an intranet, the activity stream could include a message such as "John logged in." Creating and raising a custom activity is a two-step process. The rest of this section walks through how to create a custom activity type that will be raised when a user logs into the site.

First, you must add a new Custom Activity definition in the Workarea.

Now, users must modify their preferences to define how they want to be notified when the User Logged In activity occurs. As shown earlier, this is controlled on the Users Activities preferences screen shown in Figure 11-17. Make sure to select the User Logged In checkbox on the Colleagues and My Activities sections.

Writing the code to raise a custom activity is a straightforward three-step process:

You can see an example of this in the following code snippet, which defines the RaisedLoggedInActivity() and encapsulates the code that defines the ActivityData object and then raises it. Because you want the custom activity to be raised anytime a site visitor logs in, you must insert a reference to the custom RaisedLoggedInActivity() method wherever your login processing logic is defined.

private void RaiseLoggedInActivity()
    {
         // The user is now logged in, get their ID
         Ektron.Cms.Framework.Activity.Activity activityApi =
           new Ektron.Cms.Framework.Activity.ActivityApi();
         ActivityUserInfo activityUser = new ActivityUserInfo();
         activityUser.Id = activityApi.UserId;

        // Define the "User Logged In" activity
        ActivityData activityData = new ActivityData();

       // Reference to the user that raised the activity
       activityData.ActionUser = activityUser;

       // Our activity type ID as defined in the Workarea
       activityData.ActivityTypeId = 1001;

       // The activity message that is put in the Activity Stream
       activityData.Message = "<p>I logged in</p>";

       // The language ID of this particular message
       activityData.LanguageId = 1033;

       // Raise the "User Logged In" activity
       activityApi.Publish(activityData);
     }

For more information on activity streams, take a look at the Ektron Developer screencast titled "Getting Activity Streams on Your Website," which includes a video walkthrough of some of these concepts and pointers to a Notification Architecture diagram as well as a document describing how to troubleshoot the notification system. See http://dev.ektron.com/getting-activity-streams-on-your-website/.