• Performanter Lösungsweg, da der Suchindex asynchron aufgebaut wird
• Security Trimming in der Ergebnisliste
• Über C#, JavaScript oder REST abrufbar

In SharePoint 2013 wurden diese Ansätze natürlich weiterhin erweitert und vereinfacht . Da aufgrund von SharePoint Apps JavaScript immer wieder mehr an Bedeutung findet, möchte ich in diesem Artikel zeigen, wie die REST API für die Suche über JavaScript verwendet werden kann.

Accessing Search using REST API

Der Vorteil von Rest besteht darin, dass es sich lediglich um eine URL handelt. Dadurch kann der Aufruf und das Ergebnis im Browser getestet werden ohne eine Zeile Code zu schreiben. Die Grundstruktur von Rest sieht dabei wie folgt aus:

http://<Site Url>/_api/<SP API>/<Operation>?<Parameters>

In unserem Fall würde die Url wie folgt aufgebaut sein:

http://<Site Url>/_api/search/query?querytext=’test’

Wird diese Url im Bowser aufgerufen, so wird ein XML mit interessanten Eigenschaften als Antwort vom Server zurückgegeben. Zum Beispiel die Anzahl der Treffer.

Search Properties

Die Suchanfrage kann an Hand vieler Parameter gefiltert werden. Typische Anwendungsfälle wären zum Beispiel:

• die Filterung der Ergebnisse an Hand des Autors oder einer speziellen Source ID
• maximale Anzahl an Ergebnissen pro Seite (für Paging) oder Gesamt
• Angabe der benötigten Managed Properties (Title, Author, Path)
• …

Eine ausführliche Auflistung aller Möglichkeiten inklusive Code-Beispiel findet sich auf MSDN.

Calling the REST service from JavaScript

Ich habe mir zunächst über Napa eine neue SharePoint App erstellt und das AppManifest.xml mit den notwendigen Berechtigungen erweitert.

Damit wird sichergestellt, dass die App Zugriff auf die SharePoint Suche besitzt und die Anfrage nicht in einem Access Denied endet.

Im nächsten Schritt habe ich der Default.aspx eine einfache Suchmaske ohne viel Magie hinzugefügt.

<div>
    <input type="text" id="searchBox"></input>
    <input type="button" id="searchBtn" value="Search"></input>
    <div id="searchResult" />
</div>

Zum Schluss wechseln wir zur App.js und fügen den eigentlichen REST Aufruf hinzu. Bei dem hier dargestellten Lösungsweg handelt es sich um einen vereinfachten objektorientierten Ansatz. Es ist zu empfehlen diese Logik in eine eigene JavaScript Datei mit eigenem Namespace auszulagern, nur möchte ich der übersichtshalber hier darauf verzichten.

'use strict';
var context = SP.ClientContext.get_current();
var SPSearchResults = {
      elem : '',
      url : '',
      init : function(elem, query) {
          SPSearchResults.elem = elem;
          SPSearchResults.url = _spPageContextInfo.webAbsoluteUrl + "/_api/search/query?querytext='" + query + "'";
      },
      load: function() {
          $.ajax(
           {
                  url: SPSearchResults.url,
                  method: "GET",
                  headers: {"accept" : "application/json;odata=verbose"},
                  success: SPSearchResults.onSuccess,
                  error: SPSearchResults.onFailed
           }
          )
      },
      onSuccess: function(data) {
             var results = data.d.query.PrimaryQueryResult.RelevantResults.Table.Rows.results;
             if(results.length === 0) {
                    $(SPSearchResults.elem).text("no results were found.");
             } else {
                    var resultHtml = "<div class='searchResults'>";
                    $.each(results, function(index, result) {
                              resultHtml += "Title: <a href='" + result.Cells.results[6].Value + "'>" + result.Cells.results[3].Value + "</a> <br/>" + 
                              "Content: " + result.Cells.results[10].Value + "<br/>" + 
                              "Type: " + result.Cells.results[17].Value + "<br/>" + 
                              "Modified: " + new Date(result.Cells.results[8].Value).toString("MMMM") + "<br/>";
                    })
                    resultHtml += "</div>";
                    $(SPSearchResults.elem).html(resultHtml);
             }
      },
      onFailed: function(error) {
             $(SPSearchResults.elem).text("An unexpected error occurred.");
      }
  }

// This code runs when the DOM is ready and creates a context object which is
// needed to use the SharePoint object model
$(document).ready(function () {
    $("#searchBtn").click(function() {
           SPSearchResults.init($("#searchResult"), $("#searchBox").val());
           SPSearchResults.load();
    });
});

Der dargestellte Code erstellt in der Methode init in Abhängigkeit des Suchwortes eine REST Query. Durch die Methode load wird diese Anfrage unter der Verwendung von jQuery ausgeführt. War die Anfrage erfolgreich so wird in der Methode onSuccess durch die Ergebnisse iteriert und in dem gewünschten Div angezeigt. Sollte diese Anfrage in einem Fehler enden, so wird diese über onFailed behandelt.

Fazit

Immer mehr Anwendungen setzen für die Aggregierung von Daten auf die SharePoint Suche um Performance zu gewährleisten. Dabei kann die Such API auch über JavaScript und REST angesprochen werden, um diese Vorteile auch in einer SharePoint App anzuwenden. Verwendet kann diese Lösung nicht nur in Apps, sondern auch in allen Farm- oder Sandbox-Solutions wo auf JavaScript gesetzt wird.

Ich persönlich begrüße es, dass die Suche für die Entwicklung immer mehr in den Vordergrund gestellt wird, da ich sehr viel Wert auf Performance lege. Ich hoffe dieser kurze Artikel hat euch ebenfalls von der Mächtigkeit der neuen SharePoint 2013 REST API überzeugt und wie immer freue ich mich auf Euer Feedback

Create an App

Zunächst habe ich mit Visual Studio 2012 ein neues SharePoint 2013 App Projekt vom Typ SharePoint-Hosted App erzeugt.

Anschließend muss die App.js wie folgt angepasst werden:

var fieldXml = '<Field Type="Geolocation" DisplayName="Geo Location" />';

$(document).ready(function () {
    ProvisionBingMaps();
});

function ProvisionBingMaps() {
    var context = SP.ClientContext.get_current();
    var hostContext = new SP.AppContextSite(context, GetParam("SPHostUrl"));
    var web = hostContext.get_web();
    context.load(web);

    var listCreationInfo = new SP.ListCreationInformation();
    listCreationInfo.set_title("Bing Maps");
    listCreationInfo.set_description("You can use this list to store Geolocation Informations");
    listCreationInfo.set_templateType(SP.ListTemplateType.genericList);

    web.get_lists().add(listCreationInfo);

    var list = web.get_lists().getByTitle("Bing Maps");
    if (list != null || list != "undefined") {
        var fields = list.get_fields();
        fields.addFieldAsXml(fieldXml, true, SP.AddFieldOptions.addToDefaultContentType);
    }

    var webProperties = web.get_allProperties();
    webProperties.set_item("BING_MAPS_KEY", "<Valid Bing Maps Key>");
    web.update();

    context.executeQueryAsync(function () { $("#message").text("Provisioning succeeded.") }, Function.createDelegate(this,OnFailed));
}

function OnFailed(sender, args) {
    $("#message").text("Provisioning failed: " + args.get_message() + "\n" + args.get_stackTrace());
}

function GetParam(param) {
    var params = document.URL.split("?")[1].split("&");
    for (var i = 0; i < params.length; i++) {
        prop = decodeURIComponent(params[i]);
        if (prop.indexOf(param) > -1)
            return prop.split("=")[1];
    }
}

Wird die App das erste mal aufgerufen, so wird eine neue benutzerdefinierte Liste inklusive Geolocation Feld dem Host Web hinzugefügt. Darüber hinaus wird noch der Bing Maps Key im SharePoint bekannt gemacht, was sonst mittels PowerShell oder C# hätte gemacht werden müssen.

Kurz zusammengefasst, macht die App alles notwendige auf Seitens SharePoint, damit die Funktionalität am Ende komplett von den Benutzern genutzt werden kann.

Rufen die Benutzer die Liste auf, so ist die komplette Geolocation Funktionalität gegeben:

Fazit

Das es sich bei der Geolocation Funktionalität in SharePoint 2013 um ein sehr mächtiges Feature handelt, ist bei vielen bereits bekannt. Ein großer abschreckender Faktor waren die einzelnen Konfigurationsschritte:

• SQL Server Feature aktivieren
• Bing Maps Key im SharePoint bekannt machen
• Geolocation Feld erzeugen
• Liste erzeugen

Dieser Artikel zeigt, dass auch auf Basis einer App und mit JavaScript die 3 letzten Konfigurationsschritte automatisiert realisiert werden können. Und das mit recht wenig Aufwand und auch wenig Quellcode

Ich hoffe ich konnte euch damit weiterhelfen und wie immer freue ich mich über Feedback.

Anwendung könnte diese Art von Navigation in Intranets finden und wer bereits einen ersten Blick auf Office 365 geworfen hat, wird jene auch da vorgefunden haben

Technisch baut dieser Artikel auf einen vorangegangenen Artikel auf, welcher die einzelnen Schritte zum Erstellen eines SuiteLinks Delegate Control ausführlich beschreibt. Von daher wird nur der Codeblock näher betrachtet, an dem die Terms geladen werden. Aber bevor es technisch wird, müssen redaktionelle Vorarbeiten geleistet werden.

Add Terms to Termstore Manager

Über die Site Settings zum Termstore Manager navigieren und sicherstellen, dass das Recht zum hinzufügen von Elementen besteht. Anschließend eine neue Gruppe hinzufügen und dessen ID sich gut merken, denn diese benötigen wir zu einem späteren Zeitpunkt nocheinmal

Unterhalb dieser Gruppe muss ein neues Termset hinzugefügt und auch dessen ID sich für später gemerkt werden.

Außerdem erlauben wir für dieses erstellte Termset die Verwendung in der Navigation.

Damit können die einzelnen Navigationspunkte als Terms hinzugefügt und die gewünschte URL hinterlegt werden.

Implement Delegate Control

Nachdem ein SuiteLinks Delegate Control auf Basis des vorangegangenen Artikels erstellt wurde, muss in diesem Fall das beziehen der benutzerspezifischen Links aus dem Termstore Manager angepasst werden. Dazu in den Code-Behind des UserControls navigieren und dieses wie folgt anpassen:

protected override void Render(HtmlTextWriter writer)
{
    writer.RenderBeginTag(HtmlTextWriterTag.Style);
    writer.Write(".ms-core-suiteLinkList {display: inline-block}");
    writer.RenderEndTag();
    writer.AddAttribute(HtmlTextWriterAttribute.Class, "ms-core-suiteLinkList");
    writer.RenderBeginTag(HtmlTextWriterTag.Ul);
    RenderCustomLinks(writer);
    writer.RenderEndTag();
    base.Render(writer);
}

private void RenderCustomLinks(HtmlTextWriter writer)
{
    var lcid = System.Threading.Thread.CurrentThread.CurrentUICulture.LCID;
    string simpleUrl = String.Empty;
    TaxonomySession session = new TaxonomySession(SPContext.Current.Site);
    TermStore termStore = session.DefaultSiteCollectionTermStore;
    var group = termStore.Groups[new Guid("bd122f89-7f19-43b6-939b-57376fe17337")];
    var termSet = group.TermSets[new Guid("1a44f71c-ba9f-43dd-b4ad-7915b7ad6bac")];
    foreach (var term in termSet.Terms)
    {
        simpleUrl = string.Empty;
        if(term.LocalCustomProperties.TryGetValue("_Sys_Nav_SimpleLinkUrl", out simpleUrl))
            RenderSuiteLink(writer, simpleUrl , term.GetDefaultLabel(lcid), "Shell" + term.Id, false);
    }
}

Dieser Codeblock baut eine Verbindung zum Termstore Manager auf und lädt alle Terms innerhalb einer Gruppe und eines Termsets mit einer bestimmten ID Anschließend wird für jeden Term geprüft ob eine URL hinterlegt wurde. Sollte dies der Fall sein, so wird in Abhängigkeit der aktuellen Sprache die Standardbezeichnung des Terms geholt und der Link gerendert.

Rufen wir das Ergebnis im Browser auf, so ergibt sich folgendes Bild:

Die Terms die vor wenigen Minuten noch in den Termstore Manager eingepflegt wurden, erstrahlen nun in Form von SuiteLinks. Es können damit jederzeit Änderungen im Termstore Manager vorgenommen werden, welche sich direkt auf die gerenderten SuiteLinks auswirken.

Fazit

Das SuiteLinks und Managed Navigation in SharePoint 2013 viel gefragte Themen sind, können sich bestimmt viele Denken. Von daher ist es um so effektiver diese 2 Sachen miteinander zu vereinen und den Nutzern die größtmögliche Flexibilität zu bieten. Dieses Beispiel hat gezeigt, dass mit relativ wenig Aufwand gepflegte Terms aus dem Termstore Manager ausgelesen und als SuiteLinks dargestellt werden können. Diese Lösung funktioniert auch Site Collection bzw. Web Application übergreifend und bringt somit einen Mehrwert in Intranets mit eventueller MySite.

Dieser Ansatz kann auch mit JavaScript realisiert und somit als App bereitgestellt werden. Dazu könnte Ihr hier mehr erfahren.

Ich hoffe dieser Artikel hat euch gefallen und ich freue mich wie immer auf Feedback

Es gibt aber 2 Möglichkeiten diese wieder anzeigen zu lassen, welche nun im Detail beschrieben werden.

Modify Master Page

Die gewünschte Master Page entweder mit dem SharePoint Designer oder eine Kopie aus der Master Page Gallery herunterladen und mit einem Editor bearbeiten. Dabei muss folgender Codeblock angepasst werden, sodass kein visible=false oder display:none mehr enthalten ist.

Vorher:

<div class="ms-breadcrumb-dropdownBox" style="display:none;">
<SharePoint:AjaxDelta id="DeltaBreadcrumbDropdown" runat="server">
	<SharePoint:PopoutMenu
		Visible="false"
		runat="server"
		ID="GlobalBreadCrumbNavPopout" ...

Nachher:

<div class="ms-breadcrumb-dropdownBox">
<SharePoint:AjaxDelta id="DeltaBreadcrumbDropdown" runat="server">
	<SharePoint:PopoutMenu
		runat="server"
		ID="GlobalBreadCrumbNavPopout" ...

Anschließend die Änderungen in SharePoint bereitstellen und gegebenenfalls veröffentlichen.

Using Delegate Control

Wenn die Master Page nicht angepasst werden soll, so können die Änderungen auch programmatisch mit einem Delegate Control umgesetzt werden. Dazu mittels Visual Studio eine SharePoint 2013 Farm Solution erstellen und ein Delegate Control hinzufügen. Das Delegate Control sollte im AdditionalPageHead platziert und im CodeBehind folgender Code eingefügt werden:

protected override void OnLoad(EventArgs e)
{
    base.OnLoad(e);
    this.Page.PreRender += new EventHandler(Page_PreRender);
}

void Page_PreRender(object sender, EventArgs e)
{
    var masterPage = this.Page.Master;
    if (masterPage == null)
        return;
    var delta = masterPage.FindControl("DeltaBreadcrumbDropdown") as AjaxDelta;
    if (delta != null)
    {
        var breadcrumb = delta.FindControl("GlobalBreadCrumbNavPopout") as PopoutMenu;
        if (breadcrumb != null)
        {
            breadcrumb.Visible = true;
            breadcrumb.ThemeKey = "spcommon";
            breadcrumb.IconUrl = "/_layouts/15/images/spcommon.png";
            this.Page.Header.Controls.Add(new LiteralControl("<style type=\"text/css\">.ms-breadcrumb-dropdownBox { display: inline-block !important; }</style>"));
        }
    }
}

Anschließend das Delegate Control einem Feature vom Scope Web Application oder Site zuweisen und deployen.

Fazit

Egal welche Variante verwendet wird, es ergibt sich daraus folgendes Resultat:

Es wird die aus SharePoint 2010 bekannte Navigate Up Breadcrumb angezeigt Es ist zwar schade, dass die Breadcrumb standardmäßig ausgeblendet ist, aber dieser Artikel zeigt 2 einfache Möglichkeiten jene wieder einzublenden. Ich hoffe euch hilft dieser Artikel und wie immer freue ich mich über Feedback.

Und damit die Nutzer nicht den Überblick über Ihre Aktivitäten verlieren, bietet sich der neue Newsfeed auf der MySite an. Ähnlich wie bei Facebook oder Yammer, nur das in SharePoint immer zwangsweise auf die MySite navigiert werden muss, um sich die neusten Nachrichten, Mentions oder Aktivitäten anzusehen. Dadurch können wichtige Informationen sehr schnell verloren gehen, wenn ein Tag mal nicht die MySite benutzt wird.

Um dieses Problem zu vermeiden, müssen MySite Benachrichtigungen in die SharePoint Inhaltsseiten implementiert werden, um die zwei SharePoint Welten miteinander zu vereinen. Dies könnte wie folgt aussehen:

In diesem Beispiel findet der Nutzer in den Promoted Actions ein Brief Symbol mit der Anzahl der ungelesenen Mentions. Sobald der Nutzer in einem weiteren Eintrag namentlich erwähnt wird, so erscheint eine Benachrichtigung ohne die Seite neuladen zu müssen. Klickt der Benutzer auf die Benachrichtigung oder das Symbol, so wird er zum Newsfeed weitergeleitet und kann sich die neuen Informationen einsehen.

Implementation

In SharePoint 2013 kann diese Funktion auf unterschiedliche Art und Weise implementiert werden. Entweder serverseitig mittels C# oder unter der Verwendung des Client Object Models. Ich habe mich in diesem Fall für Variante 2 auf Basis von JavaScript entschieden.

Für die gezeigte Funktionalität muss sichergestellt sein, dass die folgenden JavaScript Dateien geladen wurden:

• SP.js
• SP.UserProfiles.js

Überprüft kann das ganze mittels ExecuteOrDelayUntilScriptLoaded. Anschließend kann mit folgenden Script für den aktuellen Nutzer die Aktivitäten sowie die ungelesenen Mentions innerhalb eines gewissen Zeitraums ausgelesen werden:

var activities;
var clientContext = SP.ClientContext.get_current();
var feedManager = new SP.Social.SocialFeedManager(clientContext);
var options = new SP.Social.SocialFeedOptions();
options.set_newerThan(new Date("03/22/2013"));
options.set_olderThan(new Date());
options.set_sortOrder(SP.Social.SocialFeedSortOrder.byModifiedTime);
activities= feedManager.getFeed(SP.Social.SocialFeedType.news, options);
clientContext.load(feedManager);
clientContext.executeQueryAsync(function () {
            console.log("unread Mentions:" + activities.get_unreadMentionCount());
            console.log("activities:" + activities.get_threads().length);
        }, function () { console.log("error"); });

Wird dieses Script ausgeführt, so erscheinen in der Konsole des Browsers 2 Ausschriften. Im nächsten Schritt kann man dieses Script in eine Methode auslagern und diese in einem bestimmten Intervall immer wieder aufrufen lassen. So erscheint dann im folgenden Beispiel immer aller 30 Sekunden die Ausschrift.

setInterval(function () { loadMentions(); }, 30000);

function loadMentions() {
.....
}

Damit ist sichergestellt, dass der Nutzer auch bei Inaktivität über Neuigkeiten in seinem Newsfeed aller 30 Sekunden benachrichtigt wird.

Schließlich muss anstelle der Konsolenausschrift im Browser noch schicke SharePoint Benachrichtigungen angezeigt und das Symbol in den Promoted Links aktualisiert werden. Natürlich kann auch noch der Titel der Seite  angepasst werden, damit der Nutzer sieht in dem Browser Tab ist was passiert. Aber das ist das geringste Problem denke Ich

Fazit

Microsoft hat einen großen und wichtigen Schritt mit SharePoint 2013 und den integrierten Social Funktionen getan, jedoch die 2 SharePoint Welten zu wenig mit einander integriert. Mir persönlich sind viele Informationen an mir vorbei gegangen, weil ich nicht stündlich mein Newsfeed durchforstet habe. Das war für mich der Grund etwas zu ändern und auch diese hier dargestellte Lösung zu entwickeln. Ähnlich wie bei Facebook oder Yammer erhalte ich auch auf SharePoint TeamSites Benachrichtigungen über eine neue Erwähnung oder eine wichtige Aktivität und kann mir diese mit einem Klick im Detail auf dem Newsfeed anschauen. Für mich und meine Kollegen ein großer Mehrwert

Ich hoffe euch hat dieser Artikel und die kleinen technischen Ausschnitte gefallen und freue mich über Feedback

Als Ausgangspunkt setze ich wieder auf den Empfehlungen von Microsoft auf, welche in folgenden Artikel veröffentlicht wurden.

Create a Multilingual App

Zunächst erstelle Ich mit Visual Studio 2012 ein neues SharePoint 2013 App Projekt vom Typ SharePoint-Hosted App. Die Struktur meiner App sieht anschließend wie folgt aus:

Im nächsten Schritt erzeugen wir die benötigten Ressourcen auf Basis von JavaScript Dateien. Dazu im Ordner Scripts die benötigten JavaScript Dateien nach folgender Namenskonvention hinzufügen.

Resources.LL-CC.js (LL = Language, CC = Country)

Example: Resources.en-US.js 

Als Fallback habe ich noch eine neutrale Ressource Resources.js hinzugefügt, da ich nicht jede Sprachvariante unterstützen kann. Mein Ordner Scripts sieht anschließend wie folgt aus:

Nun gilt es, diese Ressourcen Dateien mit Informationen zu befüllen. Microsoft selber erstellt für jeden Ressourceneintrag eine eigene JavaScript Variable. Ich hingegen bevorzuge den Objektorientierten Ansatz, welcher wie folgt aussieht:

_EnsureJSNamespace('msscorner');
msscorner.Resources = {Welcome:'Willkommen', Error:'Es ist ein Fehler aufgetreten'}

Diese Zeilen JavaScript müssen in jede Ressourcen Datei mit den dementsprechenden Übersetzungen eingefügt werden.

Im weiteren Schritt gilt es, diese JavaScript Dateien zu referenzieren. Dazu in die Default.aspx navigieren und folgende Zeile einbinden:

<script type="text/javascript" src="../scripts/Resources.<SharePoint:EncodedLiteral runat='server' text='<%$Resources:wss,language_value%>' EncodeMethod='HtmlEncode' />.js"></script>

In Abhängigkeit der aktuellen Sprache wird versucht die dementsprechende Ressourcen Datei zu laden. Jedoch kann auch aktuell eine Sprache ausgewählt sein, für die keine Ressourcen Datei hinterlegt wurde. Und genau an dieser Stelle gibt es bei den Empfehlungen von Microsoft Probleme. Daher habe ich mir Gedanken über einen möglichen Fallback Mechanismus gemacht und bin auf folgende Lösung gekommen. Nachdem die App geladen wurde, überprüfe ich mit JavaScript in der App.js ob meine Ressourcen geladen wurden und lade gegebenenfalls meine Fallback Ressource nach. Der Code dafür schaut wie folgt aus:

$(document).ready(function () {
    if (typeof (msscorner) == "undefined" || msscorner == null) {
        $.getScript("../scripts/Resources.js", function () {
            OnInit();
        })
    } else {
        OnInit();
    }
});

function OnInit() {
    //your code
    context = SP.ClientContext.get_current();
    web = context.get_web();
    getUserName();
}

Es wird überprüft ob mein erstellter Namespace msscorner verfügbar ist oder anderenfalls eine Fallback Ressource nachgeladen. Danach ist sichergestellt, dass die Ressourcen geladen wurden und es wird die Methode OnInit aufgerufen, in welcher der restliche Code ausgeführt wird.

Im weiteren Verlauf kann schließlich wie folgt auf die einzelnen Ressourceneintrage an Hand des Namespaces zugegriffen werden:

$('#message').text(msscorner.Resources.Welcome + ' ' + user.get_title());

Ich habe bei mir deutsche Ressourcen hinterlegt, rufe jedoch die App von einer englischen Website her auf. Es müsste demnach die Fallback Ressource mit englischen Beschriftungen geladen werden. Im Browser ergibt sich dann folgendes Resultat:

It Works !

Fazit

Microsoft selber hat mit den veröffentlichen Artikel einen guten Guide zum Thema Mehrsprachige Apps unter SharePoint 2013 geschaffen. Mir persönlich gefällt die objektorientierte Struktur bei Ressourcen besser als die von Microsoft beschriebene Herangehensweise mit einzelnen JavaScript Variablen. Da ich in meinen Projekten öfters das Problem mit Fallback Ressourcen habe, bin ich sehr schnell über dieses Problem gestolpert und hoffe euch mit diesen Artikel geholfen zu haben .

http://technet.microsoft.com/en-us/library/jj819267.aspx

In dieser Übersicht wird auch gezeigt, dass SharePoint Online nicht gleich SharePoint Online ist. Auf Feature Ebene werden die einzelnen Unterschiede sichtbar und auch bei der Anzahl der  Nutzer sind Limits für die einzelnen SharePoint Online Ausprägungen gesetzt.

Mir persönlich hilft dieser Überblick enorm und wie immer bin ich auf euer Feedback sehr gespannt

• App Package entpacken
• Resx Files manuell hinzufügen
• gewisse Manifest und Feature Dateien manuell anpassen
• App Package packen

Ich habe eigentlich erwartet, dass das hinzufügen von Ressourcen und das Setzen von Verweisen automatisch über das Visual Studio oder den TFS beim paketieren passiert. Aber hier zeigt sich, dass die App Entwicklung für SharePoint 2013 nicht ganz trivial ist. Da ich mich aber mit dieser Lösung von Microsoft nicht zufrieden geben wollte, hier ein Ansatz mit dem keine bzw. nur eine manuelle Anpassung notwendig ist.

Create a Multilingual App

Zunächst erstelle Ich mit Visual Studio 2012 ein neues SharePoint 2013 App Projekt vom Typ SharePoint-Hosted App. Die Struktur meiner App sieht anschließend wie folgt aus:

Im nächsten Schritt erzeugen wir die notwendigen Ressourcen. Dazu die AppManifest.xml in der Designview öffnen und im Tab Supported Locales die gewünschten Sprachen hinzufügen.

Damit wurde für die gewünschten Sprachen einzelne Ressourcen Dateien inklusive einer Fallback Variante angelegt. Darin kann nun der Titel der App ausgelagert und in der Codeview der AppManifest.xml muss dann der Titel wie folgt gesetzt werden.

<Title>$Resources:appTitle;</Title>

Stellt man diese App in SharePoint bereit, so ergibt sich folgendes Bild:

Es ist zu sehen, dass die Bezeichnungen aus den Ressourcen stammen. Da allerdings im Company Store für die App eine Metadatensprache definiert werden muss, erscheint in der Navigation daher die englische Bezeichnung. Die Metadatensprache bestimmt, in welcher Sprache die Informationen der App im Store angezeigt werden.

Adding a Custom Action

Es bietet sich an, eine App mittels einer Custom Action zu Erweitern um diese somit besser in SharePoint 2013 zu integrieren. Jedoch kann dabei nicht ganz so einfach auf die erstellten Ressourcen zu gegriffen werden. Doch zunächst fügen wir der App eine Ribbon Custom Action hinzu. Mein Ribbon für meine Custom List sieht in diesem Fall wie folgt aus:

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <CustomAction Id="adfd1f17-a890-49b9-8d73-9fbd7a35c94b.CustomAction"
                RegistrationType="List"
                RegistrationId="100"
                Location="CommandUI.Ribbon"
                Sequence="10001"
                Title="$Resources:_Res,caTitle;"
                HostWebDialog="TRUE"
                HostWebDialogHeight="100"
                HostWebDialogWidth="480">
    <CommandUIExtension>
      <CommandUIDefinitions>
        <CommandUIDefinition Location="Ribbon.List.Settings.Controls._children">
          <Button Id="Ribbon.List.Settings.CustomActionButton"
                  Alt="$Resources:_Res,caTitle"
                  Sequence="100"
                  Command="CARequest"
                  LabelText="$Resources:_Res,caTitle;"
                  Description="$Resources:_Res,caDesc;"
                  TemplateAlias="o1"
                  Image32by32="_layouts/15/images/placeholder32x32.png"
                  Image16by16="_layouts/15/images/placeholder16x16.png" />
        </CommandUIDefinition>
      </CommandUIDefinitions>
      <CommandUIHandlers>
        <CommandUIHandler Command="CARequest"
                          CommandAction="~appWebUrl/Pages/Default.aspx"/>
      </CommandUIHandlers>
    </CommandUIExtension >
  </CustomAction>
</Elements>

Die Bezeichnung und Beschreibung für die Custom Action wurden in Ressourcen ausgelagert und die Verweise gesetzt. Beim Aufruf dieser Custom Action soll ein Dialog mit der Default Page der App erscheinen. Wenn wir diese App im SharePoint bereitstellen und in eine Custom List navigieren, so sieht das Resultat wie folgt aus:

Die Ressourcen werden zwar nicht aufgelöst, aber dafür die App Page im Dialog angezeigt. Passen wir aber das App Package manuell an, so können wir dieses Problem mit den Ressourcen beheben, da ein Verweis nicht gesetzt wird. Dazu muss zunächst die App paketiert werden und sichergestellt sein, dass Winzip auf dem Rechner installiert ist. Ist dies sichergestellt, so müssen anschließend folgende Schritte durchgeführt werden:

• Das App Package mit WinZip öffnen und im Ordner _rels die AppManifest.xml.res öffnen
• Die folgenden Relationship Einträge für die Ressourcen suchen und kopieren.

<Relationship Type="http://schemas.microsoft.com/sharepoint/2012/app/relationships/content-defaultresource" Target="/Resources.resx" Id="R584e73144fd34ef1" />
<Relationship Type="http://schemas.microsoft.com/sharepoint/2012/app/relationships/content-resource" Target="/Resources.en-US.resx" Id="Ra4724a7f504b4876" />
<Relationship Type="http://schemas.microsoft.com/sharepoint/2012/app/relationships/content-resource" Target="/Resources.de-DE.resx" Id="Rba23b9da54ba40a5" />

• Im Ordner _rels die Feature<Guid>.xml.rels Dateien öffnen und die kopierten Zeilen einfügen
• Das Archiv mit Änderungen aktualisieren und speichern

Nun haben wir das App Package manuell angepasst und es kann über den Company Store bereitgestellt werden. Rufen wir danach die App im SharePoint in einer Custom List auf, so erscheint folgendes Resultat:

Die Ressourceneinträge werden diesmal aufgelöst und die App Page öffnet sich natürlich weiterhin im Dialog.

Fazit

Es ist möglich eine App mit Ressourcen bereitzustellen. Jedoch sollte sich vorher Gedanken gemacht werden, ob dies auch wirklich sinnvoll ist. Denn der App Store und der Company Store ist dafür ausgelegt, dass die Informationen zu einer App immer in einer Sprache angezeigt werden. Es handelt sich dabei um die Metadatensprache. Lediglich Bezeichnungen von Custom Actions werden in Abhängigkeit der aktuellen Sprache angezeigt. Trotzdem hoffe ich, dass euch der Artikel geholfen hat und freue mich wie immer über Feedback.

Wer aber auf eines der fehlenden Site Templates nicht verzichten kann, kann sich einer dieser hier dargestellten Tricks bedienen. Jedoch muss zuvor erwähnt werden, dass die Site Templates nicht ohne Grund nicht mehr über die Oberfläche zur Verfügung stehen. Mehr dazu aber später .

Using PowerShell

Lässt man sich über PowerShell die zur Verfügung stehenden Site Templates über den folgenden Befehl ausgeben, so erscheint eine sehr lange Liste.

Get-SPWebTemplate

Betrachtet man diese Liste etwas genauer, so fallen in der Oberfläche alle fehlenden Site Templates auf.

Auf Basis dieser Liste kann anhand des Namen des Site Templates eine neue Website erstellt werden. Dazu folgende Zeilen PowerShell ausführen:

$template = Get-SPWebTemplate "STS#1"
New-SPSite -Url "<Site URL>" -OwnerAlias "<domain\user>" -Template $template

Damit ist es Möglich, eine Site auf Basis eines über die Oberfläche nicht zur Verfügung stehenden Template zu erstellen.

Modify WEBTEMP.xml

Die ausgeblendeten Site Templates können natürlich auch in der Oberfläche wieder bereitgestellt werden. Dazu einfach die WEBTEMP.xml in folgendem Pfad mit einem Editor öffnen.

C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\15\TEMPLATE\1033\XML\

Anschließend die gewünschten Site Templates suchen und das Attribute Hidden=”TRUE” auf Hidden=”FALSE” setzen. Für die Blank Site sieht das anschließend wie folgt aus:

<Configuration ID="1" Title="Blank Site" Hidden="FALSE" ImageUrl="/_layouts/15/images/stbs.png?rev=23" Description="A blank site for you to customize based on your requirements." DisplayCategory="Collaboration" AllowGlobalFeatureAssociations="False" ></Configuration>

Erstellt man über die Oberfläche eine neue Site Collection, so steht nach dieser Änderung das Site Template Blank Site wieder zur Verfügung.

Microsoft says

Meeting Workspace site templates

Description: When you create a site in SharePoint 2013, all five of the Meeting Workspace site templates are not available. This includes the Basic Meeting Workspace, Blank Meeting Workspace, Decision Meeting Workspace, Social Meeting Workspace, and Multipage Meeting Workspace.

Reason for change: SharePoint 2013 and Office 2013 provide other features that support meetings and collaboration. For example, you can use Lync to conduct live meetings, OneNote to take notes during meetings, and a SharePoint team site or My Site to store shared meeting notes.

Migration path: Existing sites that were created by using the Meeting Workspace site templates will continue to operate in SharePoint 2013. The Meeting Workspace site templates will be removed completely from the next major release of SharePoint and sites that were created by using the Meeting Workspace site templates will not be supported.

Document Workspace site template

Description: When you create a site in SharePoint 2013, the Document Workspace site template is not available.

Reason for change: The scenario of collaborating on a document is now provided by the Team Site site template. The Document Workspace site template was removed from SharePoint 2013 to simplify the list of templates that are available when a user creates a new site collection.

Migration path: Existing sites that were created by using the Document Workspace site template will continue to operate in SharePoint 2013. The Document Workspace site template will be removed completely from the next major release of SharePoint and sites that were created by using the Document Workspace site template will not be supported.

Option 1

Den gewünschten Browser unter einer anderen Identität öffnen. Dazu die SHIFT Taste gedrückt halten und einen Rechtsklick auf das Browsersymbol. Es öffnet sich ein Kontextmenü mit der Option Als anderer Benutzer ausführen. Anschließend werden die Berechtigungen abgefragt und es öffnet sich der Browser unter der anderen Identität. Wenn SharePoint 2013 auf SingleSingOn Konfiguriert ist, so wird diese Identität verwendet.

Option 2

SharePoint ganz normal über den Browser aufrufen und durch folgende Url die Seite einfach mit einer neuen Identität besuchen:

http://<URL>/_layouts/closeConnection.aspx?loginasanotheruser=true

Es erscheint daraufhin ein Fenster mit den neuen Nutzerinformationen. Anschließend erscheint die Seite in der neuen Identität.

Option 3

Den aus SharePoint 2010 bekannten Menüeintrag einfach manuell hinzufügen. Da es sich hierbei um eine Anpassung einer Systemdatei handelt empfiehle ich diesen Schritt nicht. Aber ich möchte euch diesen natürlich auch nicht vorenthalten.

Folgende Datei im Verzeichnis suchen und mit einem Editor öffnen:

C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\15\TEMPLATE\CONTROLTEMPLATES\Welcome.ascx

Nun folgendes Element vor dem vorhandenen ID_RequestAccess Element einfügen:

<SharePoint:MenuItemTemplate runat="server" ID="ID_LoginAsDifferentUser"
Text="<%$Resources:wss,personalactions_loginasdifferentuser%>"
 Description="<%$Resources:wss,personalactions_loginasdifferentuserdescription%>"
 MenuGroupId="100"
 Sequence="100"
 UseShortId="true"
 />

In manchen Fällen muss danach ein ApplicationPool Recycle oder IISReset durchgeführt werden, damit die Änderung wirksam wird.

Fazit

Ich war Anfangs sehr erstaunt, dass der Menüpunkt entfernt wurde. Nichts desto trotz gibt es Möglichkeiten sich weiterhin mit einer anderen Identität anzumelden. Da Microsoft auch einen offiziellen Artikel zu diesem Problem veröffentlicht hat, kann es sich dabei vielleicht auch um einen Fehler handeln, welcher vielleicht mit kommenden Updates behoben wird. Wir können dahingehend nur gespannt in die Zukunft blicken und abwarten