Ezequiel Bella’s Blog

In this post you will learn how to deploy a report from a SQL Server 2008 Business Intelligence Development Studio Report Server Project into a SharePoint 2007 site (Integrated with Reporting Services). Once the report is deployed, you will be able to consume it directly from a page of your SP site using a built-in web part that comes with the Microsoft SQL Server 2008 Reporting Services Add-in.
If you are still stuck in the part where you integrate Reporting Services with SharePoint 2007, you might be interested on reading my previous post Integrating SQL Server 2008 Reporting Services with SharePoint 2007.

Deploy your report from Visual Studio into your SharePoint site

This task assumes that you have already designed a report in SQL Server Business Intelligence Development Studio (Visual Studio), and you are willing to publish it into your site’s Report Gallery. In this task you will learn how to configure the report deployment settings in order to point them to the correct SharePoint URLs. For more information, see How to: Publish a Report to a SharePoint Library from Report Designer (SharePoint Integrated Mode).

1. In Solution Explorer, right-click the Report Server project, and select Properties.

2. In your report project Property Pages, edit the following fields, and click OK. (For more information on this, see Deploying Models and Shared Data Sources to a SharePoint Site):

TargetDataSourceFolder: Is the URL of your SharePoint library for shared data sources. For example: http://<siteurl>/Documents

TargetReportFolder: Is the URL of your SharePoint site for Reports. For Example: http://<siteurl>/ReportsLibrary

TargetServerURL: Is the URL of your SharePoint site to which the project is deployed. For Example: http://<siteurl>

3. Right-click the report that you wish to publish, and click Deploy.

If everything goes fine, the output should look like this:

4. Go to the Reports Library of your site, and check that the Report was successfully deployed.

Enable the Report Viewer Web Part in SharePoint

In this task you will add the Report Viewer Web Part to your site’s Web Part Gallery. Once the web part is uploaded into the Gallery, you will be able to use it from any page of your SharePoint site. Before adding it check if the Report Viewer Web Part isn’t already in your Gallery; in this case you can skip this step.

1. Navigate to the Site Settings page of the site where you wish to consume the report. To do this, click Site Actions | Site Settings | Modify All Site Settings.

2. In the Galleries section, click Web Part link.

3. Upload the Report Viewer Web Part (installed by the Add-In Microsoft SQL Server 2008 Reporting Services Add-in for Microsoft SharePoint Technologies) to the site’s Web Part Gallery. To do this, click Upload | Upload Document.

4. Click Browse, point to “C:\Program Files\Common Files\microsoft shared\Web Server Extensions\12\TEMPLATE\FEATURES\ReportServer\ReportViewer.dwp”, and click OK.

5. In the Web Part Gallery Edit Item page, accept default values by clicking OK. The Web Part should now be visible in the Web Part Gallery list.

Consume the report from a Page in your SharePoint Site.

This page will contain the built-in web part that will consume the Report. For more information, see

1. Create a new page in your SharePoint site. To do this, click Site Actions | Create Page.

2. Configure the new Page Title and URL, and select the template that supports web parts named (Welcome Page) Blank Web Part Page. Then click Create.

3. Click Add a Web Part in any of the allowed slots.

4. In All Web Parts, in the Miscellaneous section, select SQL Server Reporting Services Report Viewer, and click Add.

5. Edit the properties of the report in the tool pane:

6. Assign the Report target URL. To determine the URL for any report, right-click the report in the Reports Library, and select Copy Shortcut. Then paste the URL in the Report field (replace the "%20" URL encoding with a space), and click OK.

You should now see the report automatically generated in your page:

Next, you should publish the page and browse it to see the report finally working!!:)

References:

How to: Add the Report Viewer Web Part to a Web Page (Reporting Services in SharePoint Integrated Mode)

Publishing Reports from Report Server in Sharepoint Integrated Mode throws error - TechNet Forums

How to: Publish a Report to a SharePoint Library from Report Designer (SharePoint Integrated Mode)

This walkthrough assumes that you have previously installed MOSS 2007 (with Reporting Services Integration feature on) + SQL Server 2008 on Windows Server 2008. If you are using another Windows version, there might be steps that will slightly differ while configuring them, so try to adjust them to your environment.

Install the Microsoft SQL Server 2008 Reporting Services Add-in for Microsoft SharePoint Technologies (here).

This add-in basically provides a Report Viewer Web Part that provides report viewing capability, export to other rendering formats, page navigation, search, print, and zoom.

Configure the Report Server via the Reporting Services Configuration Manager tool.

1. Service Account tab: In this scenario we will use Network Service as the service account.

   

2. Web Service URL tab: Use the default ReportServer Virtual Directory (is already created). This is the URL of the Report Server that will be hosted in IIS. If you want to change the name, edit the Virtual Directory text and click Apply. This will remove the existing server, and do the necessary stuff to publish the new one.

   

3. Database tab: Use the default ReportServer database (is already created). Have in mind that this database was created in Sharepoint Integrated Mode, thus cannot be accessed by the Report Server unless the database has been granted rights to access to the Sharepoint server farm (you will configure this later.)

   

4. Report Manager URL tab: This tab is intended to configure the Report Server Control Panel. In our case, we won’t use this feature because is not supported while operating in SharePoint Integration mode.

For the other tabs, let’s use the default configuration.

Configure Report Server in SharePoint Central Admin Tool.

This step will finally integrate Reporting Services with SharePoint.

1. Open the Central Administration Site. To do this, click Start | All Programs | Microsoft Office Server …

   

2. Enable Report Server Integration Feature from SharePoint.

   

3. Give Report Server permission to access the database in the SharePoint farm. To do this, go back to Application Management page, locate the Reporting Services section, and click the Grant database access link. Choose the appropriate db server name, choose Default Instance and click OK. You will be prompted for a user account and a password, use a System Administrator account.

   

4. Register the Report Server URL so as to integrate it with SharePoint. In the Reporting Services section click Manage integration settings, and set the following values:
   

   a. Report Server Web Service: Is the URL were the report server is hosted (http://<server-name>/ReportServer)

   b. Authenticated Mode: Trusted Account.

5. If you will consume a report that logs on to the database using Windows Authentication, you should set this value to Windows Authentication instead.

   

6. You can also configure the Reporting Services Server Defaults, but we will leave it like this for now. If you want to configure them see the references below for more detail.

You can verify the procedure by navigating to the ReportServer URL, and see that you are now able to browse the site correctly. This means that Report Server has the rights to access to the Report Server database of the SharePoint site farm, an operation that we were not able to perform before.

In the next post you will see how to deploy a report from Visual Studio into your SharePoint site, and then consume it using the Report Viewer Web Part that comes with the Microsoft SQL Server 2008 Reporting Services Add-in.

References:

• How to: Configure Report Server Integration in SharePoint Central Administration
• Microsoft SQL Server Reporting Services - Installation and Configuration Guide for SharePoint Integration Mode.docx

For the past five weeks I’ve been working on a project for DPE (Developer and Platform Evangelist) to deliver a set of quality Hands on Labs consisting on the new technologies for .NET 3.5 Extensions; these includes:

• ASP.NET MVC
• Creating ASP.NET MVC Applications
• Developing ASP.NET MVC applications with TDD
• Using ASP.NET MVC along with an IoC container
• ASP.NET Dynamic Data
• Creating a data-driven web application
• Customizing an ASP.NET Dynamic Data application
• ASP.NET AJAX History
• Adding history points to an ASP.NET AJAX Web application using server controls
• Adding history points to an ASP.NET AJAX Web application using the AJAX API
• ASP.NET Silverlight controls
• Adding Rich Media to Web applications
• Hosting Silverlight Content within an ASP.NET Application
• ADO.NET Data Services
• Creating and consuming ADO.NET Data Services
• Consuming ADO.NET data services using ASP.NET AJAX API
• Extending Data Services with Service Operations and Interceptors
• ADO.NET Entity Framework
• Creating and Consuming an Entity Data Model

Get them from here!

We worked really hard to make them easy to follow and have control of what you are doing at any time.

Hope you enjoy them and find them useful as you expected!

In this opportunity I will show you how to use the VSTO Ribbon dynamicMenu control to programmatically add controls at runtime using C#.

The dynamicMenu is a Ribbon control that has a similar behavior to the menu control, with the difference that the former allows to add controls like buttons, menus, toggleButtons at runtime. For this, it provides an attribute named GetContent which can be set to a callback that will retrieve all the data representing the menu content (For more information, see List of all callbacks and signatures).This data is no more than an XML file that nests controls in a given hierarchy and will be then recreated by the dynamicMenu.

As shown in the above figure, our goal is to dynamically generate the content XML file each time the GetContent callback is executed.

The sample code

I’m attaching in this post a ready to go sample that you can download and use to play around. Basically, it implements the GetContent callback, reads the My Documents folder from the file system and generates the content XML file. In order to reproduce a proper hierarchy we will need to distinguish files from folders and create controls accordingly. We will use menu controls to represent directories as they can act as containers for other controls, and for the files we will use buttons.

Let’s see a little bit of code…

1. When the GetContent callback is executed we will call GetMenuContentFromFS that will go through the directories progressively and finally build the XML content file.

   public string GetContent(Office.IRibbonControl control)
   {
       return GetMenuContentFromFS(
           Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments));
   }
   
   private string GetMenuContentFromFS(string path)
   {
       StringBuilder contentStringBuilder = new StringBuilder(
           @"<menu xmlns=""http://schemas.microsoft.com/office/2006/01/customui"" >"
       );
   
       //append nested directories with its files
       AppendDirectoryContent(new DirectoryInfo(path), contentStringBuilder, 4);
   
       //append the files that are at the root level
       AppendFilesContent(new DirectoryInfo(path), contentStringBuilder);
       contentStringBuilder.Append(@"</menu>");
   
       return contentStringBuilder.ToString();
   }

2. AppendDirectoryContent is a recursive method that appends a menu control for each directory that finds, and leaves the menu tag open until the directory has no more directory or file childs.

   //maxDirDepth specifies the maximum level of nested menus that the controls supports
       private void AppendDirectoryContent(
           DirectoryInfo dirInfo, StringBuilder contentStringBuilder, int maxDirDepth)
       {
           if (maxDirDepth > 0)
           {
   
               foreach (DirectoryInfo dir in dirInfo.GetDirectories())
               {
                   string folderId = String.Concat("a" + Guid.NewGuid().ToString()); ;
   
                   contentStringBuilder.Append(
                       String.Format(@"<menu id=""{0}"" imageMso=""Folder"" label=""{1}"">",
                       folderId, dir.Name));
   
                   AppendDirectoryContent(dir, contentStringBuilder, maxDirDepth - 1);
   
                   AppendFilesContent(dir, contentStringBuilder);
                   contentStringBuilder.Append(@"</menu>");
   
               }
           }
       }

3. AppendFilesContent method in contrast, appends a button control for each file. In this example we will just work with .docx files to make things simpler. Since all our files will be docx it will be nice if we can change the button icon to have word’s; we can do this by setting the button’s imageMso attribute to FileSaveAsWordDocx.
   
   The button control also provides an OnAction attribute were you can set a callback that is executed every time the button is clicked. We will implement this callback later.

   After appending the control we will relate the control id (fileId) with the file path for future usage.

   private void AppendFilesContent(DirectoryInfo dir, StringBuilder contentStringBuilder)
   {
       FileInfo[] files = dir.GetFiles("*.docx");
       foreach (FileInfo file in files)
       {
           //the control id cannot start with a number
           string fileId = String.Concat("a" + Guid.NewGuid().ToString());
           contentStringBuilder.Append(
               String.Format(@"<button id=""{0}"" label=""{1}"" onAction=""OnAction""
                               imageMso=""FileSaveAsWordDocx"" />", fileId, file.Name));
   
           filePaths.Add(fileId, file.FullName);
       }
   }

4. Finally, we will implement the OnAction callback. Here you can do what you want, open the file, paste it in word. We will just display the full file path to keep the sample simple.

   public void OnAction(Office.IRibbonControl control)
   {
       object oObject = System.Reflection.Missing.Value;
       Microsoft.Office.Interop.Word.Application applicationObject =
           ((Word.Window)control.Context).Application;
       string filePath = filePaths[control.Id];
   
       System.Windows.Forms.MessageBox.Show(filePath);
   }

An important thing to have in mind is that the normal behavior of dynamicMenu control is to execute the OnAction callback just the first time you click on it. So if you add or remove some files to the My Documents folder you won’t see the changes until you reopen the document. But this behavior can be changed to have the callback executed every time we click on the dynamicMenu :).

Here is the trick: You need to invalidate the dynamicMenu control in the Application.WindowActivate event and force it to reload.

void Application_WindowActivate(
     Microsoft.Office.Interop.Word.Document Doc,
     Microsoft.Office.Interop.Word.Window Wn)
 {
     ribbon.ribbonUI.InvalidateControl("dynamicMenuSample");
 }

If you have some time, download the sample and see it working.

See you in the next post!

Southworks’ family is getting bigger and bigger as days pass, and makes me wonder if there is a limit. In this opportunity I would like to introduce our new CEO, Hernan Rey-Willis, who decided to join us in the path to greatness. I’m sure he will bring Southworks tons of energy and positive vibrations! =)

Cheers southies for this important milestone!¡!

Hernan Rey-Willis performing his speech

Southworks family!

Hi, in this opportunity you will see how to attach a given template into a Word 2007 document programatically (C#), and subsequently update the styles that were modified.

Sample Solution

If you like to see the code working, I’m attaching in this post a really simple sample solution that you can download and use it at will. The sample consists on a VSTO Word 2007 add-in solution that when debugs it opens a Word 2007 instance. This Word 2007 instance has plugged-in an additional ribbon bar with one button named AttachTemplate that will attach a provided template every time it is clicked.

The Code

The code is really small and seamless; seems that the guys of Interop did a great job with this :). First of all, we need to gather the active Word Document which is the object representation of our Word document instance (For more information, see Document Interface).

The Document interface exposes two methods that comes in handy for our mission: set_AttachedTemplate and UpdateStyles. When we call the set_AttachedTemplate, Interop resets the Document.AttachedTemplate property and performs additional tasks such as manipulating the Styles section of the OpenXml (more precisely the word\styles.xml XmlPart).

(For more information, see AttachedTemplate property)

At this moment, all elements that compose a template have been re assigned to match the new ones, but you won’t see any style changes. The document content and the styles pane will stay unaltered. Here is when UpdateStyles method comes into action by adding the new styles into the style pane and forcing all the document content styles to get updated instantly.

See it by yourself:

private void AttachTemplate(Word.Document document, string templateFilePath)
{
    object oTemplate = (object)templateFilePath;
    document.set_AttachedTemplate(ref oTemplate);
    document.UpdateStyles();
}

Hope it helped! See you!

Introduction

In order to make the sample more exciting, you will convert a text selection into a plain text content control. For this, you will use several Interop interfaces such as Selection and Range, but don’t panic because their use is really simple and intuitive. For more information, see Selection Interface and Range Interface.

Additionally, I’m attaching in this post a solution sample containing the full code that you may use as a guide for this walkthrough. It consists on a Word 2007 VSTO solution that when runs it opens a Word 2007 instance and creates a custom Ribbon with one button named ConvertText. When this button is pressed, it converts the current selected text into a plain text content control.

Requirements to run the code sample

• 2007 Microsoft Office system Primary Interop Assemblies
• Microsoft Visual Studio 2005 Tools for the 2007 Microsoft Office System

The code

Let me briefly describe the big picture. When the ConvertText ribbon button is clicked, a callback named ConvertText_Click is called.

This method simply checks if there is any text selected in the active Word 2007 instance and if indeed, it calls to CreateContentControlInSelection method that converts the selection into a plain text content control.

The code is really simple and self-explained:

public void ConvertText_Click(Office.IRibbonControl control)
{
    Selection selection = ((Word.Window)control.Context).Application.Selection;
    int selectionLength = selection.Range.End - selection.Range.Start;

    if (selectionLength > 0)
    {

        if (CreateContentControlInSelection(
            selection,
            TOPIC_TITLE,
            DateTime.Now.ToString()) != null)
        {
            object oUnit = WdUnits.wdCharacter;
            object oCount = selectionLength + 1;

            //Gets out of the content control
            selection.MoveRight(ref oUnit, ref oCount, ref paramMissing);
        }
    }
}

private ContentControl CreateContentControlInSelection(
    Selection selection, string controlName, string controlTag)
{
    ContentControl contentControl = null;

    if (selection.Paragraphs.Count > 1)
    {
        MessageBox.Show(
            "Plain text conent control cannot be inserted around multiple paragraphs.",
            "Microsoft Office Word", MessageBoxButtons.OK, MessageBoxIcon.Warning);
    }
    else
    {
        object oRng = (object)selection.Range;
        contentControl = selection.Range.ContentControls.Add(
            WdContentControlType.wdContentControlText, ref oRng);
        if (contentControl != null)
        {
            contentControl.Range.Text = selection.Text.Replace("\r", "");
            contentControl.Tag = controlTag;
            contentControl.Title = controlName;
        }
    }

    return contentControl;
}

How to run the sample?

1. Download the sample from this post.
2. Unzip the AddContentControl.zip file
3. Double click the AddContentControl.sln solution file.
4. Hit F5 to run the solution and start a new Word 2007 instance with the RibbonBar add-in.
5. Enjoy!

Stay tuned!

Hi to all! In this post I will show you how to programatically (C#) export the images that are embedded in Word 2007. As you may know, all the images that are inserted into Word are also embedded as document parts.

All embedded parts in a Word 2007 document are in their native, default Word XML format. Therefore, if you add a picture to a document, you can rename the document with a .zip extension, and open it as you would any ZIP file. Within the package, you can locate the picture and open it as well. If the picture is in a .png format, you can see and open a .png file directly from the package.

Requirements

You will need the following technologies to use this piece of code:

• .NET Framework 3.0 -> You will need to use the System.IO.Packaging Namespace. For more information, see System.IO.Packaging Namespace. 

Inside the code

Before starting, have in mind that this is not intended to be an OpenXml tutorial. If you want to learn more about OpenXml standard and characteristics visit, Walkthrough: Word 2007 XML Format.

In the following section I will show and explain the functionality of one method named ExportEmbeddedImages that contains the most relevant logic you need to know. If you want to explore the code more deeply, please download the entire solution attached in this post.

Pretty much of the implementation of this post is inspired on the 2007 Office System Sample: Open XML File Format Code Snippets for Visual Studio 2005. It really helped me to start thinking in terms of PackageParts and PackageRelationships.

ExportEmbeddedImages method

In this method we will open the docx file as a Package to retrieve the main document part (word\document.xml), where we can find all the image relationships (represented by the PackageRelationship class).
Then we will loop over the image relationships and will get the image PackagePart that is actually the embedded image stream. We will resize the PackagePart using the Bitmap class and finally save it to disk in png format.

1. First of all, we need to open the Package, which is the object representation of the docx file. The package is basically a container of PackageParts and PackageRelationships. For more information, see Package Class (System.IO.Packaging).

   using (Package wdPackage = Package.Open(documentPath,
       FileMode.Open, FileAccess.Read))

2. Once we opened the docx Package, we need to retrieve the main document part (document.xml). This PackagePart contains the main document information such as the document paragraphs, images, styles, bookmarks, etc.

   PackagePart documentPart = GetMainDocumentPart(wdPackage);

3. Get the image PackageRelationships from the main document part and loop over each of them. A relationship is a logical connection between two parts within the file package. In this case, the relationship specifies the physical location of the image within the package.

   const string imageSchema = @"http://schemas.openxmlformats.org/
   officeDocument/2006/relationships/image";
   foreach (PackageRelationship imageRel in
       documentPart.GetRelationshipsByType(imageSchema))

4. Check if the relationship corresponds to an embedded image by accessing to the TargetMode.External enum.

   if (imageRel.TargetMode != TargetMode.External)

5. Get the image size from the main document part which will be used to resize the original embedded image. Remember that images are embedded in its original size as PackageParts, so if you resize the image from Word, they will not be altered at all. That’s why you need to manage the image size separately from the main document part.

   Size imageSize = GetEmbeddedImageSize(documentPart, imageRel.Id);

6. By default, sizes in OpenXml packages are stored in a unit named EMUs (English Metric Units), so we will convert it to pixels which is the unit that the Bitmap class understands. We will use Bitmap class to save images to disk.

   imageSize.Width = ConvertEmuToPixels(imageSize.Width);
   imageSize.Height = ConvertEmuToPixels(imageSize.Height);

7. Finally, we will call the ExportImage method that will resize the original image and will save it to disk. Basically this method uses the image relationship to obtain the PackagePart that contains the original image stream and resizes it using the size managed in the previous step.

   ExportImage(imagesPath, documentPart, imageRel, imageSize);

internal static void ExportEmbeddedImages(string documentPath, string imagesPath)
{
    using (Package wdPackage = Package.Open(documentPath, FileMode.Open, FileAccess.Read))
    {
        PackagePart documentPart = GetMainDocumentPart(wdPackage);

        if (documentPart != null)
        {
            const string imageSchema = @"http://schemas.openxmlformats.org/
                                            officeDocument/2006/relationships/image";
            foreach (PackageRelationship imageRel in
                documentPart.GetRelationshipsByType(imageSchema))
            {
                //is an embedded image
                if (imageRel.TargetMode != TargetMode.External)
                {
                    Size imageSize = GetEmbeddedImageSize(documentPart, imageRel.Id);
                    if ((imageSize.Width > 0) && (imageSize.Height > 0))
                    {
                        imageSize.Width = ConvertEmuToPixels(imageSize.Width);
                        imageSize.Height = ConvertEmuToPixels(imageSize.Height);
                        ExportImage(imagesPath, documentPart, imageRel, imageSize);
                    }
                }
            }
        }
    }
}

Running the sample

To run the sample:

• Download and build the solution attached in this post
• Execute the ExportEmbeddedImage.exe in a command prompt with the following parameters:
  • documentPath: Specifies the path and name of the docx
  • imagesPath (optional): Specifies the images output path

See you in the next post!

As I mentioned in my previous post, SaaS HOLs are now available to download at Fred Chong’s Blog. 

Click at Santa to start enjoying such a precious gift, hope you enjoy them :)

In the past days I’ve been working on a project to deliver Microsoft AST’s SaaS Hands On Labs which will provide a step by step guide to implement some SaaS key architectural aspects such as DataModel, Business Process, Security, etc.
These labs also served as a reference material during the SaaS Workshop that was presented by Gianpaolo Carraro, Fred Chong, Matias Woloski and Erik Weis last week at Microsoft, Redmond. For those who are willing to try this HOLs, stay tuned because they will be available to download soon!

This is a brief summary about the SaaS architectural aspects that the labs covered:

• Lab01-DataModel
  • Ex01-Creating Metadata Extensible Entities: Get familiarized with Multi-Tenant efficient data architecture.
  • Ex02-Configuring Extensible Entities for Presentation: Implement the visual side of the extensible entity.
  • Ex03-Creating and Querying Extensible Entities: Implement the logic to work with actual instances of the extensible entities created in previous exercises.
• Lab02-Workflow
  • Ex01-Customizing Workflow Using Xoml: Create a workflow editor in ASP.NET 2.0 that will let the tenant build a sequence workflow customizing its structure from a list of available activities.
  • Ex02-Customizing Business Rules: Create a ruleset editor in ASP.NET 2.0 that will let the tenant create a rule based on a product entity instance field.
  • Ex03-Consuming Customized Workflows and Business Rules Using Xoml Activation: Create a router workflow and a couple of activities that will execute a ruleset and launch a workflow created by the tenant.
• Lab03-Security
  • Ex01-Implementing claim-based security using security token services: The exercise shows how to use Windows Communication Foundation federation capabilities to implement a centralized security subsystem based on standards like WS-Trust and SAML.
  • Ex02-Implementing the authentication store using Active Directory Application Mode (ADAM): Implement the logic to allow the service layer authenticate and retrieve roles from ADAM.
• Lab04-Provisioning
  • Ex01-Make tenant provisioning in IIS, ADAM and SQL Server 2005: Implement a service of the hosting platform that will perform the provisioning of a tenant at ADAM.

For more detail about the SaaS Workshop, see Matias Woloski’s post.

For more information about LitwareHR (Microsoft AST SaaS reference implementation) community, see Ariel Schapiro’s blog and LitwareHR at Codeplex.