Die Autoren der MindBusiness GmbH sind wieder im SharePoint-Magazin vertreten. Dieses Mal mit folgendem Thema:

Power BI mit SharePoint – Wo Excel streikt und PowerPivot triumphiert

PowerPivot. Was ist das überhaupt? Wie funktioniert es? Welchen Nutzen bringt dieses Tool? Wie wird mit SharePoint synchronisiert? Fragen über Fragen! Die Antworten  erleichtern allerdings das Arbeiten im Tagesgeschäft, als [...]]]> Achtung! News!

Die Autoren der MindBusiness GmbH sind wieder im SharePoint-Magazin vertreten. Dieses Mal mit folgendem Thema:

Power BI mit SharePoint – Wo Excel streikt und PowerPivot triumphiert

PowerPivot. Was ist das überhaupt? Wie funktioniert es? Welchen Nutzen bringt dieses Tool? Wie wird mit SharePoint synchronisiert? Fragen über Fragen! Die Antworten  erleichtern allerdings das Arbeiten im Tagesgeschäft, als auch im Fällen von strategischen Entscheidungen. Also, aufgepasst! Der Hauptteil dieses Artikels besteht aus einer Wette. Diese lautet: Wetten, dass es machbar ist innerhalb von 15 Minuten ein übersichtliches BI-Cockpit in SharePoint zu veröffentlichen, dass sich bei Änderungen der Daten automatisch aktualisiert? Es wird gezeigt, dass diese automatische Aktualisierung nur aufgrund des Arbeitens mit Datenfeeds ermöglicht wird. Des Weiteren wird geklärt, ob diese automatisch aktualisierende BI-Lösung mit Microsoft Office365, somit SharePoint Online, gleiche Funktionalitäten mit sich bringt und es wird ein grober Ausblick auf SQL Server 2012 in Verbindung mit PowerView getätigt.

Hier geht es direkt zum Artikel: SharePoint-Magazin_PowerBI

Das MindBusiness-Team

The first you will read on Microsoft msdn for SharePoint 2010 about this requirement should be: http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.webpartpages.communication.iparametersoutprovider.aspx.

Uups, there is a bold NOTE: This API is now obsolete (IParametersOutProvider) and where is the link [...]]]> A client was asking for a connectable web part, sending a parameter to data form web part (dfwp) build by SharePointDesigner.

The first you will read on Microsoft msdn for SharePoint 2010 about this requirement should be: http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.webpartpages.communication.iparametersoutprovider.aspx.

Uups, there is a bold NOTE: This API is now obsolete (IParametersOutProvider) and where is the link to the new one?  .. i was  adapting the example for my test solution.

If i copied the complete code to my own web part class and compile this code first time, i got a message on my classname: ‘Microsoft.SharePoint.WebPartPages.Communication.IParametersOutProvider’ is obsolete: ‘Use System.Web.UI.WebControls.WebParts.IWebPartParameters instead’, why it’s not written in the note?

Trying this code, i was running in an unhandled exception on Step #6. The PartCommunicationConnect was called, the given connectedPart was Null! The exception occurs if you connect a dfwp with parameter binding to my wp implementing IParametersOutProvider. So i realized, this should not my solution.. searching for a fully description on IWebPartParameters.. there are not so many complete stories on the net yet..

Now i will share working c# code like in the above link.

In my example, a hidden web part extracts a sequence from current web URI and send the ‘data’ parameter to a dfwp connected by parameter binding.

   1:  // Common .NET required namespaces

   2:  using System;

   3:  using System.ComponentModel;

   4:   

   5:  // WebPart required namespaces

   6:  using System.Web;

   7:  using System.Web.UI;

   8:  using System.Web.UI.WebControls;

   9:  using System.Web.UI.WebControls.WebParts;

  10:   

  11:  //Step #1: Reference the SharePoint namespace.

  12:  using Microsoft.SharePoint;

  13:   

  14:  namespace ConnectionCodeSamples.WebPartParametersProvider

  15:  {

  16:      // Step #2: Inherit from the WebPart base class and implement the 

  17:      // IWebPartParameters interface.

  18:      [ToolboxItemAttribute(false)]

  19:      public class WebPartParametersProvider : WebPart, IWebPartParameters

  20:      {

  21:          // Step #3: Declare private variables for configuration , handling 

  22:          // and a value passed as parameter.

  23:          private int _strFirst;

  24:          private int _strLength;

  25:          private string _myError = string.Empty;

  26:   

  27:          private string _urlData = "WebPartParametersProvider url 'data' value";

  28:   

  29:          // Step #4: the provider must implement a list of property descriptors 

  30:          // that the consumer is interested in 

  31:          private PropertyDescriptorCollection _objParameters;

  32:          public PropertyDescriptorCollection Parameters

  33:          {

  34:              get { return _objParameters; }

  35:              set { _objParameters = value; }

  36:          }

  37:   

  38:          // Step #5: Constructor

  39:          public WebPartParametersProvider()

  40:          {

  41:              this.ExportMode = WebPartExportMode.All;

  42:              base.Hidden = true;

  43:          }

  44:   

  45:          // Step #6: implement ConnectionInterface

  46:          [ConnectionProvider("my parameters provider")]

  47:          public IWebPartParameters ConnectionInterface()

  48:          {

  49:              return this;

  50:          }

  51:   

  52:          // Step #7: implement a schema for the data returned by the provider

  53:          // you need this for the IWebPart* interfaces

  54:          public System.ComponentModel.PropertyDescriptorCollection Schema

  55:          {

  56:              get

  57:              {

  58:                  PropertyDescriptorCollection objProperties;

  59:                  PropertyDescriptor[] arrProperties =

  60:                      new PropertyDescriptor[Parameters.Count];

  61:                  TypeDescriptor.GetProperties(this);

  62:   

  63:                  objProperties = TypeDescriptor.GetProperties(this);

  64:                  int intParameterCount = 0;

  65:                  foreach (PropertyDescriptor objProperty in Parameters)

  66:                  {

  67:                      if (Parameters[objProperty.Name] != null)

  68:                      {

  69:                          intParameterCount++;

  70:                          arrProperties[intParameterCount] = objProperty;

  71:                      }

  72:                  }

  73:   

  74:                  objProperties = new PropertyDescriptorCollection(arrProperties);

  75:                  return objProperties;

  76:              }

  77:          }

  78:   

  79:          // Step #8: implement a method called SetConsumerSchema(), allows a consumer

  80:          // to express its interest in a set of parameters provided by provider

  81:          public void SetConsumerSchema(System.ComponentModel.PropertyDescriptorCollection schema)

  82:          {

  83:              Parameters = schema;

  84:          }

  85:   

  86:          // Step #9: implement the GetParametersData(), this will hold a reference

  87:          // to the parameters consumer web part after a connection is established

  88:          public void GetParametersData(ParametersCallback callback)

  89:          {

  90:              StateBag objParameters = new StateBag();

  91:   

  92:              foreach (PropertyDescriptor objProperty in Parameters)

  93:              {

  94:                  switch (objProperty.Name)

  95:                  {

  96:                      case "data":

  97:                          objParameters.Add("data", UrlData);

  98:                          break;

  99:                      default:

 100:                          throw new Exception("WebPartParametersProvider: Unknown parameter name");

 101:                  }

 102:              }

 103:   

 104:              callback.Invoke(objParameters);

 105:          }

 106:   

 107:          // Step #10: implement properties for web part configuration 

 108:          // and to hold our data extracted from current url

 109:          [WebBrowsable(true),

 110:          Personalizable(PersonalizationScope.Shared),

 111:          WebDescription("The first char in web url to search for (0 based).")]

 112:          public int UrlFirst

 113:          {

 114:              get

 115:              {

 116:                  return this._strFirst;

 117:              }

 118:              set

 119:              {

 120:                  this._strFirst = value > 0 ? value : 0;

 121:              }

 122:          }

 123:   

 124:          [WebBrowsable(true),

 125:          Personalizable(PersonalizationScope.Shared),

 126:          WebDescription("The length of the string to extract after first char.")]

 127:          public int StrLength

 128:          {

 129:              get

 130:              {

 131:                  return this._strLength;

 132:              }

 133:              set

 134:              {

 135:                  this._strLength = value > 0 ? value : 0;

 136:              }

 137:          }

 138:   

 139:          public string UrlData

 140:          {

 141:              get { return _urlData; }

 142:              set { _urlData = value; }

 143:          }

 144:   

 145:          // Step #11: init the all data

 146:          protected override void OnInit(EventArgs e)

 147:          {

 148:              base.OnInit(e);

 149:   

 150:              if (UrlFirst != 0 && StrLength > 0)

 151:              {

 152:                  try

 153:                  {

 154:                      string url = SPContext.Current.Web.Url;

 155:                      if (url.Length >= UrlFirst + StrLength)

 156:                      {

 157:                          _urlData = url.Substring(UrlFirst, StrLength);

 158:                      }

 159:                  }

 160:                  catch (Exception se)

 161:                  {

 162:                      _myError = se.Message + ", " + se.InnerException;

 163:                  }

 164:              }

 165:          }

 166:   

 167:          // Step #12: create controls to show properies, 

 168:          // data and web part configuration hints in page edit mode

 169:          protected override void CreateChildControls()

 170:          {

 171:              Controls.Clear();

 172:   

 173:              if ((UrlFirst == 0 || StrLength == 0))

 174:              {

 175:                  //.. show a how to configure web part

 176:              }

 177:              else

 178:              {

 179:                  //.. show your properties and the assigned data

 180:              }

 181:          }

 182:      }

 183:  }

for more description, please study also on msdn the IWebPartParameters interface: http://msdn.microsoft.com/en-us/library/system.web.ui.webcontrols.webparts.iwebpartparameters.aspx

Eine Silverlight Anwendung beschreibt mehrere SharePoint listen und soll auf beliebigen SharePoint Server installiert werden. Wenn ich das Silverlight Projekt im Visual Studio erstellt, kann ich ja eine Service Referenz hinzufügen. Visual Studio erzeugt dann den Proxy oder Client für den ausgewählten dienst und schreibt dann auch noch in eine Konfigurationsdatei [...]]]> Dieser Blog beschreibt folgendes Szeario:

Eine Silverlight Anwendung beschreibt mehrere SharePoint listen und soll auf beliebigen SharePoint Server installiert werden. Wenn ich das Silverlight Projekt im Visual Studio erstellt, kann ich ja eine Service Referenz hinzufügen. Visual Studio erzeugt dann den Proxy oder Client für den ausgewählten dienst und schreibt dann auch noch in eine Konfigurationsdatei die URI für das Binding und den Endpoint.

Die Datei sieht dann in meiner Anwendung dann so aus:

<configuration>
    <system.serviceModel>
        <bindings>
            <basicHttpBinding>
                <binding name="PeopleSoap" maxBufferSize="2147483647" maxReceivedMessageSize="2147483647">
                    <security mode="None" />
                </binding>
                <binding name="UserProfileServiceSoap" maxBufferSize="2147483647"
                    maxReceivedMessageSize="2147483647">
                    <security mode="None" />
                </binding>
                <binding name="ListsSoap" maxBufferSize="2147483647" maxReceivedMessageSize="2147483647">
                    <security mode="None" />
                </binding>
            </basicHttpBinding>
        </bindings>
        <client>
            <endpoint address="http://www.sharepointonline.biz/_vti_bin/people.asmx"
                binding="basicHttpBinding" bindingConfiguration="PeopleSoap"
                contract="PeopleReference.PeopleSoap" name="PeopleSoap" />
            <endpoint address="http://www.sharepointonline.biz/xxxxxxx/_vti_bin/UserProfileService.asmx"
                binding="basicHttpBinding" bindingConfiguration="UserProfileServiceSoap"
                contract="UserProfileService.UserProfileServiceSoap" name="UserProfileServiceSoap" />
            <endpoint address="http://www.sharepointonline.biz/_vti_bin/lists.asmx"
                binding="basicHttpBinding" bindingConfiguration="ListsSoap"
                contract="ServiceReference1.ListsSoap" name="ListsSoap" />
        </client>
    </system.serviceModel>
</configuration>

Man kann erkennen, dass hier die EndPoint Adresse hart verdrahted ist. Ich brauche aber eine dynamische Bindung zur Laufzeit, so dass ich die gleiche XAP-Datei auf verschiedenen Server, die unterschiedliche URLs haben, verwendet kann. Das folgende Listing zeigt die Lösung:

Ich deklariere die folgenden Stringvariablen:

public string Host;

public string PathToSite;

public string Protocol;

public string PathToWebService;

Dann schreiben ich folgende Zeilen im Konstruktor:

            BasicHttpBinding bind = new BasicHttpBinding();

            Protocol = HtmlPage.Document.DocumentUri.Scheme + “://”;            Host = HtmlPage.Document.DocumentUri.Host;

           
            // Pfad der Site berechnen

            string[] temp = HtmlPage.Document.DocumentUri.LocalPath.Split(‘/’);

            string result = “”;

            for(int i = 0; i < temp.Length; i++) {

                if( ! temp[i].Contains(“Silverlight”) ) {

                    result += temp[i];

                    result += “/”;

                }

                else {

                    break;

                }

            }

 

            PathToSite = result;

            PathToWebService = “_vti_bin/lists.asmx”;

            string sEndPoint = Protocol + Host + PathToSite + PathToWebService;

            EndpointAddress endpoint = new EndpointAddress(sEndPoint);

            proxy = new ListsSoapClient(bind, endpoint);

 

Jetzt kann ich die Variablen Protocol, Host, PathToSite und PathToWebService Anwendungsweit verwendet, um auch andere URL wie z.B. die folgende aufzubauen:

             string uri = “”;

             uri = Protocol + Host + PathToSite + “/_layouts/Upload.aspx?List=” + BrettBilderGUID;             HtmlPage.Window.Navigate(new Uri(uri), “_blank”);

 

Hier öffnen ich z.B. die Upload-Seite einer Bildbibliothek. Die letzte Variable ist eine zuvor ausgelesene GUID.

In Listen können sog. Nachschlagespalten eingefügt werden, die Werte aus einer anderen Liste/Bibliothek derselben Site zur Auswahl anbietet. So kann z.B. eine benutzerdefinierte Liste “Teilprojekte” erstellt werden, und in einer Dokumentenbibliothek kann ein Dokument mit einer Nachschlagespalte auf diese Liste einem Teilprojekt zugeordnet [...]]]> Hier wieder eine kleine Neuerung in SharePoint 2010, die wir kurz beschreiben möchten.

In Listen können sog. Nachschlagespalten eingefügt werden, die Werte aus einer anderen Liste/Bibliothek derselben Site zur Auswahl anbietet. So kann z.B. eine benutzerdefinierte Liste “Teilprojekte” erstellt werden, und in einer Dokumentenbibliothek kann ein Dokument mit einer Nachschlagespalte auf diese Liste einem Teilprojekt zugeordnet werden.

Neu in SharePoint 2010 ist, dass nach der Auswahl der Nachschlagespalte aus der Ursprungsliste (z.B. die Teilprojekte) auch weitere Spalten angezeigt werden können. So kann man dann beim Dokument nicht nur das Teilprojekt sondern gleich auch noch z.B. Start- und Enddatum mit anzeigen lassen.

Leider lassen sich nicht alle Spaltentypen anzeigen. Wir haben eine Quell-Liste mit allen Standard-Spaltentypen erstellt und geschaut, welche davon zusätzlich mit einer Nachschlagespalte angezeigt werden können. In der Abbildung sind die entsprechenden Spalten hervorgehoben, die restlichen Standardspalten sind von einem dieser markierten Datentypen:

Nicht mit angezeigt werden können also folgende Spaltentypen:

• Mehrere Zeilen
• Auswahl
• Währung
• Nachschlagen
• Ja/Nein
• Person
• Hyperlink/Bild
• Metadaten

Besonders schade finden wir das bei Auswahl, Person und Metadaten.

Jedenfalls sieht das Ergebnis in einer Liste mit einer Nachschlagespalte folgendermaßen aus, auf jeden Fall eine schöne Erweiterung in 2010:

So entstehen sowohl für das Dokumenten- und Informationsmanagement als auch für die sozialen Netzwerke in SharePoint Strukturen und Informationsquellen, die neue Möglichkeiten für die Suche und Darstellung von Informationen bieten.

An einigen Stellen wurde schon von diesen [...]]]> Mit SharePoint 2010 hat Microsoft einige Möglichkeiten und Funktionen hinzugefügt, um Inhalte durch Metadaten und Schlüsselwörter sowie Bewertungen zu kennzeichnen.

So entstehen sowohl für das Dokumenten- und Informationsmanagement als auch für die sozialen Netzwerke in SharePoint Strukturen und Informationsquellen, die neue Möglichkeiten für die Suche und Darstellung von Informationen bieten.

An einigen Stellen wurde schon von diesen neuen Funktionalitäten berichtet, wir möchten mit einer kleinen Artikelserie die Praxis verdeutlichen – wie wird das eingerichtet, wo hat der Anwender nutzen davon, welche Probleme und Lösungsmöglichkeiten gibt es etc. Zuerst einmal ein paar Begriffsdefinitionen.

Verwaltete Metadaten (Managed Metadata)

Im Unternehmen gibt es eine Reihe an festen Kategorien oder Begrifflichkeiten, die nach Möglichkeit zentral definiert werden und für verschiedene Anwendungszwecke und Informationen zur Verfügung stehen sollen. Beispiele:

• Standorte eines Unternehmens (Alzenau, Berlin, Nürnberg…)
• Dokumenttypen (Angebot, Vertrag, Vorlage…)
• Sprachen (Deutsch, Englisch…)
• Status (Neu, In Arbeit, Abgeschlossen…)

Es handelt sich also um eindeutig definierbare Auflistungen zu einem bestimmten Stichwort. In SharePoint können nun z.B. Dokumente an unterschiedlichen Stellen abgespeichert werden, an jeder Stelle soll aber z.B. die Sprache des Dokuments und der Dokumenttyp als zusätzliche Information abgespeichert werden.

Mit den verwalteten Metadaten steht nun in SharePoint ein zentraler Speicherort zur Verfügung, in dem diese Auflistungen angelegt und gepflegt werden können. Wird z.B. im Laufe der Zeit ein neuer Dokumenttyp benötigt (Trainingsunterlage…), wird dieser Begriff dort eingepflegt und kann ab sofort in allen Dokumentablagen, der die entsprechende Auflistung zugeordnet ist, verwendet werden.

Weiterhin können nicht mehr verwendete Begriffe "stillgelegt" werden (z.B. ein Standort), Elemente in SharePoint, denen ein solcher Begriff zugeordnet wurde, behalten diesen jedoch bei.

Die Summe all dieser Begriffe und Auflistungen kann als die Taxonomie eines Unternehmens bezeichnet werden. Oder, um die Wikipedia zu zitieren:

Eine Taxonomie (altgr. táxis ,Ordnung’ und nómos ,Gesetz’) oder Klassifikationsschema ist ein einheitliches Verfahren oder Modell, um Objekte eines gewissen Bereichs (ggf. unter Zuhilfenahme eines Klassifikationsinstruments) nach bestimmten Kriterien zu klassifizieren, das heißt sie in bestimmte Kategorien oder Klassen (auch Taxa genannt) einzuordnen.

Microsoft drückt es im Zusammenhang mit SharePoint 2010 folgendermaßen aus:

Bei verwalteten Metadaten handelt es sich um eine hierarchische Auflistung zentral verwalteter Ausdrücke, die Sie definieren und anschließend als Attribute für Elemente in Microsoft SharePoint Server 2010 verwenden können.

Schlüsselwörter (Keywords)

Während die verwalteten Metadaten zentral festgelegt und von bestimmten Anwendern gepflegt werden, ermöglicht SharePoint 2010 an vielen Stellen auch die Verwendung von Schlüsselwörtern. Hier können Anwender selbst Begriffe definieren, die ihnen für den jeweiligen Zusammenhang wichtig sind. Wichtig ist, dass diese Schlüsselwörter nach der ersten Verwendung von allen Anwendern wiederverwendet werden können, so dass in einem Unternehmen dadurch eine benutzerdefinierte Klassifizierung von Inhalten entstehen kann, die auch als Social Tagging oder Folksonomien (im Gegensatz zur Taxonomie) bezeichnet wird.

Bei der Zuordnung von verwalteten Metadaten oder Schlüsselwörter z.B. zu einem Dokument werden die entsprechenden vorhandenen Begriffe als Auswahl angeboten:

Im Beispiel sieht man, dass zwei der Begriffe von Anwendern als Schlüsselwörter definiert wurden, die anderen beiden als verwaltete Metadaten vorliegen.

Terminologiespeicherverwaltung (Term Store Management)

Nun braucht es natürlich auch einen Ort, an dem die Begriffe verwaltet werden können, das ist die Terminologiespeicherverwaltung. Ohne ins Detail zu gehen, möchten wir hier doch schon drei Dinge hervorheben:

• Schlüsselwörter können hier in den Bereich der verwalteten Metadaten verschoben werden. Wenn im Unternehmen im Lauf der Zeit festgestellt wird, dass bestimmte Begriffe in den überwachten Bereich in eine Taxonomiestruktur übernommen werden sollen, ist dies problemlos möglich, die Begriffe können natürlich weiterhin verwendet werden.
• Verwaltete Metadaten können mehrsprachig definiert werden. Hat ein Anwender in einer deutschen SharePoint-Umgebung z.B. ein Dokument als "Angebot" markiert, taucht dies in einer englischen Umgebung als "Offer" auf.
• Synomyme und Abkürzungen können für verwaltete Metadaten gepflegt werden

Bewertungen

Neu hinzugekommen ist noch die Möglichkeit, Dokumente und andere Elemente bewerten zu können. Dies wird am Element durch Sternchen gekennzeichnet, wie die Anwender sie auch von anderen Systemen bzw. Webanwendungen gewohnt sind:

Damit können besonders gut bewertete Artikel und Dokumente hervorgehoben werden, oder "Ladenhüter" gezielt überarbeitet und verbessert werden.

Mit der nächsten Folge in dieser Serie gehen wir in die konkrete Nutzung und Einrichtung.

Bei einem Kunden sollte im SharePoint-Blog (SharePoint 2007) bei den Kommentaren das Titelfeld mit der kompletten Zeile ausgeblendet werden. Dazu wurde die Datei post.aspx im SharePoint Designer geöffnet und folgender Code eingefügt (für Ihre Anwendung die [...]]]> Viele Tricks finden sich rund um jquery, um Webseiten allgemein sowie auch speziell SharePoint-Seiten zu gestalten bzw. spezielle Funktionen hinzuzufügen.

Bei einem Kunden sollte im SharePoint-Blog (SharePoint 2007) bei den Kommentaren das Titelfeld mit der kompletten Zeile ausgeblendet werden. Dazu wurde die Datei post.aspx im SharePoint Designer geöffnet und folgender Code eingefügt (für Ihre Anwendung die Bezeichnung “Titel” austauschen mit der Zeilenbeschriftung, die ausgeblendet werden soll):

<asp:content runat="server" contentplaceholderid="PlaceHolderAdditionalPageHead">
 
	<script type="text/javascript" src="http://pfad_anpassen/jquery-1.4.2.min.js"></script>
	<script type="text/javascript">
	$(document).ready(function(){
		$(":input[title='Titel']").parent().parent().parent().hide();
	});
	</script>
 
</asp:content>

In einer SharePoint-Liste wird das Alter einer Person berechnet als:

Mit diesem Wert soll in einer Silverlight-Anwendung gerechnet werden.

Wenn dieses Feld über einen Web Service ausgelesen wird, dann findet man im XML-Response folgende Zeile für das Alter 9 Jahre:

ows_Alter=”float;#9.000000000000”

Diese muss nun in eine Integer gewandet werden, um mit dem Alter arbeiten [...]]]> Dieser Blog beschreibt die folgende Situation:

In einer SharePoint-Liste wird das Alter einer Person berechnet als:

Mit diesem Wert soll in einer Silverlight-Anwendung gerechnet werden.

Wenn dieses Feld über einen Web Service ausgelesen wird, dann findet man im XML-Response folgende Zeile für das Alter 9 Jahre:

ows_Alter=”float;#9.000000000000”

Diese muss nun in eine Integer gewandet werden, um mit dem Alter arbeiten zu können. Im konkreten Fall ging es um eine Alterstatistik. Die Lösung sieht folgendermaßen aus:

Alter  = Int32.Parse(x.Attribute(“ows_Alter”).Value.Split(‘#’)[1].Split(‘.’)[0]),

Achtung: das Komma ist keine Fehler, der Ausdruck steht in einem Linq-Select