Project Programmability

This blog focuses on customizations and programming for Project Web App, Project Server, Project Professional and Project Standard. Includes User Interface (UI) customizations, Project Server Interface (PSI) and Visual Basic for Applications (VBA) Programming. It also covers Business Intelligence.
 
 

  • Project Programmability and Business Intelligence

    March 2013 update of the Project 2013 SDK download file

    • 6 Comments

    The Project 2013 SDK download is updated. The conceptual, how-to, and reference documentation in the download closely matches the Project 2013 developer documentation online content published on MSDN.

    The Project2013SDK.msi download file now installs properly on Windows 8 and Windows Server 2012.

    The Project 2013 SDK download contains:

    • The on-premises Reporting database schema reference, ProjectServer2013_ReportingDB.chm, and the OLAP cube schema reference. 
    • Updated VBA Help for local use. Objects such as Chart, Report, Series, and Shape now show correct members tables, properties, and methods topics.
    • Basic reference topics for the JavaScript client-side object model (JSOM), which includes REST endpoints and HTTP request syntax. You can use the JSOM for development of Project Online solutions for cross-browser web apps and for non-Windows platforms.
    • Sixteen complete code solutions, including two task pane apps (with minor updates) for Project, the QuickStatus app sample for Project Server and Project Online, eight client-side object model (CSOM) solutions, two solutions for querying the ProjectData service for reporting, and three updated legacy PSI solutions.
    • DLLs and a license for redistribution of the Project Server CSOM assemblies, JavaScript files for the CSOM, the Microsoft.Office.Project.Server.Library assembly, and the Microsoft.Office.Project.Server.Events.Receivers library for on-premises development.
      Notes:   1. The attached REDIST.zip file contains the RTM build 15.0.4420.1017 of the Project Server assemblies for redistribution.
                    2. The REDIST.zip file also includes the Microsoft.Office.Project.Schema.dll assembly, for developing event handlers.
                    3. Project CSOM solutions also require the redistributable DLLs for the SharePoint 2013 CSOM, 
                        which are at SharePoint Server 2013 Client Components SDK.
    • Updated Intellisense files for the PSI and CSOM, source code for creating a PSI proxy assembly, and instructions on how to update the PSI proxy files.
    • XML schemas for the Project client, AppProvisioning, and the Statusing PSI.

    The top-level online landing page for the Project SDK is Project for developers (http://msdn.microsoft.com/project).

    For additional Project-related SDK content, see Office for developers (http://msdn.microsoft.com/office), SharePoint for developers (http://msdn.microsoft.com/sharepoint), and Build apps for Office and SharePoint (http://msdn.microsoft.com/office/apps/). The two articles on Task pane apps for Project are in the Apps for Office and SharePoint SDK, and the JavaScript API for Office reference includes information specific for Project, the ProjectDocument object with eleven methods and three events, and four enumerations for Project.

    Want to try out Project 2013?

    1. Sign up for Project Online and Project Pro for Office 365
    2. Download Project Professional 2013 and Project Server 2013

    --Jim

  • Project Programmability and Business Intelligence

    MSDN Webcast: Project 2010 JS Grid Extensibility: Project Web App

    • 10 Comments

    Pat Malatack (Program Manager, Microsoft Corporation) has a comprehensive series of webcasts on extending the JS Grid in Project Web App.

    Note:  This blog post was originally created Monday, April 19, 2010. The webcasts were missing for the past several months, but have been reinstated on the Microsoft Events site (https://msevents.microsoft.com/).

    MSDN Webcast: Project 2010 JS Grid Extensibility: Project Web App (Part 1 of 3) (Level 400)
    Tuesday, April 20, 2010
    1:00 P.M.-2:00 P.M. Pacific Time
    This is the first webcast in a three-part series on extending grid pages in Microsoft Office Project Web App. In this webcast, we focus on initializing custom grid code and interactions between the grid and the Project Web App Ribbon. In particular, we show you how to add additional functionality to the Project Center.
     
    MSDN Webcast: Project 2010 JS Grid Extensibility: Project Web App (Part 2 of 3) (Level 400)
    Thursday, April 22, 2010
    1:00 P.M.-2:00 P.M. Pacific Time
    This is the second webcast in a three-part series on extending grid pages in Microsoft Office Project Web App. In this webcast, we focus on the use of events and delegates to interact with the timesheet grid in a way that allows for the addition of custom features and functionality to that page.
     
    MSDN Webcast: Project 2010 JS Grid Extensibility: Project Web App (Part 3 of 3) (Level 400)
    Tuesday, April 27, 2010
    1:00 P.M.-2:00 P.M. Pacific Time
    This is the third webcast in a three-part series on extending grid pages in Microsoft Office Project Web App. In this webcast, we walk you through more grid customizations, including adding custom commands to the column header dropdown and custom row header states.

  • Project Programmability and Business Intelligence

    Project Server 2013 reporting database (RDB) schema reference

    • 4 Comments

    The attached Project2013Reporting.exe file contains a draft release of the schema reference for the reporting tables and views in Project Server 2013. To install the files, run Project2013Reporting.exe. The next release of the Project 2013 SDK download will also include the reporting schema reference; that will be announced here when the Project 2013 SDK update is published.

    The Project Server 2013 RDB and OLAP cubes are accessible only with an on-premises installation of Project Server. For Project Online, you can use REST queries of the ProjectData OData service. The ProjectData service is also available with on-premises installations. For more information, see ProjectData - Project 2013 OData service reference in the Project 2013 SDK.

    The attached file includes the following:

    • ProjectServer2013_ReportingDB.chm is the HTML Help build of the RDB reference. It includes only the tables, views, stored procedures (SProcs), and user-defined functions (UDFs) that are in the dbo user namespace of the Project Server database. 

    Note: The draft, published, and archive database objects are not documented. Project Server 2013 combines objects from the four Project Server 2010 databases into one database. The default name of the database is ProjectService; different Project Web App instances can have different database names.

    • OLAPCubeSchemas2013.xlsx includes a worksheet for each of the 14 OLAP cubes that are available to build with Project Server 2013. Each worksheet lists the dimensions, measures, and properties that are available in the cube.

    The Project Server 2013 RDB includes three new tables, 27 new views, and a total of 33 tables and views that include new fields. You can easily find the new items by searching, for example, for “New field” (with quotes). The following screenshot shows the new ProjectVisibilityMode field in the dbo.MSP_EpmProject_UserView view:

    imgSearchNewField_84 

  • Project Programmability and Business Intelligence

    Building an app for Project Server 2013

    • 1 Comments

    Alex Burton, a Project MVP, has published a series of posts titled Building your first Project Server app on the EPMSource blog. The app is named Publish All; it publishes all enterprise projects for the PWA instance where the app is installed. The Publish All app is developed by using the Project Server JavaScript object model (JSOM) with "Napa" Office 365 Development Tools, and can be deployed to Project Online and to an on-premises installation of Project Server 2013.

    The blog series includes the following parts:

    Alex has even gone so far as to add a support page for the Publish All app, at http://epmsource.com/2013-apps/. It looks to be a very useful series.

    For more information about the Napa tools, see How to: Create a basic app for SharePoint by using Office 365 Development Tools on MSDN. For information about using Visual Studio 2012 with the JSOM for Project Server, see Getting started with the Project Server 2013 JavaScript object model.

  • Project Programmability and Business Intelligence

    Installing the Project 2013 SDK download on Windows 8

    • 0 Comments

    The Project 2013 SDK download is updated for the RTM release of Project 2013. In addition to articles, references, and code samples that are updated from the July release of Project 2013 Preview, the SDK also includes a local copy of VBA Help for Project Standard and Project Professional.

    You can install the downloaded Project2013SDK.msi file on computers that are running Windows 8, Windows 7 (and a couple of earlier Windows releases), Windows Server 2008 R2, and Windows Server 2012. When you install the SDK on a Windows 7 machine, the SDK contents are accessible from the Start menu. Figure 1 shows, for example, that the Microsoft SDKs folder contains the Project 2013 SDK folder, which contains links to three files. From the hierarchical context of the Start menu, it is clear that the Documentation node is contained in the Project 2013 SDK folder.

    Similarly, if you install the SharePoint 2013 SDK download and the Apps for Office and SharePoint SDK download, they each create a folder in Microsoft SDKs, and each SDK has a Documentation node within its folder.

    Figure 1. Using the Project 2013 SDK from the Windows 7 Start menu

    PJ15SDK_Start_Win7

    The problem

    Windows 8 does not have a Start menu, it has two related Start screens. After you install the Project 2013 SDK download, and scroll the main Start screen to the links for the installed files, you can see the same three links as in Windows 7. (To see the Welcome Guide on the Start screen, you can search for Welcome.rtf, open it in Internet Explorer, and then pin Welcome Guide to the Start screen.) But, the Start screen in Windows 8 is not arranged in hierarchical folders. In Figure 2, it is not clear what the Documentation link is for.

    Figure 2. Using the Documentation link to the Project 2013 SDK, on the Windows 8 Start screen

    Win8_StartScreen_Documentation

    The problem is worse if you also install the SharePoint 2013 SDK and the Apps for Office and SharePoint 2013 SDK. You would then have three Documentation links and three Welcome Guide links, each of which goes to a different SDK.

    If you right-click one of the Start screen icons, the icon shows a check mark, and the Start screen shows options at the bottom (see Figure 2). If you choose All apps at the bottom right of the screen, Windows 8 shows lists of installed apps within top-level groups. For example, the Microsoft SDKs group contains links for all of the Office, Project, and SharePoint SDKs that you install; there are no subfolders to distinguish which links go to which SDK. In Figure 3, only the Project 2013 SDK is installed, and the links have the same names as in Figure 2.

    Figure 3. Using the Project 2013 SDK links in the Apps view, in Windows 8

    Win8_AllApps_MicrosoftSDKs

    The workaround (for now)

    On a machine with Windows 8, you can install one SDK at a time, and then rename the links on the Start screen, before installing another SDK.

    To install Office, Project, and SharePoint SDKs on Windows 8

    1. Log on to Windows 8 as an administrator.
    2. Install, for example, the Project 2013 SDK.
    3. On the Start screen, right-click the Documentation icon, and then choose Open file location at the bottom of the screen.
    4. On the Windows Desktop, rename the Documentation link as Project 2013 SDK Documentation, and then choose Continue in the File Access Denied dialog box (see Figure 4).

      Figure 4. Renaming the Project 2013 SDK links in the Desktop view
      Win8_Rename_Documentation
    5. Similarly, rename the VBA Reference link as Project 2013 VBA Reference, and rename the Welcome Guide link as Project 2013 Welcome Guide.
    6. With the mouse pointer in the lower-left corner of the screen, choose the Start pop-up icon, and then scroll to the Project 2013 SDK icons (see Figure 5).

      Figure 5. Using the renamed links in the Start view
      Win8_StartScreen_ProjectSDK_Renamed
    7. Install the Apps for Office and SharePoint 2013 SDK, and similarly rename the Start screen links.
    8. Install the SharePoint 2013 SDK, and similarly rename the Start screen links. Figure 6 shows the Microsoft SDKs group with the renamed links in the All apps view.

    Figure 6. Using the renamed links for all three SDKs in the All apps view

    Win8_AllApps_3SDKs_Renamed

    In future releases, the Office, SharePoint, and Project SDK downloads will be reconfigured so that they install with non-conflicting link names on Windows 8.

     

  • Project Programmability and Business Intelligence

    Creating Project Workflows using Visual Studio 2012

    • 6 Comments

    In Project Server 2010, Project developers were able to create Project Workflows using Visual Studio 2010. In Project Server 2013, we enabled creating the workflows with SharePoint Designer, which makes it much easier and faster to create Project Workflows. In that blog post, we showed how we have simplified the workflow creation for Project using SharePoint Designer 2013.

    We are, however, still supporting creating Project Workflows with Visual Studio for the more complex set of workflows, and in fact, have also made it easier to create Project Workflows with Visual Studio 2012. Below, we are going to use a sample two-stage workflow to show how you can create workflows with Visual Studio 2012:

    1. Creating the Workflow solution: File Menu>New>Project>Office/SharePoint>SharePoint solutions > SharePoint 2013 Project. Give this project a name, and hit OK:
    clip_image002

    In the customization wizard, enter the address of the PWA web you’d like this workflow to be published to. Then, pick the sandboxed solution option to limit this workflow to this particular PWA web:
    clip_image004

    2. At this point, the project you’ll see the empty canvas. In the Project Menu, click on the Add New Item, and from the Office/SharePoint tab, select Workflow, enter a name, and hit Add:
    clip_image006

    Then, in the customization wizard, pick Site workflow:
    clip_image008

    Then, pick the history list and the workflow tasks list from that site. We recommend that you use the default lists since a number of PWA UI entry points, use these default lists. Then, hit Finish:
    clip_image009

    3. Now, we need to set up the environment to use the Project Server activities. In the toolbox, right click and click on “add tab”, and call the new tab “project server”:
    clip_image011

    Then, right click on the “project server” tab and click on “choose items” from the menu, and you’ll see this dialog:
    clip_image013

    In the dialog click on Browse, and navigate to where the workflow dlls are located. They are usually located in C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\15\TEMPLATE\WorkflowActivities
    You’ll see two activities dll there. Open the project server one (Microsoft.Office.Project.Server.WorkflowActivities.dll), and hit OK. You are now taken back to the “toolbox items” dialog, and highlights the selected corresponding activities. Hit OK to continue.
    clip_image015

    4. You might see a “sequence” in the canvas. Delete that, and from the toolbox, pick Flowchart and add it by dragging it into the main area. This flowchart will be the main container of all the stages of the workflow:
    image

    In the toolbox, click on Control flow, and add the sequence inside that flowchart. Throughout this sample workflow, we will use sequence to represent workflow stages in Visual Studio. This is similar to how SharePoint Designer handles each stage, i.e. each stage is equivalent to a separate sequence in Visual Studio:
    clip_image019

    Rename the sequence to “Create_Stage” by clicking on the “Sequence” and start typing to change the name. Drag the line from start to “Create_Stage” to connect them together:
    clip_image021

     

    5. Double click on the “Create_Stage” to drill into this sequence

    a. Under project server in toolbox, add the “EnterProjectStage” and “ExitProjectStageGate” activities to the sequence. These two activities are required in any of the PWA stages in Visual Studio.

    b. In the properties of “EnterProjectStage”, change the StageID to the Stage ID of the particular stage you’d want this sequence to represent. You can find the stage ID in the URL of that stage, and is available if you navigate to that stage in PWA Settings > Workflow Stages, and then click on the particular stage. Since stageID is a string, the ID should be provided in quotation marks.

    c. Put another sequence between “EnterProjectStage” and “ExitProjectStageGate”. Essentially, everything in this sequence is what is represented in the text-based designer in SharePoint Designer stage definition.

    d. From project server item in the toolbox, drop the “waitForProjEvent” activity in that sequence:
    clip_image022

    e. Change the EventName property to “OnProjectSubmit”. The other supported Event Names are “OnProjectCommit” and “OnProjectCheckIn”

    6. In the breadcrumb, click on Flowchart to go one level up. Add another sequence after Create_Stage and call it Finished_Stage, and connect the wire from Create_Stage to the Finished_Stage:
    clip_image023

    7. Similar to the Create_Stage, add the EnterProectStage and ExitProjectStageGate activities to the sequence as well as the WaitForProjectEvent activity in the middle, and set the properties accordingly:
    clip_image024

     

     

    8. This completes building the workflow in Visual Studio. However, in order to make sure that the workflow can be properly published to the PWA, we need to make a few more changes in the xaml files of the project: From solution explorer, pick “Elements.xaml” under the workflow node

    a. Replace the WSEventSourceGUID with the following so that the workflow is correctly identifies as a project workflow:
    <Property Name="WSEventSourceGUID" Value="5122D555-E672-4E5D-A7C4-8084E694A257" />

    b. Inject the following properties under the “Url = WorkflowStartAssociation”:
          <Property Name="Microsoft.ProjectServer.ActivationProperties.ProjectId" Value="" />
          <Property Name="Microsoft.ProjectServer.ActivationProperties.CurrentStageId" Value="" />
          <Property Name="Microsoft.ProjectServer.ActivationProperties.RequestedStageId" Value="" />
          <Property Name="WSEventContextKeys" Value="Microsoft.ProjectServer.ActivationProperties.CurrentStageId;#Instance&#xA;Microsoft.ProjectServer.ActivationProperties.ProjectId;#Instance&#xA;Microsoft.ProjectServer.ActivationProperties.RequestedStageId;#Instance&#xA;" />

    9. Now that everything is set, and the workflow is ready for publishing, click on the “Build Solution” under the Build menu, and then click on the “Deploy Solution” under the Build menu. The wsp file is now deployed to the site. You can also find a copy of the wsp file in the file system, under [project name]>bin>debug

    Now, the workflow will show up in PWA. If you navigate to PWA Settings > Enterprise Project Types, and create a new Enterprise Project Type, you will see this workflow as one of the options in the workflow dropdown list.

    For more information, see Getting started developing Project Server 2013 workflows in the Project 2013 SDK.

  • Project Programmability and Business Intelligence

    Connecting a Project Task Pane App to PWA

    • 2 Comments

    Introduction

    Apps for Office present a great new opportunity to bring data from a variety of sources into Office applications. The new Project specifically offers a very powerful way to surface both SharePoint and Project Web App data in a task pane app in Project Professional. To connect with SharePoint or PWA from the client, we use on-the-fly OAuth flow as presented in the SharePoint 2013 SDK. The App for Project described in this article connects with the same PWA site collection that Project Professional is currently connected to, and displays data about the currently selected task that is not otherwise available from within Project Professional. This will work with all versions of Project Professional (C2R, MSI, On Demand) and with all PWA environments (Project Online, Project Server).

    image

    Setup

    Prerequisites for this project are:

    • Visual Studio 2012
    • IIS or IIS Express configured to allow applications to run on your server (at localhost)
    • Office 2013 and SharePoint 2013 tools for Visual Studio, available here
    • Project Professional 2013
    • Project Online tenant or Project Server

    The first step is to launch Visual Studio 2012. Create a new App for Office 2013 project as shown below. Let’s call it “TaskLastModifiedApp”.

    image

    In the next dialog, make this a Task Pane App for Project.

    We need to add references, as this app will use a number of APIs across Office and SharePoint. These DLLs may be in a different location on your system. Most of these references are automatically added if you use the App for SharePoint template, so if you can’t find these on your system, create a quick App for SharePoint solution and note the reference paths to help you out. You should add:

    • C:\Program Files\Reference Assemblies\Microsoft\Windows Identity Foundation\v3.5\Microsoft.IdentityModel.dll
    • C:\Windows\Microsoft.NET\assembly\GAC_MSIL\Microsoft.IdentityModel.Extensions\v4.0_2.0.0.0__69c3241e6f0468ca\Microsoft.IdentityModel.Extensions.dll
    • C:\Program Files\Reference Assemblies\Microsoft\Windows Identity Foundation\v3.5\Microsoft.IdentityModel.WindowsTokenService.dll
    • C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\15\ISAPI\Microsoft.ProjectServer.Client.dll
    • C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\15\ISAPI\Microsoft.SharePoint.Client.dll
    • C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\15\ISAPI\Microsoft.SharePoint.Client.Runtime.dll
    • C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.IdentityModel.dll
    • C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.IdentityModel.Selectors.dll
    • C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.ServiceModel.dll

    Additionally, you will need to add a copy of TokenHelper.cs, which is generated when creating an autohosted or provider-hosted App for SharePoint project.

    Task Pane App Manifest

    The actual task pane app is just an XML manifest. Open up TaskLastModifiedApp.xml from the TaskLastModifiedApp project in your Solution Explorer. Replace its contents with the following:

     1: <?xml version="1.0" encoding="UTF-8"?>
     2: <OfficeApp xmlns="http://schemas.microsoft.com/office/appforoffice/1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="TaskPaneApp">
     3:   <Id>[leave this line alone]</Id>
     4:   <Version>1.0</Version>
     5:   <ProviderName>Microsoft</ProviderName>
     6:   <DefaultLocale>en-US</DefaultLocale>
     7:   <DisplayName DefaultValue="TaskLastModifiedApp" />
     8:   <Description DefaultValue="This app will show you when the selected task was last modified"/>
     9:   <AppDomains>
     10:     <AppDomain>https://localhost:44301/</AppDomain>
     11:   </AppDomains>
     12:   <Capabilities>
     13:     <Capability Name="Project" />
     14:   </Capabilities>
     15:   <DefaultSettings>
     16:     <SourceLocation DefaultValue="https://localhost:44301/pages/URLConstructor.aspx" />
     17:   </DefaultSettings>
     18:   <Permissions>ReadWriteDocument</Permissions>
     19: </OfficeApp>

    Replace the port after localhost (in both instances) with whatever port you have configured IIS to use for SSL. Make sure to toggle the “SSL Enabled” property on the TaskLastModifiedAppWeb project to true. Let whatever ID was originally set in the manifest remain.

    Architecture

    Next, delete the TaskLastModifiedApp.html page – we will need .aspx pages in this project. The basic architecture of the task pane app is as follows:

    • When the task pane app is launched, it loads “URLConstructor.aspx”, which pulls the PWA URL from the client and constructs a call to OAuthAuthorize with the proper tokens to request permissions for the app to access PWA data. This page loads “URLConstructor.js” to interact with the client.
    • OAuthAuthorize is launched in a new window, since we cannot predict the customer’s Project domain. After the user trusts the app, that new window is redirected to “PostOAuth.aspx”, which surfaces the auth code back to URLConstructor.aspx.
    • Once URLConstructor.aspx has the auth code, the task pane app is redirected with this as a token to “Default.aspx”, which has the functional code for the app. This page uses Project CSOM code in its code-behind page to read data from PWA, as well as “TaskLastModifiedApp.js” to interact with the client.

    Constructing the OAuthAuthorize URL

    The complete code for URLConstructor.aspx is as follows:

     1: <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="URLConstructor.aspx.cs" Inherits="TaskLastModifiedAppWeb.Pages.URLConstructor" %>
     2:  
     3: <!DOCTYPE html>
     4:  
     5: <html xmlns="http://www.w3.org/1999/xhtml">
     6:  
     7: <head runat="server">
     8:     <title>TaskLastModifiedApp</title>
     9:     <meta http-equiv="X-UA-Compatible" content="IE=9" />
     10:     <script type="text/javascript" src="..\Scripts\Office\1.0\MicrosoftAjax.js"></script>
     11:     <script type="text/javascript" src="..\Scripts\Office\1.0\Office.js"></script>
     12:     <script type="text/javascript" src="..\Scripts\URLConstructor.js"></script>
     13:     <script type="text/javascript">
     14:         function getClientId() {
     15:             var clientId = '<%=ConfigurationManager.AppSettings["ClientId"].ToString() %>'; //read the clientID from web.config
     16:             getPwaUrl(clientId); //return to client code
     17:         }</script>
     18: </head>
     19:  
     20: <body>
     21:     Redirecting...
     22: </body>
     23:  
     24: </html>

    This page needs to be an .aspx page in order to read from web.config, but does not need anything in its code-behind. The clientId read from web.config is needed for the authorization flow. getPwaUrl() is a function within URLConstructor.js.

    The complete code for URLConstructor.js is as follows:

     1: var _projDoc;
     2: var pwaUrl;
     3: var oAuthUrl;
     4:  
     5: Office.initialize = function (reason) {
     6:     _projDoc = Office.context.document;
     7:     getClientId(); //on document load, reads the ClientId from web.config first since it is server-side
     8: }
     9:  
     10: function getPwaUrl(clientId) { //uses Office App API to read PWA URL
     11:     _projDoc.getProjectFieldAsync(Office.ProjectProjectFields.ProjectServerUrl,
     12:         function (asyncResult) {
     13:             if (asyncResult.status == Office.AsyncResultStatus.Succeeded) {
     14:                 pwaUrl = asyncResult.value.fieldValue;
     15:                 generateUrl(clientId); //creates the OAuthAuthorize URL with necessary parameters
     16:             }
     17:             else {
     18:                 logMethodError("getProjectFieldAsync", asyncResult.error.name, asyncResult.error.message);
     19:             }
     20:         }
     21:     )
     22: };
     23:  
     24: function generateUrl(clientId) {
     25:     oAuthUrl = pwaUrl + "/_layouts/15/OAuthAuthorize.aspx?IsDlg=1&client_id=" + clientId + "&scope=Projects.Read&response_type=code&redirect_uri=https://localhost:44301/pages/PostOAuth.aspx";
     26:     authWindow = window.open(oAuthUrl);
     27:     codeListener(); //start listening for the auth code
     28: }
     29:  
     30: function codeListener() {
     31:     setTimeout(function () { readCode(); }, 1000); //check for the auth code every one second
     32: }
     33:  
     34: function readCode() {
     35:     try { //if we can actually reach the authCode field on PostOAuth.aspx
     36:         authCode = authWindow.document.getElementById("authCode").value;  //pull the authCode value
     37:         if (authCode != "NA") { //if it is not the default "NA"
     38:             authWindow.close(); //close the new window
     39:             document.location.href = "/Pages/Default.aspx?code=" + authCode; //redirect task pane to the app code with the authCode token
     40:         }
     41:     }
     42:     catch (e) {
     43:         codeListener(); //if we couldn't reach PostOAuth.aspx, wait another second and try again
     44:     }
     45: }

    When the task pane app loads, it first reads web.config from the aspx page, since this is server-side code. Once it has the clientId, we read the PWA URL. We then create the full OAuthAuthorize URL with the parameters specified above. scope=Projects.Read requests read permission to projects on the current PWA site. Make sure to match the SSL port here as well, as before.

    On running the app, a new window will open up outside of Project that prompts the user to login to PWA (if they have not checked “Keep me signed in” previously). They will then be presented with a “Do you trust…” page, the same as if they were installing an App for SharePoint. This is the OAuthAuthorize.aspx page. Once trusted, that new window navigates to PostOAuth.aspx, presented below:

     1: <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="PostOAuth.aspx.cs" Inherits="TaskLastModifiedAppWeb.Pages.PostOAuth" %>
     2:  
     3: <!DOCTYPE html>
     4:  
     5: <html xmlns="http://www.w3.org/1999/xhtml">
     6: <head runat="server">
     7:     <title></title>
     8: </head>
     9: <body>
     10:     <form id="form1" runat="server">
     11:     <div>
     12:     <asp:HiddenField ID="authCode" runat="server" value="NA"/>
     13:         Closing...
     14:     </div>
     15:     </form>
     16: </body>
     17: </html>

    And PostOAuth.aspx.cs:

     1: using System;
     2: using System.Collections.Generic;
     3: using System.Linq;
     4: using System.Web;
     5: using System.Web.UI;
     6: using System.Web.UI.WebControls;
     7:  
     8: namespace TaskLastModifiedAppWeb.Pages
     9: {
     10:     public partial class PostOAuth : System.Web.UI.Page
     11:     {
     12:         protected void Page_Load(object sender, EventArgs e)
     13:         {
     14:             var code = Request.QueryString["code"];
     15:             authCode.Value = code;
     16:         }
     17:     }
     18: }

    This page saves the auth code token in a hidden field. The task pane app, still on URLConstructor.aspx, waits for this value and then closes the new window. The app then continues on to default.aspx with the proper code token needed to finish the OAuth flow.

    Reading the Last Modified Date of the Selected Task

    The remainder of this article is an example of what you might do in your task pane app now that you have read access to PWA data. This example will show you the Last Modified date and time of the task you have selected. On launch, it shows you data for the selected task, and as you change tasks, the data is updated using an event handler.

    The complete code for Default.aspx is as follows:

     1: <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="TaskLastModifiedAppWeb.Pages.Default" %>
     2:  
     3: <!DOCTYPE html>
     4:  
     5: <html xmlns="http://www.w3.org/1999/xhtml">
     6: <head runat="server">
     7:     <title>TaskLastModifiedApp</title>
     8:     <meta http-equiv="X-UA-Compatible" content="IE=9" />
     9:     <script type="text/javascript" src="..\Scripts\Office\1.0\MicrosoftAjax.js"></script>
     10:     <script type="text/javascript" src="..\Scripts\Office\1.0\Office.js"></script>
     11:     <script type="text/javascript" src="..\Scripts\TaskLastModifiedApp.js"></script>
     12:     
     13: </head>
     14:  
     15: <body>
     16:     <form id="form1" runat="server">
     17:         
     18:         <asp:HiddenField ID="projGuidHF" runat="server" />
     19:         <asp:HiddenField ID="taskGuidHF" runat="server" />
     20:         <asp:HiddenField ID="pwaUrlHF" runat="server" />
     21:  
     22:         <asp:Label ID="TaskLastModLabel" runat="server" Text="Loading..." />
     23:  
     24:         <div style="display: none;">
     25:             <asp:Button ID="hiddenTaskChangedButton" runat="server" OnClick="OnTaskChanged" />
     26:         </div>
     27:  
     28:     </form>
     29:  
     30: </body>
     31: </html>

    This page contains three hidden fields used to pass data back and forth between the client-side code and the server-side code. It also leverages a label to surface the results to the user, and a hidden button that the client-side code uses to call a server-side function, as you will see below.

    The complete code for TaskLastModifiedApp.js is as follows:

     1: var _projDoc;
     2: var taskGuid;
     3: var projGuid;
     4: var pwaUrl;
     5:  
     6: // This runs after every postback
     7: Office.initialize = function (reason) {
     8:     _projDoc = Office.context.document;
     9:     if (document.getElementById("pwaUrlHF").value == "NA") { //if this is the first run
     10:         firstRun();
     11:     }
     12:     manageTaskEventHandler('addHandlerAsync'); //need to re-register event handler after each postback
     13: }
     14:  
     15: // Only need these on the first page load, not on postbacks
     16: function firstRun() {
     17:     getProjGuid();
     18:     _projDoc.getProjectFieldAsync(Office.ProjectProjectFields.ProjectServerUrl,
     19:         function (asyncResult) {
     20:             pwaUrl = asyncResult.value.fieldValue;
     21:             document.getElementById("pwaUrlHF").value = pwaUrl;
     22:         }
     23:     )
     24:     getTaskGuid();
     25: }
     26:  
     27: // Get the GUID of the selected task, comes from SDK
     28: function getTaskGuid() {
     29:     var TaskLastModLabel = document.getElementById("TaskLastModLabel");
     30:     TaskLastModLabel.innerHTML = "Loading...";
     31:     _projDoc.getSelectedTaskAsync(function (asyncResult) {
     32:         taskGuid = asyncResult.value;
     33:         document.getElementById("taskGuidHF").value = taskGuid; //saves the task GUID to a hidden field to pass to the code-behind
     34:         document.getElementById("hiddenTaskChangedButton").click(); //runs the CSOM calls in the aspx.cs file
     35:     });
     36: }
     37:  
     38:  // Get the GUID of the current project.
     39: function getProjGuid() {
     40:     _projDoc.getProjectFieldAsync(Office.ProjectProjectFields.GUID,
     41:         function (asyncResult) {
     42:             projGuid = asyncResult.value.fieldValue;
     43:             document.getElementById("projGuidHF").value = projGuid; //saves the project GUID to a hidden field to pass to the code-behind
     44:         }
     45:     )
     46: }
     47:  
     48: // Task selection changed event handler.
     49: function onTaskSelectionChanged(eventArgs) {
     50:     getTaskGuid();
     51: }
     52:  
     53: // Add or remove a task selection changed event handler.
     54: function manageTaskEventHandler(docMethod) {
     55:     manageEventHandlerAsync(
     56:         Office.EventType.TaskSelectionChanged,      // The task selection changed event.
     57:         onTaskSelectionChanged,                     // The event handler.
     58:         docMethod                // The Office.Document method to add or remove an event handler.
     59:     );
     60: }
     61:  
     62: // Add or remove the specified event handler.
     63: function manageEventHandlerAsync(eventType, handler, operation, onComplete) {
     64:     _projDoc[operation]   //The operation is addHandlerAsync or removeHandlerAsync.
     65:     (
     66:         eventType,
     67:         handler,
     68:         function (asyncResult) {
     69:             // code here runs after event has been registered (or failed)
     70:         }
     71:     );
     72: }

    The first time this code runs, it pulls the PWA URL (just like we did in URLConstructor.js) and saves it to one of our hidden fields, registers a client-side event handler to capture when a new task is selected, and starts the process of connecting to PWA and pulling the data we need, which is mostly done in the code-behind file. After each postback, we do not need to recapture the PWA URL, as our ProjectContext is maintained as a static variable.

    We need to make one quick tweak to TokenHelper.cs first – change GetRealmFromTargetUrl from a private method to a public method.

    The complete code for Default.aspx.cs is as follows:

     1: using System;
     2: using System.Collections.Generic;
     3: using System.Linq;
     4: using System.Web;
     5: using System.Web.UI;
     6: using System.Web.UI.WebControls;
     7: using Microsoft.ProjectServer.Client;
     8: using Microsoft.SharePoint.Client;
     9:  
     10: namespace TaskLastModifiedAppWeb.Pages
     11: {
     12:     public partial class Default : System.Web.UI.Page
     13:     {
     14:         public static ProjectContext projContext;
     15:         public static PublishedProject thisProj;
     16:         public Guid projGuid;
     17:  
     18:         protected void Page_Load(object sender, EventArgs e)
     19:         {
     20:             if (!IsPostBack) //set values of hidden fields if this is the first page load
     21:             {
     22:                 projGuidHF.Value = "NA";
     23:                 taskGuidHF.Value = "NA";
     24:                 pwaUrlHF.Value = "NA";
     25:             }
     26:         }
     27:  
     28:  
     29:         protected void GetContexts()
     30:         {
     31:             var code = Request.QueryString["code"]; //pulls the code token from the request
     32:  
     33:             string targetPwa = pwaUrlHF.Value; //pulls the PWA URL from where the Office app API stored it
     34:  
     35:             Uri targetPwaUri = new Uri(targetPwa);
     36:  
     37:             var tRealm = TokenHelper.GetRealmFromTargetUrl(targetPwaUri);
     38:  
     39:             Uri rUri = new Uri("https://localhost:44301/pages/PostOAuth.aspx"); //hardcoded link to redirect_uri
     40:  
     41:             var clientContext = TokenHelper.GetClientContextWithAuthorizationCode(targetPwa, "00000003-0000-0ff1-ce00-000000000000", code, tRealm, rUri);
     42:  
     43:             projContext = GetProjectContextWithAuthorizationCode(targetPwa, "00000003-0000-0ff1-ce00-000000000000", code, tRealm, rUri);
     44:  
     45:             projGuid = new Guid("{" + projGuidHF.Value + "}"); //loads the current project through CSOM
     46:  
     47:             var projects = projContext.LoadQuery(projContext.Projects.Where(proj => proj.Id == projGuid));
     48:             projContext.ExecuteQuery();
     49:             thisProj = projects.First();
     50:         }
     51:  
     52:         protected void OnTaskChanged(object sender, EventArgs e) //determine the selected task's last modified date
     53:         {
     54:             if (thisProj == null)
     55:             {
     56:                 GetContexts();
     57:             }
     58:             
     59:             var taskGuid = new Guid(taskGuidHF.Value);
     60:  
     61:             var tasks = projContext.LoadQuery(thisProj.Tasks.Where(task => task.Id == taskGuid)); //load the selected task off of the project
     62:             projContext.ExecuteQuery();
     63:             PublishedTask thisTask = tasks.First();
     64:             string dateMod = thisTask.Modified.ToString("D"); //pull out the Modified field on the task
     65:             string timeMod = thisTask.Modified.ToString("t");
     66:             TaskLastModLabel.Text = "The selected task was last modified on " + dateMod + " at " + timeMod + ".";
     67:         }
     68:  
     69:         public static ProjectContext GetProjectContextWithAuthorizationCode(string targetUrl,string targetPrincipalName,string authorizationCode,string targetRealm,Uri redirectUri)
     70:         {
     71:             Uri targetUri = new Uri(targetUrl);
     72:  
     73:             string accessToken =
     74:                 TokenHelper.GetAccessToken(authorizationCode, targetPrincipalName, targetUri.Authority, targetRealm, redirectUri).AccessToken;
     75:  
     76:             return GetProjectContextWithAccessToken(targetUrl, accessToken);
     77:         }
     78:  
     79:         public static ProjectContext GetProjectContextWithAccessToken(string targetUrl, string accessToken)
     80:         {
     81:             Uri targetUri = new Uri(targetUrl);
     82:  
     83:             ProjectContext projContext = new ProjectContext(targetUrl);
     84:  
     85:             projContext.AuthenticationMode = ClientAuthenticationMode.Anonymous;
     86:             projContext.FormDigestHandlingEnabled = false;
     87:             projContext.ExecutingWebRequest +=
     88:                 delegate(object oSender, WebRequestEventArgs webRequestEventArgs)
     89:                 {
     90:                     webRequestEventArgs.WebRequestExecutor.RequestHeaders["Authorization"] =
     91:                         "Bearer " + accessToken;
     92:                 };
     93:  
     94:             return projContext;
     95:         }
     96:     }
     97: }

    PageLoad()

    The first time the page loads, we need to initialize the hidden field values. This enables us to not set them directly in Default.aspx (and thus lose their values after a postback) and lets the client-side code distinguish between a first run load and a postback.

    GetContexts()

    This code also only runs once, assuming the current project remains loaded. This handles the last part of the OAuth flow – we use the code token from OAuthAuthorize to generate a client context and a project context using methods in TokenHelper.cs, as well as slightly modified methods GetProjectContextWithAuthorizationCode() and GetProjectContextWithAccessToken().

    OnTaskChanged()

    This first checks to make sure we have a project loaded from which to pull data. We then read the selected task guid from the hidden field, which was updated client-side before this method was called. We use Project CSOM to load the selected task from PWA and read its Last Modified field, which is then presented to the user in a readable format using the label on Default.aspx.

    Register the App ID and App Secret

    Since we are not submitting this app to the Office Store, we need to register it on our test tenant. On your tenant, navigate to https://[your PWA site]/_layouts/15/appregnew.aspx. Generate a new App Id and App Secret, set the Title to “TaskLastModifiedApp”, set the App Domain to localhost:44301 (or wherever the app code is running), and set the Redirect URI to match the redirect_uri token value in the oAuth URL created in URLConstructor.js.

    image

    Hit Create, and then add the App Id and App Secret to web.config in your Visual Studio solution. It should look like the following when you are done, with your values for ClientId and ClientSecret:

     1: <?xml version="1.0"?>
     2:  
     3: <configuration>
     4:     <system.web>
     5:       <compilation debug="true" targetFramework="4.0" />
     6:     </system.web>
     7:   <appSettings>
     8:     <add key="ClientId" value="a9ce3d5a-bb14-4aad-9c27-41a05c473b4d" />
     9:     <add key="ClientSecret" value="hL0C8wt2PPaBYNYRMZzcUcu3C/Vv0fbm48djGzyIXOw=" />
     10:   </appSettings>
     11: </configuration>

    Time to Test!

    To run the app, just hit F5 in Visual Studio, which will launch Project Professional. Make sure to connect to a PWA profile, then load a published project (or create and publish a new one). From a task view, select the Project tab in the ribbon, hit the dropdown for Apps for Office, and click TaskLastModifiedApp.

    image

    The app will launch in a task pane on the right side of the screen. It’ll prompt you to trust the app, quickly load, and then display the last modified date and time of the selected task.

    image

    Select a different task, and the data will update almost instantly.

    image

    Wrap-Up

    In this blog post, you have learned how to create a task pane app in Project Professional that can display data from PWA that would not normally be visible in the client. The app uses SharePoint’s OAuthAuthorize page to request permissions from PWA and handle the authentication handshake between the app code and your online data. For more on working with OAuth, make sure to check out the relevant node in the SharePoint 2013 SDK. For more information on PWA programmability, check out the Project 2013 SDK. To learn more about writing task pane apps for the new Project, see this node in the Office 2013 SDK.

  • Project Programmability and Business Intelligence

    New VBA classes and members in Project Professional 2013 Preview

    • 2 Comments

    The What’s new for developers in the new Project desktop (besides task pane apps) article is available in the Office Developer Blog. The VBA and VSTO object model includes includes classes that support new reports with charts, tables, and Office Art. Other new members in the Project object model support the new task paths feature, cache status, and working with tasks lists in SharePoint 2013.

  • Project Programmability and Business Intelligence

    Project 2013 Preview SDK and related resources

    • 0 Comments

    The Project 2013 Preview SDK download is published. The conceptual, how-to, and reference documentation in the download closely matches the Project 2013 developer documentation online content published on MSDN. In addition, the download also contains:

    • Ten complete code solutions, including two task pane apps for Project, six client-side object model (CSOM) solutions, and two solutions for querying the ProjectData service for reporting.
    • DLLs and a license for redistribution of the three Project Server CSOM assemblies, JavaScript files for the CSOM, and the Microsoft.Office.Project.Server.Library assembly.

      Note: Project CSOM solutions also require the redistributable DLLs for the SharePoint 2013 CSOM, which are at SharePoint Server 2013 Client Components SDK.
    • Intellisense files for the PSI and CSOM, source code for creating a PSI proxy assembly, and instructions on how to update the PSI proxy files.
    • XML schemas for the Project client, AppProvisioning, and the Statusing PSI.

    The top-level online landing page for the Project SDK is Project for developers (http://msdn.microsoft.com/project).

    For additional Project-related SDK content, see Office for developers (http://msdn.microsoft.com/office), SharePoint for developers (http://msdn.microsoft.com/sharepoint), and Build apps for Office and SharePoint (http://msdn.microsoft.com/office/apps/). The two articles on Task pane apps for Project are in the Apps for Office and SharePoint SDK, and the JavaScript API for Office reference includes information specific for Project, the ProjectDocument object with eleven methods and three events, and four enumerations for Project. Those SDK downloads are now published:

    Want to try out Project 2013?

    1. Sign up for the Project Online Preview with Project Pro for Office 365
    2. Download Project Professional 2013 Preview & Project Server 2013 Preview
  • Project Programmability and Business Intelligence

    Using the updated ChangeXML utility for Statusing

    • 0 Comments

    The Statusing methods in the Project Server Interface (PSI) in Microsoft Project Server 2010 enable one user to read, submit, and update assignment and task status for another user, without resorting to impersonation. In the Project Server 2007 SDK, the How to: Generate ChangeXML for Statusing Updates article shows how to generate the changeXml parameter for the UpdateStatus method, validate the XML, and use the ReadStatus and SubmitStatus methods. The Project 2007 SDK download includes the complete Visual Studio 2005 solution for the ChangeXML utility. However, the ChangeXML utility could only update status for the current user.

    The ChangeXML utility  is now updated for Project Server 2010, in the attached ChangeXMLUtility.zip file. With it, you can generate the changeXml parameter and update status for the current user or for another user. To update status for another user, the utility uses the ReadStatusForResource and UpdateStatusForResource methods. In addition, the utility checks whether the current user has the global StatusBrokerPermission security permission, adds the ResID attribute to the changeXml parameter, and validates the XML against the updated ChangeList.xsd schema in Project Server 2010. For more information about the ChangeList.xsd schema, see Introduction to the ChangeList Schema and Statusing ChangeXML.

    Note: The ChangeXML utility is designed for use only on a test installation of Project Server 2010, as an example of a programming utility for statusing. It should not be used on a production installation.

    The updated ChangeXML utility also has several other changes. The previous version uses the ASMX interface, which was the only choice available for Project Server 2007. In the updated version, you can choose to programmatically initialize the WCF interface of the PSI by entering the Project Web App URL, or by using the WCF endpoint values in the app.config file. In the following screenshot, the login is automatic if you use the app.config value.

            ChangeXML_LogOn_AppConfig

    Note: To use the app.config file, change the URL to the value for your PWA instance, for each PSI service endpoint.

    In the main window, after you log on Project Server, choose Build Change XML.

            ChangeXML_Main_Empty

    You can choose to update the status of available assignments for the current user, or – if you have the StatusBrokerPermission – you can choose another user and update assignments for that user. In the following screenshot, the update is for another user. The Items available for update list shows the Project name : Task name : User name values for each item. You can choose to update assignment values or task values for that assignment. The Generate a Change dialog box shows different controls in the Update section, depending on what kind of update you choose. For example, if you choose to update an assignment custom field, you can choose the custom field and the lookup table value, if the custom field uses a lookup table.

            ChangeXML_Generate_4User_Assign_HealthCF

    When you choose Update XML, the tool generates the changeXml parameter value, as follows:

            ChangeXML_Main_4User_Assign_HealthCF

    Following is the changeXml parameter value in the case shown, for updating the Health assignment custom field. Note that the XML value includes the ResID attribute for the Assn element.

    <Changes xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
      <Proj ID="a3e78597-2302-45fc-bb15-7f23d74efdf8">
        <Assn ID="b001d2d9-69eb-49a0-aa9f-6bbe53f9484c"
    ResID="aa3a6f6f-bb70-4d2e-92da-b06580ae6376"> <LookupTableCustomFieldChange IsMultiValued="false"
    CustomFieldType="Text"
    CustomFieldGuid="00004f6d-90a2-439a-8cc2-1c1ef6d2da4f"
    CustomFieldName="Health"> <LookupTableValue
    Guid="0000c45d-8a43-4eb0-9b74-e535b391988a">Late</LookupTableValue> </LookupTableCustomFieldChange> </Assn> </Proj> </Changes>

    You can clear the Run Update check box to just validate the changeXml parameter. For example, manually change one of the elements, attributes, or values in the XML, and see if it still validates. Or, you can check Run Update to validate and run the change.

    When the change is completed, try opening the project in Project Professional. If you are the project manager, you are prompted to review the status change in PWA. If you accept the change in PWA, to see the change, open the project in Project Professional. For example, if you changed the Health assignment custom field, go the the Task Usage view, and then add the Health field to the view.

            WinProj_OpenProject_AssnHealthCF_Changed

    After you save and publish the project, you can also see the change in the Reporting database. For example, run the following query in SQL Server Management Studio for the RDB:

    SELECT TOP 1000 [AssignmentUID]
          , [ResourceUID]
          , [Health_T]
        FROM [ProjectServer_Reporting].[dbo].[MSP_EpmAssignment_UserView]

    Find the correct assignment and resource GUIDs in the Results pane:

    SQLSrv_ReportingDB_EpmAssignment

    The ChangeXML utility is useful for creating and testing values of the changeXml parameter for the UpdateStatus method,
    where
    you can create and test changes for the current user and for other Project Server 2010 users. It also contains code examples
    that show how to check for a security permission of a resource and use statusing methods.

    Updating the ChangeXML utility

    Here are the main steps that were used to update the application from Project Server 2007 to 2010. The user interface had only
    minor tweaks, because that was not an issue for a test tool.

    1. Open in Visual Studio 2010 to update the solution; change the target to .NET Framework 3.5.
    2. Add a reference to the updated ProjectServerServices.dll, which contains a proxy WCF interface of the PSI services.
    3. Remove ASMX initialization; initialize PSI services for WCF (programmatic and/or with app.config). This step is not
      essential, but the WCF interface is recommended for moving forward.
    4. Modify the login dialog box; use the WCFHelpers.dll assembly from ProjTool for login routines. The ProjTool code for
      Project Server 2010 is in the SDK download.
      Note: The logon routines for Forms authentication are not updated in this sample.
    5. Get and display the StatusBrokerPermission value for the current user. Enable the Update for user option if the current
      user has the correct permission.
    6. Get the list of active resources, by using ReadUserList; add the ResourceItem class for combobox display and values.
    7. Refresh the list of items to update, by using ReadStatusForResource.
    8. Add ResID to classes for generating and displaying the changeXml parameter (ChangesProj, ChangesProjAssn,
      ChangesProjTask, and Items).
    9. Remove the empty ResID attribute in the changeXml value for the current user.
    10. Run statusing updates for a selected user, by using SubmitStatusForResource.
    11. Test

    In actuality, testing occurs after each step is completed.

    —Jim Corbin

  • Project Programmability and Business Intelligence

    MSDN Webcast: Building Integrated Applications on the Project Server 2010 Platform (Level 300)

    • 0 Comments

    It is our pleasure to host Catalin Olteanu, Chief Product and Technology Officer, UMT and former Principal Development Lead for Microsoft Project to talk about extending Microsoft Project 2010!

    Webcast Description:

    Now that Microsoft Project Server 2010 is built on Microsoft SharePoint Server 2010, developers can take advantage of a rich platform and familiar tools to effectively build integrated applications and provide customers with shrink-wrapped solutions to common problems. Join Catalin Olteanu to hear lessons learned from developing UMT Project Financial Server 2010 in parallel with the Project 2010 release cycle.
    Project Financial Server 2010 is a complex, three-tier application that seamlessly integrates with Project Server 2010 and extends many of the out-of-the box components including demand management, the ribbon, the queue service, permissions, web parts, and the reporting infrastructure.

    Date:

    Starts: Tuesday, September 20, 2011 8:00 AM
    Time zone: (GMT-08:00) Pacific Time (US & Canada)
    Duration: 1 hour(s)

    Register for Event today!

  • Project Programmability and Business Intelligence

    Where in the SDK are the Visio diagrams for the RDB?

    • 0 Comments

    The Project 2007 SDK download includes E-R diagrams of the major tables and views in the Project Server Reporting database. The Project 2010 SDK download does not include the Visio diagrams, although it does have the new RDB_Field_Selector.xls tool, along with the Project2010_ReportingDB.chm schema reference. You can easily create database diagrams by using either Visio Professional or Microsoft SQL Server Management Studio.

    For example, with a Visio diagram, you can see the relationships between the timesheet tables:

    TimesheetTables_84

    If you have Visio Professional 2010 and access to a Project Server 2010 Reporting database, you can reverse engineer the RDB to new database diagrams. Use the Visio diagrams in the Project 2007 SDK download as an example.

    With the Reverse Engineer Wizard in Visio, select the Microsoft SQL Server driver, and then create a new data source, for example:

    VisioReverseEngineerWizard

    … and then follow through the wizard to select the tables and views you want for each diagram. In the Project 2007 SDK, there are four E-R diagrams:

    • EPM User Views:  this is a very crowded page, suitable mainly for printing on a large sheet of paper.
    • EPM Relationships:  shows the main relationships between the views in the previous page.
    • Timesheet Tables
    • SharePoint Data:  shows the links from tasks and projects to the Issues and Risks views.

    To create diagrams using SQL Server Management Studio, expand a Project Server Reporting database, right-click the Database Diagrams folder, and then click New Database Diagram. Select the tables you want, and SQL Server arranges them in a useful manner so that relationship lines don’t cross. Following are the timesheet tables in the Project Server 2010 Reporting database:

    SQLDiagram_Timesheets_84

    Hover the mouse pointer over a relationship to show the relationship details.Database diagrams can help you derive T-SQL queries to build reports.

    Note:  When you create enterprise custom fields with lookup tables, Project Server creates additional views in the RDB, and can also create more column pool tables as required, for that instance of Project Web App.

    For more information, see  Custom Fields and the Reporting Database in the Project 2010 SDK.

  • Project Programmability and Business Intelligence

    You can use Project with SharePoint Composites, too

    • 1 Comments

    The Guide to creating SharePoint Composites includes a 73-page download that explains SharePoint Composites. To quote from the download, “A SharePoint Composite combines data, documents, and business process in a useful, productive way. … A SharePoint Composite is a ‘do-it-yourself’ business solution.” The SharePoint Composites.docx handbook includes a detailed introduction along with common design patterns that can help provide ideas on how to integrate and present data for collaboration and BI, by using SharePoint.

    Although the Office 2010 integration points section includes only a brief mention of Microsoft Project, the handbook overall is a useful introduction to the concepts. For those who work with Project and Project Server, the handbook can help to expand your view of what is possible – as well as what is useful.  Similar terms you might have heard in the past include mashup and OBAs (Office Business Applications). The SharePoint Composites handbook extends those ideas specifically for SharePoint-based solutions.

  • Project Programmability and Business Intelligence

    Update of Project 2010 SDK–Online and Download

    • 0 Comments

    The Project 2010 SDK download and the MSDN online release are both updated. The updates have the same URLs as previous releases:

    New conceptual / how-to topic:

    ·Topic updates for MSDN online, since the last update on March 7, 2011:
    20 conceptual and how-to topics have updates. Most changes are relatively minor; the Change History table at the bottom of each topic shows significant changes.

    • Assn Element
    • ChangeList Elements
    • ChangeList Schema Reference
    • Developing Project Server Workflows
    • How to: Create a Project Server Event Handler and Log an Event
    • How to: Create a Proxy Assembly for WCF Services (SP1 note)
    • How to: Modify the Ribbon in PWA
    • Introduction to the ChangeList Schema and Statusing ChangeXML
    • Introduction to the SetAssignmentWorkData Schema
    • Prerequisites for ASMX-Based Code Samples (SP1 note)
    • Prerequisites for WCF-Based Code Samples (SP1 note)
    • Project 2010 SDK Documentation (overview of the Project 2010 SDK)
    • Project Server 2010 Programming Tasks
    • Project Server Error Codes
    • SetAssignmentWorkData Elements
    • SetAssignmentWorkData Schema Reference
    • Supported Project Fields and Field Information for Statusing ChangeXML (updated the valid change types for the Actual Overtime Work and Remaining Overtime Work fields)
    • Tables of VBA Object Model Changes
    • Walkthrough: Developing PSI Applications Using WCF
    • What's New for Developers in Project 2010 (programmability changes for SP1)

    600 managed code types (classes that include new descriptions for one or more properties, methods, and events) are updated. There are new code samples for the following PSI methods:

    • QueueDeleteProjects
    • ReadResource
    • UpdateStatus
    • ReadProjectStatus
    • SubmitStatusForResource
    • ReadStatusForResource
    • ReadEventHandlerAssociationsForEvent
    • UpdateEventHandlerAssociations
    • CreateEventHandlerAssociations

    New / updated items in the Project 2010 SDK download, which was last updated March 7:

    • Project2010SDK.chm is an HTML Help file that includes the same updated content that is online. In the managed code reference section, 99.8% of the types and members now have descriptions (26,530 out of a total 26,576 topics). That is up from 77.7% at RTM.
    • WINPROJ.DEV.hxs remains unchanged from the March update of VBA Help. There are instructions for replacing the local VBA Help file that was shipped with the Project RTM release.
    • IntelliSense files are updated for the PSI proxy assembly and the Project Server assemblies, to show descriptions of classes and members while programming in Visual Studio. The type and member descriptions have the same updates as in the HTML Help file (and in MSDN online).
    • The Microsoft.Office.Project.Server.Library.dll assembly is updated for distribution with third-party solutions for SP1.
    • Event handler solution: TestProjectEventHandlers.
    • Test application for the Queue System: UsingQueueSystem shows an example of when to wait for the queue, and when you don’t need to wait.
    • ProjTool has a minor update, so the functionality of the Project Details dialog matches the description in Using the ProjTool Test Application.
    • New PSI code samples include complete WCF-based solutions for the following events: ProjectEventReceiver: OnCreating, OnCreated, OnSaved. Other new solutions show the use of the following PSI methods: QueueDeleteProjects, CreateEventHandlerAssociations, UpdateEventHandlerAssociations, ReadEventHandlerAssociationsForEvent, using the ReadResources and ReadResource methods to get the RBS custom field, creating a changeXml parameter for a different resource with the UpdateStatus method, and using SubmitStatusForResource and ReadStatusForResource.
  • Project Programmability and Business Intelligence

    Timesheet Solutions for Webcast: Understanding the PSI in Project Server 2010

    • 1 Comments

    The MSDN Webcast: Understanding Project Server Interface (PSI) in Project Server 2010 (Level 300) presentation is available for download, when you register for the event. Several of the sample applications that were demonstrated in the webcast are available in the Project 2010 SDK download. The TimesheetSamples.zip file that is attached to this blog post includes the two example solutions for timesheets. (Steven Haden and Olivier Laymand, Microsoft Corporation, did the webcast and created the sample code.)

    • MyTsSample shows how to update a  timesheet for a resource, where the timesheet is in single entry mode.
    • TimesheetEventHandler shows how to use impersonation with a TimesheetEventReceiver.OnCreated event handler, to update the timesheet name.
  • Project Programmability and Business Intelligence

    Statusing for Manually Scheduled Tasks in Project 2010 SP1

    • 0 Comments

    Service Pack 1 (SP1) for Project Server 2010 enables you to use the UpdateStatus method to edit timephased data for manually scheduled tasks. Before SP1, you could update status only for automatically scheduled tasks. The attached UpdateStatus_ManualTasks.zip file contains the Visual Studio 2010 solution that will be included in the next update of the Project 2010 SDK download.

    The UpdateStatus_ManualTasks example is a test application that does the following, for a manually scheduled task or an auto-scheduled task:

    • Parses the project name, task name, number of hours worked, the optional assigned resource, and an optional status comment.

    • If no resource is specified, assumes the application user is assigned to the task.

    • Gets the GUID for the user assigned to the specified task.

    • Gets and validates the assignment data. Assumes only one resource is assigned.

    • Creates the changeXml string for the UpdateStatus method. For a simple test, converts reported hours to percent complete (maximum 100). If the application user specifies a different resource, adds the ResID attribute to the Assn element in the changeXml string.

    • Calls UpdateStatus, and then calls SubmitStatusForResource, for the single assignment.

    • Calls ReadStatusForResource to get an updated StatusingDataSet.

      The application also writes the datasets and the changeXml value to XML files, for use in testing.

    Note:  Until you install SP1, the UpdateStatus test application will work only with automatically scheduled tasks. SP1 will be available the end of June, 2011.

    To use the UpdateStatus test application, do the following:

    1. Use Project Professional to create a test project, add two manually scheduled tasks, set the task duration and start date, and then add yourself and one other user as resources. Assign one task to you and the other task to the other user.

      For example, name the project Test project, name the tasks T1 and T2, and then set the duration of each task to three days. Assume your user name is User 1, and the other user is User 2. Assign T1 to User 1 and assign T2 to User 2.

    2. In the app.config file, change the WCF endpoint address for the Project Web App instance you are using.

    3. Run tests, using various parameters. See the Usage method in the attached Program.cs file for parameter information. For example, run the following tests in a Command Prompt window:

      • UpdateStatus -p "Test project" -t "T1" -hours 6 -c "This is a comment"

        The output shows:
        Updating status for User 1 on task 'T1': 6 hours
                Manually scheduled task
      • UpdateStatus -p "Test project" -t "T1" -hours 6 -r "User 2" -c "This is a comment"

        User 2 is not assigned to task T1, so the output shows:
        The assignment on task 'T1' is for User 1, not for User 2
      • UpdateStatus -p "Test project" -t "T2" -hours 6 -r "User 2" -c "This is a comment"

        The output shows:
        Updating status for User 2 on task 'T2': 6 hours
                Manually scheduled task

    After each test, check the Approval Center in Project Web App for status updates.

    When you add a manually scheduled task that does not have a start date or duration, the default is eight hours of work. You can still assign a resource to the task and update the status.

    For example, if a task T3 has no start date or duration, and you use the UpdateStatus test application to set six hours of work for the assigned resource, Project Server sets the start date for T3 to the project start date, and then adds six hours of actual work. After accepting the status update, you can add the Actual Work column and the Remaining Work column to the Gantt Chart view in Project Professional . The work for T3 is eight hours, actual work is six hours, and remaining work is two hours.

    Gantt_6hWork

    If you add the Actual Work row to the Details pane in the Resource Usage view or the Task Usage view, you can also see the six hours of actual work.

    ResourceUsage_6hWork

    For more information about changes in SP1, see Announcing Service Pack 1 for Microsoft Project & Project Server 2010 in the Project team blog.

  • Project Programmability and Business Intelligence

    Upcoming MSDN Webcast (6/23): Understanding Project Server Interface (PSI) in Project Server 2010 (Level 300)

    • 0 Comments


    Just to highlight a webcast not to miss…

    Starts: Thursday, June 23, 2011 8:00 AM, Time zone: (GMT-08:00) Pacific Time (US & Canada)
    Duration: 90 Minutes

    This webcast helps you understand the changes and new features of Project Server Interface (PSI) in Microsoft Project Server 2010. We cover the following topics: dual interface ASMX and WcfImpersonation with WCFTimesheet, event handlers with impersonation, Single Entry Mode (SEM), and using a Project Web App (PWA) web part in other Microsoft SharePoint sites.

    Presenters:
    Steven Haden, Senior Consultant, Microsoft Corporation and Olivier Laymand, Senior Consultant, Microsoft Corporation
    Steven Haden is a senior consultant working for Microsoft Services in France. He is involved in large Microsoft Project Server and Microsoft SharePoint deployments. Steven is interested in both the architecture and the development of solutions. He is the author of the white paper "Hitchhiker's Guide to Demand Management"; to download it, visit http://go.microsoft.com/fwlink/?LinkId=200608.
    Olivier Laymand is senior consultant from Microsoft Services working on large SharePoint and Project Server deployments. He is involved in solution architecture definitions, development best practices and governance.

    More details and registration.

  • Project Programmability and Business Intelligence

    Upcoming WebCast: Project Server Development for SharePoint Developers (Level 300)

    • 0 Comments

     

    Let me highlight the following webcast that we conduct Thursday, May 05, 2011 8:00 AM (GMT-08:00) Pacific Time. Make sure to register now to get automatic reminder!

    MSDN Webcast: Project Server Development for SharePoint Developers (Level 300)

    Language(s): English.

    Product(s): Microsoft Project 2010

    Audience(s): Pro Dev/Programmer

    This webcast covers the Microsoft Project Server development features from a Microsoft SharePoint developer's perspective. We explain the logical architecture of Project Server in a SharePoint farm and compare the development features. We also give real world examples such as the ribbon UI, Windows Communication Foundation (WCF) server programming, web part with JS Grid, Workflow for Demand Management, and cmdlets for Windows PowerShell. The key takeaway is for SharePoint developers to understand the similarities in development to be able to join the Project Server developer community.


    Presenters: Steven Haden, Senior Consultant, Microsoft Corporation and Olivier Laymand, Senior Consultant, Microsoft Corporation


    Steven Haden is a senior consultant working for Microsoft Services in France. He is involved in large Microsoft Project Server and Microsoft SharePoint deployment. Steven is interested in both the architecture and the development of solutions and is the author of the white paper "Hitchhiker's Guide to Demand Management" (http://go.microsoft.com/fwlink/?LinkId=200608).


    Olivier Laymand is a senior consultant from Microsoft Services working on large Microsoft SharePoint and Microsoft Project Server deployments. He's involved in solution architecture definitions, development of best practices, and governance.

  • Project Programmability and Business Intelligence

    Project Developer Curriculum and Project Development for SharePoint developers

    • 0 Comments

    To help Microsoft SharePoint 2010 and Project 2010 developers conveniently find all relevant resources for Project 2010 development we have created unified information center “Project Developer Curriculum” that references all key resources – from blogs, SDK chapters, SDK code samples, Solution Starters to extensive list of on demand webcasts.

    This addition to strong Project Developer Center also talks specifically to SharePoint developers offering development approach comparison. We are preparing a separate webcast dedicated to this topic MSDN Webcast: Project Server Development for SharePoint Developers (Level 300) - Thursday, May 5, 2011 at 8:00 A.M.–9:30 A.M. Pacific Time (subject to change). Make sure you register now to get the reminder before the webcast!

    Q&A

    Q: What are the key resources for Project 2010 Developers
    A: Project Developer Curriculum is an awesome unified resource –in addition - Project Developer Center and SDK http://msdn.microsoft.com/project/ and Project Programmability blog http://blogs.msdn.com/project_programmability/  are great information resources.

    Q: Any ‘quick start’ type of technical training for Project 2010?
    A: Here you go http://www.microsoft.com/project/en/us/quick-start-training.aspx!

    Q: Is there any Project 2010 Demo Image?
    A: Yes, it’s available as Project 2010 Demonstration and Evaluation Pack for the 2010 Information Worker Demonstration and Evaluation Virtual Machine and as hosted experience as well - http://technet.microsoft.com/en-US/evalcenter/ee410540.aspx. Make sure to check the following recording for details.

    Q: Any additional generic Project 2010 resources?
    A: Product information, forums, partners, videos, training and learning resources and many more here.

    Thanks Steven and Jim for you contribution!

  • Project Programmability and Business Intelligence

    Learn How To Build a Silverlight App for PWA. . .

    • 0 Comments

    . . . which is, after all, a SharePoint application.

    See the SharePoint and Silverlight Training Course. It includes 30 hands-on labs, including labs on accessing data through WCF services.

  • Project Programmability and Business Intelligence

    Reading Enterprise RBS values: the Easy Way and the Not-So-Easy Way

    • 2 Comments

    There are a couple of ways to programmatically get the Resource Breakdown Structure (RBS) value for a Project Server user. The simplest way is to query the Reporting database, for example:

    SELECT [ResourceUID] ,[ResourceName] ,[ResourceBookingType] ,[ResourceIsActive] ,[RBS] FROM [ProjectServer_Reporting].[dbo].[MSP_EpmResource_UserView] AS res WHERE res.ResourceName = N'Linda Jones'

    The result on my machine is:

    ResourceUID

    ResourceName

    ResourceBookingType

    ResourceIsActive

    RBS

    0D455775-01CB-42E1-A481-A6F0F1F8208A

    Linda Jones

    0

    1

    User Assistance.DevDocs.SDK Writers

    To get the RBS by using the PSI is a bit more work. Because the RBS is an enterprise resource custom field that uses the RBS lookup table, you can use the following steps:

    1. Call the ReadResources method and filter the primary Resources table for the user name and GUID. Alternately, you can use the ReadUserList method to get all of the active resource names and GUIDs, and iterate through the ResourceDataSet for the specific resource. The attached example uses the –userList command line argument to have the application use the ReadUserList method, and displays the elapsed time for the method used.
    2. Call ReadResource with the resource GUID to get the full ResourceDataSet.
    3. Iterate through the ResourceDataSet.ResourceCustomFields table to get the CODE_VALUE for the RBS custom field (if it exists).
    4. Use a filter with the ReadLookupTables method to get a LookupTableDataSet that contains only the LookupTableTrees table for the RBS lookup table.
    5. Iterate through the LookupTableTrees table to get the LT_VALUE_FULL string that corresponds to the CODE_VALUE in the RBS custom field.  The LookupTableTrees row where the LT_STRUCT_UID element matches the  custom field CODE_VALUE contains the correct RBS string.

    The attached example also writes the various datasets to XML files, for debugging purposes. Keep in mind that the app user must have the ManageUsersAndGroups global permission, and the other permissions specified in the SDK topics for the methods used, in order to read data of other resources.

    The attached ReadRBS.zip file contains the complete Visual Studio solution for the example described in this post. To use the sample, change the server name and Project Server name for the endpoint addresses in the app.config file. The sample uses the WCF interface for Project Server 2010; however, it can be adapted to use the ASMX interface for Project Server 2007.

    For example, the following command gets the same RBS value shown by the Reporting database query:

    C:\Test>ReadRbs -name "Linda Jones"

    XML output from ReadResources:
            C:\Project\Samples\Output\RBS_ReadResources_UserInfo.xml

    Using ReadResources method: 412.309 milliseconds

    XML output from ReadResource:
            C:\Project\Samples\Output\RBS_ReadResource_FullUserInfo.xml

    XML output from ReadLookupTables:
            C:\Project\Samples\Output\RBS_LookupTable.xml

    User name: Linda Jones
            GUID: 0D455775-01CB-42E1-A481-A6F0F1F8208A
            RBS value: User Assistance.DevDocs.SDK Writers

    Press any key to exit...

  • Project Programmability and Business Intelligence

    Trials and Tribulations in Customizing the Project Center Ribbon

    • 0 Comments

    The How to: Modify the Ribbon in PWA article in the Project 2010 SDK works for the cases in the article, but in other cases, you can get a JavaScript error when you try to hide some ribbon controls in PWA. For example, if you hide the Zoom and Show/Hide groups in the Project Center ribbon, a JavaScript error occurs while debugging the Visual Studio project, and all of the ribbon controls are disabled on that page. The error occurs only for controls in the Show/Hide group.

    Here is the standard Project Center ribbon. The Visual Studio 2010 project that hides the Zoom group and the Show/Hide group is in the attached ProjCenter_Hide2Groups.zip file.
    ProjCenter_Default

    Here is the solution for the Project Center ribbon customization issue - at least with three of my machines, all of which have Internet Explorer 9, with both 32-bit and 64-bit IE. I did not test with IE8. The problems may be solved, or may be different, with future updates or different versions of Internet Explorer.

    1. Make sure you are running IE9 RTM (9.0.8112.16421). 

      On my Windows Server 2008 R2 machine, there was an earlier IE9 RC (9.0.8080.16413) build installed. When the ribbon customization feature was deployed, all of the ribbon controls were disabled on the Project Center page. When debugging in IE with F12, the Script tab shows:

      SCRIPT5022: Attempting to attach to Id: Ribbon.ContextualTabs.ProjectCenter.Home.ShowHide but this id is not present in the DOM
      cui.debug.js?rev=seEKIhJXfBClfYcr46fd3w%3D%3D, line 1282 character 13

    2. On Windows Server 2008 R2 (the development machine), open Internet Options in IE. On the Security tab, make sure that Enable Protected Mode is checked. If you change that option, restart IE.
      If the Enable Protected Mode option is not checked, all of the ribbon controls on the Project Center page are disabled, and the script error shows in the F12 IE debugger. With the earlier build of IE9, it didn't matter - the ribbon controls were disabled for Enable Protected Mode checked or unchecked.
      ControlsDisabled
    3. Note:   When viewing the Project Center page in IE9 on Windows 7 64-bit, it doesn't matter whether the Enable Protected Mode option is checked or not - the ribbon controls are enabled as expected:
      ControlsEnabled
    4. When you are developing the ribbon customization in Visual Studio 2010, test hiding controls one-by-one, before hiding an entire group. Run F5 after each change, to see the effect. That is fairly quick to do by using F5 in Visual Studio. For example, hiding the three Navigate controls works fine in the VS debugger, but hiding either of the ShowHide group controls results in the following error, as shown in the Visual Studio debugger. The error is in the dynamic cui.debug.js script:
      $3v: function() {ULSpEN:;
              var $v_0 = $get(this.$6_0);
              if (!CUI.ScriptUtility.isNullOrUndefined($v_0)) {
                  this.set_$2($v_0);
              }
              else {
                  throw Error.create('Attempting to attach to Id: ' + this.$6_0 + ' but this id is not present in the DOM');
              }
          },
      ProjCednter_VSError
    5. Break if you get that error, exit IE, and you can still deploy the solution and try it outside of the Visual Studio debugger. In the Solution Explorer, right-click the project, and then click Deploy. In my case, the ShowHide controls were hidden, and the ribbon controls were enabled as expected – so long as the Enable Protected Mode is checked in IE, and IE9 is the RTM build.

    I don't have an explanation of why this happens, but the previous steps are what works (on my machines – the famous WOMM test). You might find different issues, depending on your software versions and whether the Sun is having a coronal mass ejection that day. I suspect it is a combination of problems of the Javascript implementation in the Internet Explorer build version (naturally, it couldn't be Project Server's problem!).

  • Project Programmability and Business Intelligence

    Update of the Project 2010 SDK (March 2011)

    • 0 Comments

    The Project 2010 SDK download and the MSDN online release are both updated. They have the same URLs as previous releases:

    New conceptual and how-to topics:

    Topic updates since January 14, which was the previous MSDN online update:
    18 conceptual and how-to topics have relatively minor updates.
    50 managed code types (plus subtopics for properties, methods, and events) are updated, including new code samples for:

    New / updated items in the Project 2010 SDK download, which was last updated Sept. 2010:

    • Project2010SDK.chm is an HTML Help file that includes the same updated content that is online.
    • WINPROJ.DEV.hxs is an update of VBA Help that includes the latest changes in the VBA object model documentation. There are also instructions for replacing the local VBA Help file that was shipped with the Project RTM release.
    • IntelliSense files are updated for the PSI proxy assembly and the Project Server assemblies, to show descriptions of classes and members while programming in Visual Studio.
    • Event handler solutions: TestCreatingProject, TestCreatedCustomField
    • OLP sample is a solution that uses the following PSI methods: ReadProjectList, ReadProject, ReadWssData, ReadTaskWebObject, CreateWebObjectLinks, ReadTaskLinkedWebObjects, DeleteWebObjectLink
    • ProjTool complete solution, updated for Project 2010.
    • PWA Ribbon Customization solution.
    • New PSI code samples include complete WCF-based solutions for code samples that are published in the managed code reference, for the following methods: CreateResource, ReadResource, ReadResourcePlan, QueueCreateResourcePlan, QueuePublishResourcePlan, ReadDriverList, ReadPrioritization, and CreatePrioritization.
    • Microsoft.Office.Project.Server.Library.dll, file version 14.0.4999.1061, and redistribution license.

    --Jim

  • Project Programmability and Business Intelligence

    IE9 Jump List for Project Server

    • 0 Comments

    Alex Burton, a Project MVP in Australia, wrote a blog post, Creating a Internet Explorer 9 Jump List for Project Server.

    ProjectServerJumpList

    Very handy and easy to deploy by a Project Server administrator, to be available to any PWA user with IE9 who pins the PWA landing page to the Windows 7 taskbar.

  • Project Programmability and Business Intelligence

    Office 2010 Interactive Developer Map

    • 0 Comments

    The Microsoft Office 2007 interactive developer map has been available for several years, which is very handy for finding documentation on all Office 2007 products. Now Office 2010 has its own: See Microsoft Office 2010 Developer Map.

    Want to find documentation for OneNote Mobile on Windows Phone 7? Just click Mobile Applications in the Developer Map, click OneNote Mobile, and it takes you to the correct documentation  page. Yes, Project and Project Server are there, too.

    The interactive map includes relationships of all of the Microsoft Office client applications, server applications, mobile applications, services and Office 365 applications, and related technologies, development tools, and platform components. Just what we have been waiting for.

    The Learn Office Development page on MSDN is recently updated. It includes links to both of the Office Developer Maps, and also a link to the Office 2010 Developer Map poster.

Page 1 of 11 (255 items) 12345»