🪢 Sven Sieverding

Digitale Analogien – Wie Bürogegenstände helfen, Microsoft 365 besser zu verstehen

Sven Sieverding — Thu, 19 Mar 2026 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2026-03-19/

import { Image } from 'astro:assets'; import egg from './1774005477577.png';

Die digitale Arbeitswelt kann manchmal verwirrend sein – besonders, wenn es um die richtige Ablage von Dateien in Microsoft 365 geht. Viele Nutzer stehen vor der Frage: Wo speichere ich was? Teams, SharePoint, OneDrive – und was ist eigentlich ein privater Kanal? Um das verständlich zu machen, nutze ich fünf Analogien aus dem Büroalltag. Sie helfen, die Funktionen und Einsatzbereiche der verschiedenen Tools greifbar zu machen.

Diese Analogie will ich euch heute im Rahmen der Serie "Eggs of Knowledge" vom MVP-Treff nahebringen. Schaut da mal vorbei, es da könnt ihr noch viele weitere spannende EInblicke zu Projekten, Best Practices und Perspektiven rund um Microsoft 365, Copilot und Modern Work finden.

Rollcontainer – Dein persönlicher Speicher: OneDrive

Stell dir deinen Rollcontainer unter dem Schreibtisch vor: Er gehört nur dir, du kannst ihn abschließen und alles darin ablegen – von Akten bis zur Banane. Es gibt keine vorgeschriebene Ordnung, und niemand außer dir hat Zugriff. In der digitalen Welt entspricht das dem OneDrive: Dein persönlicher Speicherplatz, in dem du alles ablegen kannst, was du möchtest. Wichtig: Wenn du das Unternehmen verlässt, wird der Rollcontainer geleert und die Inhalte vernichtet – genauso wird dein OneDrive gelöscht und die Dateien gehen verloren. Für langfristige Unternehmensdaten ist OneDrive daher nicht geeignet.

Aktenschrank – Gemeinsame Ordnung: SharePoint

Der Aktenschrank steht im Flur und ist für alle zugänglich. Hier gibt es eine klare Ordnung, auf die sich das Team geeinigt hat – zum Beispiel nach Jahren sortiert. Die Akten bleiben auch nach deinem Ausscheiden im Unternehmen erhalten. SharePoint ist das digitale Pendant: Thematisch geordnete Speicherorte, auf die mehrere Personen zugreifen können. Die Inhalte sind nicht an einzelne Nutzer gebunden und überdauern deren Zeit im Unternehmen. SharePoint eignet sich für langfristige, teamübergreifende Dokumentenablage.

Projektraum – Zusammenarbeit auf Zeit: Microsoft Teams Team

Ein Projektraum ist ein temporärer Raum, in dem ein Projektteam zusammenkommt, gemeinsam arbeitet und kollaboriert. Hier können Aktenschränke, Kalender und Aufgabenlisten aufgestellt werden – alles, was für das Projekt relevant ist. Die Tür ist abschließbar, nur das Projektteam hat Zugang. Microsoft Teams bildet diesen Projektraum digital ab: Ein Team kann gemeinsam auf Ressourcen wie SharePoint, Planner und Kalender zugreifen und jedes Teammitglied hat automatisch Zugriff auf alle Ressourcen im Team. Die Zusammenarbeit ist effizient und auf das Projekt zugeschnitten.

Abgeschlossene Ecke im Projektraum – Private Kanäle in Teams

Im Projektraum größerer Projekte gibt es manchmal eine kleine, abgeschlossene Ecke – zum Beispiel für die Projektleitung. Hier sind bestimmte Akten und Informationen nur für ausgewählte Personen zugänglich. Um dorthin zu gelangen, muss man aber grundsätzlich immer zuerst durch den Projektraum. In den den privaten Raum zu gelangen, ohne den Projektraum zu durchqueren, ist unmöglich. Private Kanäle in Teams funktionieren genauso: Sie sind abgetrennte Bereiche innerhalb eines Teams, zugänglich nur für bestimmte Mitglieder. Man kann niemanden nur in den privaten Kanal einladen, man muss immer durch das Team dorthin gelangen. Auch stehen dort einige Funktionen wie etwa der Microsoft Planner nicht zur Verfügung – So wie auch die kleine abgeschlossene Ecke im Projektraum kein vollwertiger Raum ist und man dort auch nicht alles machen kann, da man dort ggf. keine echten Wände hat, sondern vielleicht nur Glasscheiben, die die Ecke vom Projektraum trennen.

Meetingraum – Temporärer Austausch: Microsoft Teams Meetings

Ein Meetingraum wird für Besprechungen genutzt. Die Teilnehmer bringen ihre Unterlagen mit, tauschen sich aus und nehmen die Akten danach wieder mit zurück ins Büro. Im Meetingraum bleibt nichts dauerhaft liegen. Microsoft Teams Meetings sind das digitale Äquivalent: Dateien können während des Meetings geteilt und bearbeitet werden, sind aber nicht für die dauerhafte Ablage gedacht. Nach dem Meeting sollten die Dateien wieder in den richtigen Aktenschrank (SharePoint) oder Rollcontainer (OneDrive) zurückgelegt werden. Den analogen Meetingraum solltet ihr ja auch in dem Zustand hinterlassen, in dem ihr ihn vorgefunden habt. Spätestens bei der Säuberung des Raumes werden dort dann ja auch dann alle Gegenstände entfernt, die da nicht hingehören.

Kurzgesagt

Ich hoffe, die Analogien haben euch ein wenig geholfen und ihr habt nun ein besseres Verständnis, wann man wo in M365 Dateien ablegen sollte. Ich fasse hier nochmal kurz zusammen:

OneDrive für persönliche, temporäre Dateien
SharePoint für teamübergreifende, langfristige Dokumente
Teams für projektbezogene Zusammenarbeit
Private Kanäle für vertrauliche Bereiche im Team
Meetings für den kurzfristigen Austausch

Hoste eine Webseite in Azure

Sven Sieverding — Tue, 12 Aug 2025 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2025-08-12/

Ich hatte neulich einen Kunden, der eine interne HTML-basierte Webseite mit PDF Berichten hostet. Diese Seite war mal auf einem Webserver im internen Unternehmensnetz gespeichert, soll aber nun aus dem Internet erreichbar sein, damit per Smartphone darauf zugegriffen werden kann.

Die HTML-Seiten der Webseite selber werden übrigens mittels Excel und vieler Makros generiert. Das ist auch ein spannendes Konstrukt, aber von dem erzähle ich euch ein anders Mal.

Es gibt an das Hosting der Webseite einige Anforderungen:

Sie soll nur für Mitarbeiter des Unternehmens sichtbar sein
Der bestehende Erzeugungsmechanismus soll bestehen bleiben. Nur der bisherige "Kopier" Mechanismus auf den lokalen Webserver soll durch einen ebenso einfachen anderen Mechanismus ersetzt werden.

Das können wir mittels Azure und einer kleinen "nodejs" Anwendung abbilden

Eine Webapp im Azure anlegen

Legen wir zunächst die Webseite im Azure an. Dazu öffnen wir zuerst die Azure Startseite

https://portal.azure.com/

und suchen dann oben in der Suchleiste nach "App Services".

Dann wählen wir oben links "Create" und erstellen eine neue Web App.

Nun gelangen wir auf den Erstellungsformular einer neuen Webapp. Hier müssen wir zunächst eine ResourceGroup anlegen. Das ist eine Art Ordner, der verschiedene inhaltlich zusammengehörende Azure Dienste bündelt. Ich wähle hier "HTMLFileHosting". Der Name ist aber im Prinzip egal.

Danach müssen wir die Programmiersprache auswählen, in der unsere App geschrieben ist. Im Moment haben wir zwar noch keine App, sondern nur ein paar HTML-Dateien, aber wir werden im Folgenden eine "nodejs" Applikation erstellen, mit der wir die HTML-Dateien hosten. Daher wählen wir "Node 22. LTS" aus. Die Region (Das Rechenzentrum), in dem wir die WebApp hosten wollen, setze ich auf "Germany West Central" (Das im Moment mir nächste Rechenzentrum)

Danach klicke ich unten auf den "Review & Create" Button und auf dem nächsten Screen auf den "Create" Button. Nun wird die Webapp erstellt. Ich warte nun, bis mir mitgeteilt wird, dass das Deployment beendet wurde. Danach klicke ich auf "Go to resource", um auf den Konfigurationsbildschirm der Webapp zu kommen.

Konfiguration und Sicherheit

Gut, nun haben wir eine leere Webapp erzeugt. Bei der Webapp müssen wir nun zwei Dinge einstellen:

einen einfachen Deployment Mechanismus
Authentifizierung. Wir wollen, dass nur Mitarbeiter des Unternehmens diese Seite sehen dürfen.

Wir befinden uns nun erstmal auf der Haupt-Konfigurationsseite der Webapp.

Auf der rechten Seite sehen wir die URL der App. Wir können sie im Browser öffnen und sehen einen Platzhalter-Text. Die URL sieht etwas kryptisch aus, aber dem Kunden war das erstmal egal. Wir können unsere eigene URL für diese App definieren, aber das tue ich nicht im Rahmen dieses Beitrags.

Wir beginnen mit der Konfiguration, indem wir links im Menu auf "Settings"-> "Configuration" klicken

Hier müssen wir zwei Schalter auf "On" setzten:

"SCM Basic Auth Publishing enabled"
"FTP Basic Auth Publishing enabled"

Mit diesen beiden Schaltern aktiviere wir später auf dem "Deployment" Bildschirm die Möglichkeit, dass wir per Git und unserem eigenen Passwort deployen können.

Zunächst sichern wir die App aber erstmal ab. Dazu wechseln wir auf den "Authentication" Bildschirm.

Hier ist noch kein Identity Provider installiert. Das bedeutet, dass die App für jeden aus dem Internet zugreifbar ist. Das ändern wir, indem wir auf "Add Identity Provider" klicken

Wir wählen den Provider "Microsoft" aus und lassen alle anderen Einstellungen so, wie sie sind. Der Effekt ist nun, dass nur noch Benutzer auf die Seite zugreifen können, die im Microsoft Entra des Unternehmens aufgelistet sind. Damit ist schonmal eine der Anforderungen erfüllt.

Deployment Einstellungen

Nun müssen wir die App noch einfach deployen können. Dazu wechseln wir ins "Deployment Center".

Hier können wir uns als Quelle für das Deployment verschiedene Versionsverwaltungssysteme auswählen. Danach könnten wir definieren, dass die App automatisch neu deployt werden soll, sobald sich in dem Versionsverwaltungssystem etwas ändern.

In diesem Szenario hat der Kunde aber keines, sondern nur automatisch erzeugte HTML-Dateien. Daher wählen wir hier zur Einfachheit die Variante "Local Git". Damit wird uns in der WebApp ein Git Zugang bereitgestellt. Wenn wir dorthin Dateien per Git pushen, dann werden diese automatisch in die Webapp deployt. Wunderbar, das lässt sich einfach lokal skripten. Dazu aber später mehr.

Zunächst wählen wir hier "Local Git" und klicken auf "Save".

Danach ändert sich der Bildschirm und wir können uns die "Git Clone URL" kopieren. Das ist die Adresse, an die wir später per Git unsere Webseite pushen können

Dazu brauchen wir aber Benutzername und Passwort. Die können wir uns unter dem Reiter "Local Git/FTPS Credentials" im Bereich "User Scope" selber setzen

Eine nodejs App als Webserver

Nun müssen wir in einem lokalen Verzeichnis unsere Webapplikation erstellen. Das klingt schlimmer als es ist - sie besteht nur aus zwei Textdateien und einem Ordner.

Legen wir zunächst den leeren Ordner "public" an. In diesem Ordnet legen wir dann später die HTML-Dateien ab, die wir später hosten wollen.

Dann legen wir eine leere Datei namens "package.json" and und fügen diesen Inhalt ein:

	  
{
  "scripts": {
    "start": "node server.js"
  },
  "dependencies": {
    "express": "^5.1.0"
  }
}

Das ist die Haupt-Projektdatei unseres Webservers. Sie enthält eigentlich nur zwei Einträge: Die Definition, wie der Server zu starten ist und die Information, dass der Server die Bibliothek "Express" braucht. Das reicht der Webapp erstmal.

Nun legen wir eine weitere Textdatei namens "server.js" an.

	  
const express = require('express')
const app = express()
const port = process.env.PORT


app.use(express.static('public'))

app.listen(port, () => {
  console.log(`App Listening ${port}`)
})

Die paar Zeilen Code definieren einen Webserver, der alle Dateien aus dem Verzeichnis "public" hosted. Fügt nun noch die HTML und CSS Dateien in das public Verzeichnis ein und dann war es das mit der Erstellung des Servers.

Jetzt müssen wir dieses Verzeichnis nur noch automatisch per Skript in unsre Webapp deployen.

Deployment per Git

Das machen wir, wie oben schon angedeutet, über das Git-Tool. Das ist eigentlich ein Tool zur Versionskontrolle von Quellcode, es lässt sich aber auch anderes anwenden. Zunächst müssen wir das Tool installieren, falls es noch nicht geschehen ist.

Ladet euch dazu den Installer von dieser Webseite herunter und führt ihn aus.

Öffnet danach eine Windows Kommandozeile oder Powershell und navigiert in das Verzeichnis, was wir eben erstellt haben. Ich klicke eigentlich immer mit der rechten Maustaste irgendwo in das Verzeichnis und wähle "In Terminal öffnen", aber das könnt ihr machen, wie ihr wollt.

Wichtig ist nur, dass ihr für die nächsten Schritte in dem Verzeichnis seid, das wir vorhin angelegt haben.

Führt nun nacheinander die folgenden Kommandos aus:

Zunächst initialisieren wir ein leere Git-Repository in dem Ordner

	  git init

Dann fügen wir alle Dateien in dem Ordner zum Repository hinzu und checken sie mit dem Kommentar "Initiales Einchecken" ein

    git add *
    git commit -m "Initiales Einchecken"

Jetzt definieren wir ein neues Remote-Repository namens "azure" mit der Git-URL, die wir in einem der Schritte oben definiert haben.

    git remote add azure <GITURL>

Also zum Beispiel in meinem Fall. Kopiert das aber nicht, benutzt in jedem Fall eure eigene URL.

    git remote add azure https://htmlfilehosting-b8hcakgbeffggsad.scm.germanywestcentral-01.azurewebsites.net:443/HTMLFileHosting.git

Wunderbar. Nun führen wir als letztes den folgenden Befehl aus

    git push azure main:master

Damit weisen wir Git an, unser lokales Repository an das Deployment Repository im Azure zu verschicken. Anders ausgedrückt: Wir weisen Git an, das Deployment zu starten.

Ihr werdet nun noch auf die eine oder andere Art nach einem Benutzernamen und Passwort gefragt werden. Gebt hier die Credentials ein, die wir oben als User Credentials vergeben haben. Git speichert die Daten für zukünftige Deployments.

Die Webseite deployt nun und ist nach ein paar Sekunden unter der App URL verfügbar.

Beim ersten Login müsst ihr wahrscheinlich noch einmal der Berechtigungsanfrage von Microsoft Entra zustimmen, aber danach läuft die App per Password abgesichert.

Wir sind nun mit dem initialen Deployment fertig.

Und nun?

Super, jetzt ist die Seite deployt und per Entra Authentifizierung abgesichert. Vielleicht denkt ihr nun, dass das alles ein wenig kompliziert war und dass ihr das noch bei jeder Änderung der HTML-Dateien wiederholen wollt.

Das braucht ihr aber auch glücklicherweise nicht.

Falls sich in Zukunft etwas an den HTML-Dateien ändert, dann braucht ihr nur in dem Verzeichnis diese drei folgenden Befehle ausführen

    git add *
    git commit -m "Neue Version der Dateien"
    git push azure main:master

Git wird dann alle geänderten Dateien einchecken und deployen. Wenn ihr diese drei Befehle nun in z.B. in den Windows Scheduler einträgt und sie jeden Tag ausgeführt werden, dann werden immer alle im Laufe des Tages erzeugten Dateien im Verzeichnis "public" deployt. Sollte es keine Änderungen gegeben haben, führen die drei Kommandos ansonsten auch kein weiteres Deployment durch.

MCP, Agenten und LLMS: Science Fiction oder Realität?

Sven Sieverding — Tue, 03 Jun 2025 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2025-06-03/

Tron

Im Film „Tron“ aus dem Jahr 1982 wird der von Jeff Bridges gespielte Kevin Flynn in eine digitale Computerwelt transportiert. Dort kämpft er gemeinsam mit dem Programm Tron (gespielt von Bruce Boxleitner) gegen den menschlichen Gegenspieler Ed Dillinger (David Warner) und das sogenannte MCP – das Master Control Program. Ursprünglich als KI-Schachprogramm entwickelt, hat sich das MCP im Laufe der Zeit immer mehr Rechte angeeignet und herrscht schließlich als düstere Kontrollinstanz über die gesamte digitale Welt.

Danach wurde es mehr als vierzig Jahre lang recht still bezüglich der Kombination der Begriffe Künstliche Intelligenz (KI), Programme und MCP. Das hat sich aber in den letzten Monaten mit der Verbreitung generativer KI (Copilot, ChatGPT und Co.) geändert.

Aber keine Angst: Die Möglichkeiten von heute lassen nicht befürchten, dass eine KI seine Reichweite vergrößern will und andere Programme übernimmt... Obwohl, wenn ich so darüber nachdenke... irgendwie schon, aber anders.

Damit ihr die im Moment im Internet herumgeisternden Begriffe Large Language Models (LLM), Agenten und MCP einordnen könnt, werde ich euch erst einmal erzählen, worum es dabei geht.

Large Language Models: Die Basis für moderne Chatbots

Beginnen wir mit den sogenannten Large Language Models (LLM), großen Sprachmodellen, wie sie in ChatGPT oder Microsoft Copilot zum Einsatz kommen. Diese Technologie ist ein zentraler Bestandteil der KI-Revolution, die vor etwa drei Jahren richtig Fahrt aufgenommen hat.

Dank dieser Modelle können wir in natürlicher Sprache mit einem Chatbot kommunizieren, der uns versteht und auf ein enormes Wissensreservoir zugreifen kann. Technisch basieren LLMs auf komplexen statistischen Verfahren, die Eingaben (Prompts) analysieren und daraus die wahrscheinlich passendste Antwort generieren: als Text, als Bild oder sogar als Video.

Warum sind die Chatbots so beliebt? Das ist einfach zu erklären. Mit so einer generativen KI kann ich mit natürlicher Sprache kommunizieren und bekomme Antworten mit auf den ersten Blick sehr vernünftigen Texten.

Aus Sicht vieler Menschen trifft diese Technologie daher genau den Sweetspot zwischen "gefühlter Einfachheit" und "gefühlter Nützlichkeit”. Das ist ein Effekt, den im Verlauf der Menschheit nur wenige Technologien erzielt haben.

Agenten automatisieren Aufgaben

Die Leistung von Chatbots ist schon beeindruckend. Aber im Arbeitsalltag möchten wir nicht immer mit einem neuen Prompt bei Null anfangen. Hilfreicher ist es, wenn die KI direkt mit unternehmensspezifischen Daten arbeiten und bestimmte Aufgaben automatisch übernehmen kann.

Hier kommen sogenannte Agenten ins Spiel (bei ChatGPT heißen sie Custom GPTs, bei anderen Herstellern können sie auch andere Namen haben). Diese lassen sich mit speziellem Wissen und klaren Anweisungen ausstatten, um definierte Aufgaben zu erfüllen.

Ein Beispiel: Ein Chatbot für den Bereich Human Ressources (HR) kann so konfiguriert werden, dass er ausschließlich auf Informationen aus dem Intranet zugreift und nur Fragen zu Karriere und Bewerbung beantwortet. Sobald seine Informationen nicht mehr ausreichen, verweist er an eine zuständige Kollegin oder einen Kollegen. So entlastet er das HR-Team bei Routinefragen.

Autonome Agenten arbeiten automatisch

Bis hierhin läuft die Interaktion noch über einen klassischen Chat: Die Benutzer:innen stellen Fragen – der Agent antwortet. Doch was, wenn die KI von sich aus aktiv wird?

Genau das leisten autonome Agenten: Sie reagieren auf Auslöser und führen anschließend eigenständig Aktionen aus.

Ein autonomer Agent erkennt beispielsweise automatisch eingehende Rechnungen in E-Mails, extrahiert Kundennamen, Rechnungsnummer und Betrag und leitet die Nachricht je nach Kunde an den:die zuständige Sachbearbeiter:in weiter.

Ein anderer Agent erstellt uns jeden Morgen automatisch eine Zusammenfassung der wichtigsten E-Mails vom Vortag und schickt sie uns. Mit ein wenig Kreativität sind hier die Möglichkeiten riesig.

Model Context Protocol: Werkzeuge in der Hand der KI

Das Model Context Protocol (MCP) ermöglicht Agenten die Ausführung noch komplexerer Aufgaben: Es handelt sich um eine standardisierte und herstellerunabhängige Schnittstelle, mit der Agenten eigenständig Informationen aus anderen Systemen abrufen oder dort Aktionen ausführen können.

Ein Beispiel: Ein Agent greift über MCP auf ein SAP-System zu, liest bestimmte Daten aus, analysiert diese aufgrund seines Prompts und führt für jeden Datensatz eine definierte Transaktion im SAP aus. Es arbeitet also genauso wie ein Softwareprogramm, nur dass dieses in natürlicher Sprache formuliert ist.

Solche Integrationen sind keine Zukunftsmusik: SAP integriert MCP bereits aktiv in seine Produkte. 

Zum Beispiel auch die 3D-Software Blender bietet eine MCP-Schnittstelle. Damit können Anwender:innen per Chat ihre lokale Blender-Instanz steuern: zur Vereinfachung, wenn sie nicht alle Blender Befehle und Shortcuts kennen, oder zur Effektivitätssteigerung, wenn sie dem Programm direkte fachliche Anweisungen geben wollen (z.B. „Vergrößere die Ohren bei dem 3D-Modell eines Hasen, das ich gerade bearbeite.“). 

Immer mehr Hersteller entwickeln solche Schnittstellen – nicht nur für große Cloud-Anwendungen, sondern auch für lokale Programme. So können Agenten künftig mit nahezu jeder Software interagieren und Aufgaben für uns übernehmen.

Die nahe Zukunft: Agenten vs. Werbetreibende

Das alles muss man erst einmal sacken lassen, denn die Auswirkungen sind enorm. Wir können Prozesse in natürlicher Sprache definieren, automatisieren und Software fernsteuern. Richtig eingesetzt, können Agenten unsere Arbeit deutlich effizienter machen.

Und es geht noch weiter: Stellen wir uns einmal vor, ich sage einem Einkaufsagenten, dass ich neue T-Shirts brauche. Der Agent sucht selbstständig passende Angebote im Web, legt sie in den Warenkorb und fordert mich nur noch auf, den Kauf abzuschließen.

Zukunftsmusik? Keineswegs. Ich habe solche Prototypen Ende Mai live auf dem European Collaboration Summit gesehen.

Autonome Agenten wie der T-Shirt-Einkäufer haben nun aber auch weitreichende Folgen:

Ich war als Nutzer selbst nicht mehr auf der Webseite eines Unternehmens. Das bedeutet: Ich habe dort keine Werbung gesehen.
Ich habe selbst nicht entschieden, wo gekauft wird. Das hat der Agent für mich übernommen.

Webseitenbetreiber müssen sich darum fragen, wie sie mit dieser Entwicklung umgehen:

Wenn ich auf meiner Seite Werbung schalten und die Agenten blockieren würde, damit Nutzer:innen die Anzeige sehen, verlöre ich potenzielle Kunden. Sie würden von ihrem Agenten schlicht nie mehr auf meine Seite geschickt. So platziere ich mich quasi selbst auf die zweite Seite der Suchergebnisse bei Google.
Wenn meine Seite zwar hübsch aussieht, aber für Agenten schwer lesbar ist, dann werden diese meine Services nicht an ihre Benutzer weiterleiten. Als Webseitenbetreiber muss ich mir daher Gedanken über eine barrierefreie Gestaltung meiner Seite machen (die übrigens jetzt schon für viele digitale Produkte und Services gesetzlich vorgeschrieben ist).Diese fördert u.a. mit strukturierten Daten die Lesbarkeit der Seite.
Als Konsequenz wird auch SEO an Bedeutung verlieren. Es wird stattdessen wichtiger, die Inhalte und Daten meiner Website so zu optimieren, dass sowohl Menschen als auch KI-Agenten sie leicht verstehen. So lenke ich mehr Agenten auf meine Seite und damit mehr Benutzer auf meine Webseite.

Der letzte Akt unserer Geschichte

Dies ist nur der Anfang und nur ein Bereich, in dem Agenten in den nächsten Monaten und Jahre gewaltige Auswirkungen haben werden. Sie werden immer mehr Fähigkeiten gewinnen und uns in noch nicht bekanntem Maß Aufgaben abnehmen können.

Es ist jedoch eher unwahrscheinlich, dass ein Szenario wie das in "Tron" wahr wird, in dem ein Schachprogramm sich selbstständig alle anderen Programme untertan macht und danach als "Master Control Program" die digitale Welt beherrscht.

So etwas wie das Programm Tron hingegen halte ich für sehr realistisch. Im Film wurden ihm nämlich von seinem Programmierer die Fähigkeiten und der Auftrag übergeben, die Macht des MCP zu brechen und Ordnung in der digitalen Welt wiederherzustellen. Tron ist ein gutes Beispiel für einen Agenten, der in der Lage ist, den ihm erteilten Auftrag eigenständig und mithilfe der ihm zur Verfügung gestellten Werkzeuge auszuführen.

Die Homepage einer SharePoint Site per PowerAutomate setzten

Sven Sieverding — Tue, 01 Apr 2025 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2025-04-01/setsphomepage/

import SPRestAPI from "../../../components/RestComponents/SPRestAPI.jsx"

Ihr könnt in der "WebsiteSeiten" Bibliothek eine beliebige Datei markieren und diese dann über das Menu als Homepage/Startseite der aktuellen SharePoint Site setzen.

Was ihr über die Oberfläche aber zum Beispiel nicht machen könnt, ist eine Ansicht einer Liste als Homepage zu definieren. Das gilt auch für diverse andere Systemseiten.

Wenn ihr das trotzdem machen wollt oder einfach nur die Homepage automatisch per PowerAutomate Flow setzen wollt, dann könnt ihr das mittels der SharePoint REST API und der Aktion “HTTP Anforderung an SharePoint senden” erreichen.

Die Aktionen

  <SPRestAPI client:load
    site="#siteUrl#"
    url="_api/web/RootFolder"
    method="POST"
    headers={{
      "Accept":"application/json",
      "Content-Type":"application/json",
      "X-HTTP-Method":"MERGE"
    }}
    params={[
      {name: "Site Collection URL", key: "siteUrl", type: "text" ,"description":"Die Adresse der SharePoint Site, auf der wir die Aktion ausführen wollen",default:"https://contoso.sharepoint.com/sites/mysite"},
      {name: "relative HomePage URL ", key: "hpURL", type: "text","description":"Die Relative Url zu der Seite, die die Homepage werden soll." ,default:"SitePages/Department-Homepage.aspx"}          
    ]}

    body='

{"__metadata": { "type": "SP.Folder" }, "WelcomePage": "#hpURL#" } '

  ></SPRestAPI>

Auswahlmöglichkeiten einer SharePoint "Auswahl" Spalte per PowerAutomate setzten

Sven Sieverding — Tue, 25 Mar 2025 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2025-03-25/

import SPRestAPI from "../../../components/RestComponents/SPRestAPI.jsx"

Ihr könnt in einer SharePoint Liste eine Spalte vom Typ "Auswahl" definieren. Das ist praktisch, dass ihr damit euren Benutzern die Auswahlmöglichkeiten in der Spalte vorgeben könnt.

Leider gibt es im PowerAutomate aber keine Standard-Aktion, um die möglichen Auswahlwerte per Flow zu setzen. Das ist aber kein Problem, da wir hierfür die SharePoint REST API und die Aktion "HTTP Anforderung an SharePoint senden" verwenden können.

Die Aktionen

  <SPRestAPI client:load
    site="#siteUrl#"
    url="_api/web/lists/getbytitle('#listtitle#')/fields/getbytitle('#columntitle#')"
    method="POST"
    headers={{
      "Accept":"application/json",
      "Content-Type":"application/json"
    }}
    params={[
      {name: "Site Collection URL", key: "siteUrl", type: "text" ,"description":"Die Adresse der SharePoint Site, auf der wir die Aktion ausführen wollen",default:"https://contoso.sharepoint.com/sites/mysite"},
      {name: "List Title", key: "listtitle", type: "text","description":"Der Titel der Liste, in dem die zu ändernde Spalte enthalten ist (Displayname)" ,default:"<listTitle>"},
      {name: "Column Title", key: "columntitle", type: "text","description":"Der Name der zu ändernden Spalte (Displayname)" ,default:"<columnTitle>"}          
    ]}

    body='{"Choices":["Choice 1","Choice 2","Choice 3"],"DefaultValue":"Choice 1"}'

  ></SPRestAPI>

Eine SiteCollection per PowerAutomate erstellen

Sven Sieverding — Mon, 17 Mar 2025 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2025-03-17/

import SPRestAPI from "../../../components/RestComponents/SPRestAPI.jsx" import ParseJsonAction from "../../../components/RestComponents/ParseJsonAction.jsx"

Manchmal wollt ihr vielleicht eine SharePoint Site automatisch per PowerAutomate erstellen.

Das geht im Standard nicht, wir können das aber mittelt der "HTTP Anforderung an SharePoint senden" Aktion und der SharePoint REST API erreichen.

Das Setup ist hier aber ein wenig komplizierter: Statt einfach die Aktion zu benutzen, müssen wir hier sicherstellen, dass der ausführende User auch die Rechte hat, um eine Site zu erstellen. Bei vielen Tenants ist das nur durch einen SharePoint Administrator möglich. In dem Fall müsst ihr eine Connection an der Aktion einstellen, die die entsprechenden Rechet hat.

Die Aktionen

  <SPRestAPI client:load
    site="#adminsiteUrl#"
    url="_api/SPSiteManager/create"
    method="POST"
    headers={{
      "Accept":"application/json",
      "Content-Type":"application/json"
    }}
    params={[
      {name: "Admin Site Collection URL", key: "adminsiteUrl", type: "text" ,"description":"Die Adresse der SharePoint Site, auf der wir die Aktion ausführen wollen",default:"https://contoso-admin.sharepoint.com"},
      {name: "Site Title", key: "siteTitle", type: "text","description":"Der Titel/Displayname der zu erstellenden Seite." ,default:"MeineSeite"},
      {name: "Description", key: "description", type: "text" ,"description":"Die Beschreibung der zu erstellenden Seite",default:"Das ist meine neue Seite"},
      {name: "Site Collection URL", key: "siteUrl", type: "text" ,"description":"Die Adresse der zu estellenden Seite",default:"https://contoso.sharepoint.com/sites/mysite"},
      {name: "Owner", key: "owner", type: "text" ,"description":"Der Besitzer der Seite als Emailadresse.",default:"vorname.nachname@contoso.com"},
      {name: "Sprache der Seite", key: "lcid", type: "choice","description":"Die Sprache der Seite (1031 für Deutsch, 1033 für English)" ,default:"1031", "choices":[
        {"value":"Deutsch (1031)","key":"1031"},
        {"value":"Niederländisch (1043)","key":"1043"},
        {"value":"Englisch (1033)","key":"1033"},
        {"value":"Französisch (1036)","key":"1036"}
        ]},          
      {name: "WebTemplate", key: "template", type: "choice","description":"Das Template der Seite (Team Site/Communication Site)" ,default:"SITEPAGEPUBLISHING#0", "choices":[
        {"value":"Communication Site","key":"SITEPAGEPUBLISHING#0"},
        {"value":"Team Site ohne M365 Gruppe","key":"STS#3"},
        {"value":"Team Site","key":"TeamSite"}
        ]},
    ]}

    body='{

"request": { "Title": "#siteTitle#", "Url": "#siteUrl#", "Description": "#description#", "Owner": "#owner#", "Lcid": #lcid#, "WebTemplate": "#template#", "SiteDesignId": "f6cc5403-0d63-442e-96c0-285923709ffc", "ShareByEmailEnabled": false } }'

  ></SPRestAPI>

Die Ausgabe der Aktion muss dann noch mittels einer "Parse JSON" ("JSON analysieren") Aktion umgewandet werden. Daraus erhalten wir dann die Properties "SiteId" und "SiteUrl", die wir dann im folgenden weiter benutzen können

Per PowerAutomate einen Benutzer einer SharePoint Gruppe hinzufügen

Sven Sieverding — Sat, 22 Feb 2025 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2025-02-22/

import SPRestAPI from "../../../components/RestComponents/SPRestAPI.jsx"

In Powerautomate findet ihr zwar Aktionen, mit denen ihr M365 Gruppen bearbeiten könnt und mit denen ihr einzelne Freigabelinks für Dateien erstellen könnt, aber ihr findet nicht, womit man Mitglieder zu einer SharePoint Gruppe hinzufügen kann.

Das ist aber kein Problem, da wir hierfür die SharePoint REST API und die Aktion "HTTP Anforderung an SharePoint senden" verwenden können.

Die Gruppen

Zunächst brauchen wir dafür aber die interne ID der Gruppe, in die wir den User einfügen wollen. Für die drei Standard-Gruppen sind das die IDs

3 für die Besitzergruppe,
4 für die Besuchergruppe und
5 für die Mitgliedergruppe

Um die IDs einer anderen Gruppe zu bestimmen, schaut euch diesen Artikel an.

Die Aktionen

  <SPRestAPI client:load
    site="#siteUrl#"
    url="_api/web/sitegroups(#groupid#)/users"
    method="POST"
    headers={{
      "Accept":"application/json",
      "Content-Type":"application/json"
    }}
    params={[
      {name: "Site Collection URL", key: "siteUrl", type: "text" ,"description":"Die Adresse der SharePoint Site, auf der wir die Aktion ausführen wollen",default:"https://contoso.sharepoint.com/sites/mysite"},
      {name: "Gruppen ID der SharePoint Gruppe", key: "groupid", type: "text","description":"Die interne GruppenID der SharePoint Gruppe; in die der User eingefügt werden soll." ,default:"<GruppenID>"},
      {name: "Email Adresse des Users", key: "userMail", type: "text","description":"Der Loginname des hinzuzufügenden Users (als Emailadresse)" ,default:"loginname@domain.com"}          
    ]}

    body='{"__metadata":{"type":"SP.User"},"LoginName":"i:0#.f|membership|#userMail#"}'

  ></SPRestAPI>

Die Berechtigungsvererbung für ein Listenelement per PowerAutomate aufheben

Sven Sieverding — Fri, 07 Feb 2025 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2025-02-17/

import SPRestAPI from "../../../components/RestComponents/SPRestAPI.jsx"

Normalerweise erben Listenelemente und Dateien im SharePoint ihre Berechtigungen vom übergeordneten Ordner oder der Bibliothek/Liste selbst.

Wenn wir das ändern wollen und einem Element eigene Berechtigungen zuweisen wollen, dann müssen wir diese Berechtigungsvererbung zunächst unterbrechen. Erst danach können wir die Berechtigungen an dem Element wie in diesem Artikel beschreiben ändern

Über die Oberfläche machen wir das, indem wir auf die drei Punkte neben dem Element klicken und dann "Zugriff verwalten" auswählen. Hier klicken wir nun wiederum ganz oben rechts auf die drei kleinen Punkte und wählen "Erweiterte Einstellungen". Auf dem sich öffnenden Bildschirm wählen wir nun "Berechtigungsvererbung unterbrechen" aus der Ribbon.

In Powerautomate gibt es daber dazu keine vorgefertigte Aktion und wir müssen sie dort und mittels der “HTTP Anforderung an SharePoint senden” Aktion und der SharePoint RestAPI selber erstellen.

Die Aktion

  <SPRestAPI client:load
    site="#siteUrl#"
    url="_api/lists/getByTitle('#listtitle#')/items(#itemid#)/breakroleinheritance(copyRoleAssignments=#copyRoleAssignments#, clearSubscopes=#clearSubscopes#)"
    method="POST"
    headers={{
      "Accept":"application/json",
      "Content-Type":"application/json"
    }}
    params={[
      {name: "Site Collection URL", key: "siteUrl", type: "text" ,"description":"Die Adresse der SharePoint Site, auf der wir die Aktion ausführen wollen",default:"https://contoso.sharepoint.com/sites/mysite"},
      {name: "List Title", key: "listtitle", type: "text","description":"Der Titel/Displayname der Liste mit dem Element" ,default:"<listname>"},          
      {name: "Item ID", key: "itemid", type: "text","description":"Die ID des Items, bei dem die Berechtigung unterbrochen werden soll" ,default:"<itemID>"},
       {name: "Bestehende Berechtigungen kopieren", key: "copyRoleAssignments", type: "choice","description":"Sollen die Berechtigungen des übergeordneten Elements an dieses Element kopiert werden oder sollen an diesem Element alle Berechtigungen gelöscht werden?" ,default:"false", "choices":[
        {"value":"Keine Berechtigungen an dieses Element kopieren","key":"false"},
        {"value":"Berechtigungen des übergeordneten Elements an dieses Element kopieren","key":"true"}
        ]},
        {name: "Subscopes löschen?", key: "clearSubscopes", type: "choice","description":"Sollen auch die Berechtigungen von untergrordneten Elementen dieses Elements entfernt werden oder nicht?" ,default:"true", "choices":[
        {"value":"Keine Berechtigungen an dieses Element kopieren","key":"false"},
        {"value":"Berechtigungen des übergeordneten Elements an dieses Element kopieren","key":"true"}
        ]},                  
    ]}

    body=' '

  ></SPRestAPI>

Copilot und das RAG Pattern

Sven Sieverding — Fri, 22 Nov 2024 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2024-11-22/

In der heutigen digitalen Welt sind KI-gestützte Tools wie Microsoft Copilot unverzichtbar geworden, um die Produktivität zu steigern und komplexe Aufgaben zu vereinfachen. Doch mit der zunehmenden Nutzung solcher Technologien kommen auch Bedenken auf, insbesondere hinsichtlich des Datenschutzes und der Sicherheit. Ein häufig gestelltes Frage ist: Trainiert Microsoft ein KI-Modell mit meinen Daten? In diesem Blogartikel werden wir diese Frage klären und das RAG Pattern (Retrieval Augmented Generation) erläutern, das von Copilot verwendet wird, um diese Bedenken zu zerstreuen.

Trainiert Microsoft ein KI-Modell mit meinen Daten?

Viele Menschen haben die Befürchtung, dass ihre Daten zum Training von KI-Modellen verwendet werden könnten. Diese Sorge ist verständlich, da persönliche und geschäftliche Daten sensibel sind und geschützt werden müssen. Dem ist jedoch nicht so. Microsoft hat klare Richtlinien und Technologien implementiert, um sicherzustellen, dass die Daten der Benutzer nicht zum Training der KI-Modelle verwendet werden.

Warum wäre das schlecht für Microsoft?

Es gibt mehrere Gründe, warum es für Microsoft nicht praktikabel wäre, individuelle Kundendaten zum Training der KI-Modelle zu verwenden:

Hoher Ressourcenaufwand: Das Training eines KI-Modells mit den Daten jedes einzelnen Kunden würde enorme Rechnerkapazitäten erfordern. Diese Daten könnten möglicherweise nie genutzt werden, was zu einer ineffizienten Nutzung der Ressourcen führen würde.
Komplexität der Modellaktualisierung: Wenn Microsoft die GPT-Modelle hinter Copilot mit speziellen Kundendaten trainieren würde, wäre es extrem aufwendig, diese Modelle zu aktualisieren. Jedes Mal, wenn ein neues Modell eingeführt wird, müssten die Daten jedes Kunden erneut integriert werden. Dies würde die Verwaltung und Wartung der Modelle erheblich erschweren.

Stattdessen benutzt Copilot das RAG Pattern

Um diese Herausforderungen zu umgehen und gleichzeitig die Effizienz und Sicherheit zu gewährleisten, verwendet Microsoft Copilot das RAG Pattern. RAG steht für Retrieval Augmented Generation und ist eine innovative Methode, um KI-gestützte Antworten zu generieren, ohne die Daten der Benutzer zum Training zu verwenden.

Wie funktioniert das RAG Pattern?

Das RAG Pattern kombiniert die Stärken der semantischen Suche und der generativen KI, um präzise und relevante Antworten zu liefern. Der Prozess lässt sich in folgende Schritte unterteilen:

Anfrage des Benutzers: Ein Benutzer stellt eine Anfrage an Copilot, beispielsweise eine Frage oder eine Aufgabe, die erledigt werden muss.
Semantische Suche: Copilot führt eine semantische Suche durch, um alle Dokumente und Informationen zu finden, die mit der Anfrage des Benutzers in Zusammenhang stehen. Diese Suche basiert auf der Bedeutung der Wörter und Phrasen, um die relevantesten Ergebnisse zu identifizieren.
Weiterleitung an das GPT-Modell: Die gefundenen Dokumente und die ursprüngliche Anfrage des Benutzers werden an ein schreibgeschütztes GPT-Modell weitergeleitet. Dieses Modell ist darauf spezialisiert, basierend auf den bereitgestellten Informationen eine kohärente und hilfreiche Antwort zu generieren.
Antwortgenerierung: Das GPT-Modell erzeugt eine Antwort, die auf den gefundenen Dokumenten und der Anfrage des Benutzers basiert. Diese Antwort wird dann von Copilot an den Benutzer zurückgeschickt.

Vorteile des RAG Patterns

Das RAG Pattern bietet mehrere Vorteile, die sowohl die Sicherheit als auch die Effizienz der KI-gestützten Antworten gewährleisten:

Datenschutz und Sicherheit: Das GPT-Modell wird von Microsoft innerhalb der Tenant-Grenzen gehostet. Das bedeutet, dass keine Daten aus dem Tenant abfließen oder zum Training verwendet werden. Die Daten bleiben sicher und geschützt innerhalb der Grenzen des jeweiligen Kunden.
Flexibilität und Aktualisierbarkeit: Microsoft kann das GPT-Modell jederzeit durch ein aktuelleres Modell ersetzen, ohne für jeden Kunden nachtrainieren zu müssen. Dies ermöglicht eine schnelle und effiziente Aktualisierung der Modelle, um stets die besten und neuesten Technologien zu nutzen.
Effiziente Ressourcennutzung: Durch die Verwendung des RAG Patterns werden die Rechnerkapazitäten effizient genutzt, da nur relevante Informationen für die Antwortgenerierung verwendet werden. Dies reduziert den Ressourcenaufwand und erhöht die Effizienz der KI-gestützten Prozesse.

Fazit

Das RAG Pattern ist eine leistungsstarke Methode, die von Microsoft Copilot verwendet wird, um präzise und relevante Antworten zu generieren, ohne die Daten der Benutzer zum Training der KI-Modelle zu verwenden. Dies gewährleistet sowohl die Sicherheit als auch die Effizienz der KI-gestützten Prozesse und ermöglicht es Microsoft, stets die neuesten Technologien zu nutzen, um die besten Ergebnisse zu liefern.

Für Softwareentwickler und IT-Entscheider ist es wichtig zu verstehen, wie diese Technologien funktionieren und welche Vorteile sie bieten. Das RAG Pattern ist ein hervorragendes Beispiel dafür, wie innovative Ansätze die Herausforderungen des Datenschutzes und der Effizienz meistern können, um eine sichere und produktive Nutzung von KI-gestützten Tools wie Microsoft Copilot zu gewährleisten.

SharePoint Hub Sites statt Unterwebsites

Sven Sieverding — Sun, 13 Oct 2024 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2024-10-13/

Einleitung

In der modernen Welt von SharePoint Online gibt es keine Hierarchie mehr zwischen den Sites. Alle Sites liegen technisch gleichwertig nebeneinander. Dies ist ein bedeutender Unterschied zu den alten On-Premise-Sites, bei denen es die Möglichkeit gab, Unterwebsites anzulegen. Diese Funktion existiert in SharePoint Online nicht mehr.

Was war das Problem mit Unterwebsites?

Unterwebsites waren technisch in einer SiteCollection enthalten. Daher war das Verschieben einer Site in eine andere Position kompliziert. Teilweise wurden SiteCollections durch Unterwebsites riesig, und Sites mit vielen Unterwebsites konnten schlechter gesichert und wiederhergestellt werden. Einzelne Sites sind hier einfacher zu handhaben.

Unterwebsites sind auch keine vollständigen Sites. Sie teilen sich verschiedene Kataloge mit allen anderen Subsites innerhalb der Sitecolletion. Zum Beispiel werden Contenttypen zwischen allen Subsites einer Site geteilt, was schnell unübersichtlich werden kann. Und dann stellt sich schnell die Frage: Welcher Contenttype gehört zu welcher Site? Und kann der gelöscht werden oder nicht.

Außerdem vermischt man mit Subsites Navigation und Datenablage. Warum sollte eine Site überhaupt innerhalb einer anderen Site enthalten sein? Genausogut könnten die auch einfach nebeneinander liegen. Um dann zu einem untergeordneten Thema zu gelangen, ist nur eine leichtgewichtige Navigation nötig, keine physische Ablagestruktur. Das ist "Ordnerdenken" und nicht "Denken in Intranets".

Gleichberechtigte Sites

Daher ist in modernen SharePoint die Anlage von Subsites im Standard auch ausgeschaltet. Das neue Konzept sieht vor, dass alle Sites physisch nebeneinander liegen und es keine Hierarchie zwischen ihnen gibt.

Aber manchmal brauche ich so eine Art Hierarchie

Das ist richtig. Als Besitzer eines Intranets möchtest du zum Beispiel, dass die siteübergreifende Navigation auf allen Sites gleich ist und du sie nicht auf jeder Site doppelt pflegen musst. Ferner willst du vielleicht noch andere Einstellungen von einer Site auf viele Sites übertragen.

Die Hub-Site als Verteiler von Einstellungen

Dafür gibt es das Konstrukt des "Hubs". Ein Hub selbst ist auch nur eine Site, aber du kannst verschiedene Sites an den Hub "andocken". Die Topnavigation, das Theme und je nach Bedarf auch Teile der Berechtigungen werden dann auf die Sites im Hub vererbt. Die Sites liegen aber immer noch nebeneinander und können jederzeit einfach an einen anderen Hub gehängt werden.

Die Hub-Site als Aggregator von Informationen

Auf der anderen Seite können auf einer Hubsite einfach Informationen von allen Sites im Hub aggregiert werden. So ist es zum Beispiel einfach, alle News und Events von allen Sites einzusammeln und gebündelt auf der Startseite eines Hubs darzustellen. Damit eignet sich die Homepage eines Hubs sehr gut als die Startseite eines Intranets, auf der die neuesten Neuigkeiten und Events der einzelnen Sites dargestellt werden.

Fazit

Wichtig zu verstehen ist, dass es einen Unterschied zwischen der Ablagestruktur von Sites und der Navigation hin zu einzelnen Sites gibt. Wenn man das einmal verstanden hat, dann ist die Hub-Site ein ganz entscheidender Baustein eines SharePoint-basierten Intranets.

Quick Tipp: SharePoint List Formatting: Commandbar

Sven Sieverding — Wed, 07 Aug 2024 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2024-08-07/

Hattet ihr auch schonmal das Problem, dass ihr einen der Listenknöpfe, also eines der Kommandos, oberhalb der Liste ausblenden wolltet? Zum Beispiel könnte es sein, dass ihr den "In Rasteransicht bearbeiten" Knopf verstecken wollt, da eure User nur über das Formular die Daten in der Liste bearbeiten sollen. Oder vielleicht wollt ihr den "Neu" Knopf auf eurer Liste nach "Neuer Vorgang" umbenennen, damit eure User genauer wissen, was sie beim Klick auf den Button anlegen. Es gibt viele Dinge, die ihr vielleicht in der Commandbar anpassen wollt. Glücklicherweise ist es nicht wirklich kompliziert, das zu tun.

Listenformatierungen und Verstecken von Kommandos

Das können wir nämlich mittels einer Listenformatierung tun. Diese Formatierung ist im Grunde eine JSON-Datei in einem bestimmten Format, die wir über die Oberfläche an eine SharePoint Ansicht hängen können.

Hierzu erstellen wir zunächst eine "template.json" Datei auf unserem Rechner und füllen Sie mit diesem Inhalt


  "$schema": "https://developer.microsoft.com/json-schemas/sp/v2/row-formatting.schema.json",
  "commandBarProps": {
    "commands": [
      {
        "key": "editInGridView",
        "hide": true
      }
    ]
  }
}

''' Danach öffnen wir unsere Liste, klicken oben rechts auf den Namen der Ansicht und wählen dann "Ansicht formatieren". Jetzt öffnen wir die erweiterte Ansicht und fügen den Inhalt ein und ... Voilà... der Button "In Rasteransicht bearbeiten" ist verschwunden. Das Vorgehen, um einen Button auszublenden ist hier immer dasselbe: Wir brauchen den internen Namen des Bittons und setzen dann für diesen Button "hide" auf "true".

Umbenennen von Kommandos

Über denselben Weg können wir dann auch Buttons umbenennen. Wenn wir zum Beispiel in einer Liste "Materialanforderungen" nachverfolgen, dann würde es sich anbieten, dass die "Bearbeiten" und "Neu" Knöpfe die Labels "Materialanforderunge bearbeiten" und "Neue Materialanforderung" haben. Das können wir wie oben über das folgende Template regeln.

{
  "$schema": "https://developer.microsoft.com/json-schemas/sp/v2/row-formatting.schema.json",
  "commandBarProps": {
    "commands": [
  {
        "key": "edit",
        "text": "Materialanforderung bearbeiten"
      },
      {
        "key": "new",
        "text": "Neue Materialanforderung"
      }
  ]
  }
}

Andere Icons und Primäre Buttons

Schließlich können wir noch zwei weitere Dinge bei den Kommandos anpassen - Wir können das Icon eines Buttons ändern und die Butten in der Primärfarbe der Webseite hinterlegen. Beides

Organizational Assets

Sven Sieverding — Sat, 13 Jul 2024 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2024-07-13/

Jedes Unternehmen hat Vorlagen, sei es Briefvorlagen, PowerPoint Masterfolien, Angebotsvorlagen oder auch Bilder und Videos, die im Intranet benutzt werden dürfen. Diese Vorlagen sind häufig auf Netzlaufwerken gespeichert oder im Intranet abgelegt. Doch wie oft kommt es vor, dass Mitarbeiter die benötigten Vorlagen nicht sofort finden und daher alte oder falsche Vorlagen verwenden? Eine bessere Lösung wäre, wenn die Vorlagen direkt in den Office Programmen wie Word oder PowerPoint verfügbar wären.

Problem

Das Problem ist bekannt: Mitarbeiter finden die Vorlagen nicht sofort und benutzen daher möglicherweise alte Vorlagen weiter. Dies kann zu Inkonsistenzen und ineffizienten Arbeitsabläufen führen. Obwohl es schon lange möglich ist, Vorlagen in Office Programmen zu integrieren, basiert dies häufig auf Netzlaufwerken, die nur per VPN verfügbar sind. Dies erschwert den Zugriff und die Nutzung der Vorlagen erheblich.

Lösung

Die Lösung für dieses Problem sind "Organizational Asset Bibliotheken". Dabei handelt es sich um Dokumentenbibliotheken im SharePoint, in die Vorlagen abgelegt werden können. Diese Vorlagen sind dann direkt in den Office Produkten benutzbar, was den Zugriff und die Nutzung erheblich erleichtert.

Einrichtung

Um Organizational Asset Bibliotheken einzurichten, muss zunächst eine SharePoint Seite definiert werden, auf der die Asset Bibliotheken angelegt werden sollen. Es ist wichtig zu beachten, dass es nicht möglich ist, mehrere SharePoint Seiten mit "Organizational Asset" Bibliotheken zu benutzen. Alle "Organizational Asset" Bibliotheken müssen auf derselben SharePoint Seite sein.

Office Vorlagen

Nachdem eine leere Bibliothek angelegt wurde, muss sich ein Administrator per SharePoint Management Shell anmelden und das folgende Kommando ausführen:

 Add-SPOOrgAssetsLibrary -LibraryUrl <URL> -OrgAssetType  OfficeTemplateLibrary -CdnType Public

Dieses Kommando definiert die angegebene Bibliothek als Vorlagenbibliothek. Nun können PowerPoint Vorlagen (.POTX), Word Vorlagen (.dotx) und Excel Vorlagen (.XLTX) dort abgelegt werden. Diese werden dann in jedem PowerPoint, Word und Excel unter "Neu" und dem Namen der Organisation als Vorlage angeboten.

Bild Vorlagen

Nach Anlage einer leeren Bibliothek und nachdem ein Administrator per SharePoint Management Shell das folgende Kommando ausgeführt hat:

  Add-SPOOrgAssetsLibrary -LibraryUrl <URL> -OrgAssetType  ImageDocumentLibrary -CdnType Public

stehen auch alle Bilder in der Bibliothek allen Redakteuren im Intranet im Dateiauswahldialog für Bilder zur Verfügung.

Vorteile der Organizational Asset Bibliotheken

Die Verwendung von Organizational Asset Bibliotheken bietet zahlreiche Vorteile:

Zentralisierte Verwaltung: Alle Vorlagen sind an einem zentralen Ort gespeichert und können leicht aktualisiert und verwaltet werden.
Einfacher Zugriff: Mitarbeiter können direkt aus den Office Programmen auf die Vorlagen zugreifen, ohne sich durch Netzlaufwerke oder VPN-Verbindungen kämpfen zu müssen.
Konsistenz: Durch die zentrale Verwaltung und den einfachen Zugriff wird sichergestellt, dass immer die aktuellsten Vorlagen verwendet werden, was zu konsistenteren und professionelleren Dokumenten führt.
Effizienz: Die Zeit, die Mitarbeiter mit der Suche nach Vorlagen verbringen, wird erheblich reduziert, was zu effizienteren Arbeitsabläufen führt.

Fazit

Organizational Asset Bibliotheken sind eine hervorragende Lösung für Unternehmen, die ihre Vorlagenverwaltung optimieren möchten. Die Einrichtung ist zwar mit einigen administrativen Schritten verbunden, diese sind aber im Vergleich mit anderen Lösungen nicht so komplex und die Vorteile überwiegen bei weitem die anfänglichen Aufwände. Nutze die Möglichkeiten von SharePoint und Microsoft 365, um deine Vorlagenverwaltung auf das nächste Level zu heben!

Sprachwirrwarr.... "Site" vs "Seite"

Sven Sieverding — Mon, 10 Jun 2024 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2024-06-10/

Ich denke, wir haben in den 1990ern kollektiv etwas falsch gemacht. Wer damals auf die Idee gekommen ist, den englischen Ausdruck "Web site" mit dem deuschten Ausdruck "Webseite" zu übersetzten hat nicht bedacht, dass die beiden Ausdrücke zwar ähnlich klingen, aber komplett andere Assoziationen wecken.

Das sehe ich viel, wenn ich mir die Oberfläche etwa eines modernen SharePoints ansehe. In meiner Erfahrung werden nicht-IT-affine Benutzer häufig von (Fehl-)Übersetzungen irritiert

Site

Das Problem ist nämlich, dass man den englischen Ausdruck "Site" nicht mit "Seite" übersetzen sollte, sondern eher mit "Bereich" oder "Ding, in dem andere Dinge enthalten sein können". Zum Beispiel ist eine "Construction Site" keine "Konstruktionsseite" oder sowas ähnliches, sondern ein Bereich oder Areal, in dem gebaut wird.... Also eine "Baustelle".

Andere Ausdrücke wie etwa "On site" oder "Off site" meinen schließlich auch nicht "Auf der Seite" oder "Außerhalb der Seite", sondern "Im Bereich" und "außerhalb des Bereichs". Im Geschäftskontext meint man damit häufig "im Büro" und "nicht im Büro"

Page

Auf der anderen "Seite" gibt es da die "Page". Wenn wir das übersetzen, entspricht das eher der Seite in einem Buch, auf der wir Buchstaben finden und lesen können. Das ist aber eigentlich nicht gemeint, wenn wir von einer "Website" sprechen. Ich tendiere dazu, diese Seiten als "Inhaltsseiten" zu bezeichnen.

Website

Klassischerweise ist eine "Website" nämlich mehr als nur der Text, der aktuell dargestellt wird. Technisch ist es im Regelfall wenigstens ein "Ordner", in dem wir mehrere Dateien abspeichern können. Das sind im Regelfall HTML Dateien, aber auch Bilder, Styles, Scripte und ähnliches. Es ist halt ein "Bereich", in dem wir die ganzen Elemente speichern, die wir darstellen wollen.

Homepage

Somit kann es in einer "Website" mehrere Inhaltseiten geben, auf die ich vielleicht per Link zugreifen kann. Eine besondere Inhaltsseite ist hier aber die "Homepage". Das ist die Inhaltsseite, die als Standart aufgerufen wird und von der ich aus alle anderen Inhalte in der Site erreichen kann. Sozusagen das "Gesicht" unserer Website.

Wenn nun Leute aber von Hompages reden, meinen Sie aber häufig nicht so eine "Hauptseite" einer Website, sondern eher eine Website, die einer einzelnen Person oder Firma zugeordnet ist. Zum Beispiel würden viele Leute sagen, dass diese Website, auf der sich dieser Text befindet, meine Homepage ist ....Eigentlich wieder eine falsche Assoziation.

Und nun?

Naja, das Kind ist in den Brunnen gefallen und wir können kurzfristig nichts an dem Problem machen.

Ich persönlich habe mich dazu entschlossen, mich sprachlich klarer auszudrücken. Daher benutze ich eigentlch nur noch diese Ausdrücke im Deutsche.

Webbereich für eine "Website"
Inhaltsseite für eine "Page"
Startseite für eine "Homepage"
Homepage garnicht

Vortrag bei den Magdeburger Dev Days: Going Serverless mit Azure

Sven Sieverding — Sat, 11 May 2024 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2024-05-11/

Bei den Magdeburger Dev Days in Magdeburg eine der größten Community Entwickler Konferenzen in Deutschland ist eine Veranstaltungsreihe, bei der sich die Webschaffenden des Bremer Umfelds in locker Atmosphere treffen, austauschen und voneinander lernen können.

Am 14.05.2023 habe ich hier einen Vortrag zum Thema "Going Serverless mit Azure" gehalten.

Bei Azure denken viele direkt an riesige Rechenzentren und "Infrastructure as a Service". Was bringt Azure mir aber als Entwickler und was für einen Einfluss kann das auf meine Architektur haben? Ich erkläre euch am Beispiel einer recht simplen Anwendung, wie man Bausteine Stück für Stück durch Azure Komponenten ersetzten kann.... bis die Applikation komplett "serverless" ist.

This browser does not support PDFs. Please download the PDF to view it: Download PDF.

Microsoft Most valued Professional

Sven Sieverding — Tue, 16 Jan 2024 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2024-01-16/

Heute habe ich ein Nominierungsschreiben erhalten, in welchem Microsoft mich zum MVP (Most Valued Professional) auszeichnet

https://mvp.microsoft.com/de-DE/MVP/profile/a063f8c2-5844-4d0b-a0fb-7bfadc715f2c

Dankeschön :) #SharingIsCaring #communityrocks

Vortrag bei den Collabdays Belgium: SPFX Forms and React Formik: Easily create custom SharePoint list forms

Sven Sieverding — Mon, 11 Sep 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-09-11/

Ich bin in diesem Jahr bei den Collabdays Belgium als Speaker mit dabei.

Ich spreche über SPFx FormCustomizer und React Formik.

Die Folien werde ich später hier veröffentlichen, bis dahin könnt ihr könnt euch in diesen beiden Artikeln über den Inhalt informieren

Was genau bedeutet "Low Code"?

Sven Sieverding — Wed, 06 Sep 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-09-06/

Wikipedia definiert "Low Code" bzw. "Low-Code-Plattform" als

Der Begriff Low-Code-Plattform (auch Low-Code-Entwicklungsplattform) bezeichnet eine Entwicklungsumgebung für Software, die die Entwicklung mit visuellen Applikationsdesign-Werkzeugen und anderen grafischen Modellierungsverfahren ermöglicht, anstatt klassische textbasierte Programmiersprachen zu verwenden. Dadurch soll die Entwicklungs- und Bereitstellungszeit für Software verringert werden. Low-Code-Plattformen sollen außerdem die Kosten für Projektplanung, Mitarbeitertraining und die eigentliche Entwicklung senken.

Dem stimme ich generell zu und nehme für mich daraus die folgenden Stichworte mit:

Grafische Modellierung statt textbasierter Programmiersprachen
Minimierung von Entwicklungszeit
Minimierung von Bereitstellungszeit

Anhand dieser Stichworte versuche ich im Folgenden in Applikationen in 4 generelle "Low Code" Kategorien einzuteilen.

Ich denke, dass das wichtig ist, da viele Leute teilweise nur von einer der Kategorien sprechen, wenn sie "Low Code" sagen. Falls in dieser Kategorie dann "Low Code" nur oberflächlich eingesetzt wird, kann das bei manchen ein verzerrtes Bild von der "Low Code" Idee hinterlassen.

1) Grafische Entwicklertools

Das sind häufig Frameworks, die ich in mein eigenes Projekt integrieren kann und mit dem ich dann grafisch Workflows in meiner Applikation modellieren kann. Der Rest meiner Applikation ist aber klassisch entwickelt und wird damit auch klassisch bereitgestellt. Das bedeutet, dass der Workflow zwar von mir als Entwickler mit Low-Code Mitteln erstellt, er danach aber gebündelt zusammen mit Code Änderungen in einem klassischen Deployment verteilt wird. Die Bereitstellungszeit zwischen zwei Deployments ändert sich hier nicht (Abgesehen von einer vielleicht kleineren Entwicklungszeit).

Die beiden Vorteile von diesem Vorgehen sind klar. Das Workflow-Framework nimmt mir als Entwickler in dem Workflow-Umfeld viele wiederkehrende Schritte ab, die ich einfach grafisch modellieren kann. Damit spare ich Zeit. Der Workflow ist aber auch gleichzeitig übersichtlicher und ich kann mir mit meinem Kunden zusammen den Workflow grafisch ansehen und schnell ändern.

2) Grafisch konfigurierbare Systeme

Auf der anderen Seite gibt es viele Applikationen, die ich in einem festgelegten Rahmen fast von Grund auf neu konfigurieren kann. Ein gutes Beispiel dafür aus dem Microsoft Umfeld ist SharePoint. Ich kann leicht über die Oberfläche meine eigenen Listen, Datenstrukturen und Ansichten auf diesen konfigurieren. Es gibt teilweise sogar Automatismen, mit denen ich bestimmte Prozesse und Freigaben zwischen den Elementen definieren kann. Neben SharePoint sprießen aber auch schon seit ein paar Jahren mehrere andere Lösungen dieser Art aus dem Boden. Häufig stehen hier Projektmanagement- und Abrechnungsprozesse im Vordergrund.

Ich als Entwickler installiere hier nicht die Plattform und entwickele darauf meine Applikation, sondern benutze eine schon bestehende Plattform, die ich dann so anpasse, wie mein Anwendungsfall es verlangt. Ich mir daher viel Zeit und Aufwand, den ich vorher in Dinge wie Datenspeicherung, Berechtigungssysteme oder Oberflächengestaltung hätte stecken müssen.

Ein Nachteil bei diesen Systemen ist häufig die Transportierbarkeit. Ich kann zwar mir zwar "eben mal kurz" eine Applikation "zusammenklicken" aber was passiert, wenn die Applikation schon genutzt wird? Muss ich dann Anpassungen direkt im Produktivsystem machen oder kann ich ein Testsystem erstellen, dort zuerst Änderungen testen und dann gezielt diese Änderungen deployen? Kann ich meine Anpassungen überhaupt automatisch in eine andere Applikation kopieren?

Bei vielen dieser Systeme gibt es zu diesen Fragen keine Antworten. Häufig stand bei der Entwicklung und dem Design dieser Plattformen nämlich etwas anderes im Vordergrund und die Idee von Konfigurierbarkeit und Low-Code war eher ein Nachgedanke.

Diese Art von Plattformen ist auch nichts neues. SharePoint gibt es schon lange und es entstehen im Internet immer mehr Dienste dieser Art. Wenn man die Definition hier etwas weiter fassen möchte, dann kann hierzu durchaus auch durchaus Atlassians Jira und andere zählen.

3) Automatisierungslösungen

Dann gibt es noch Automatisierungslösungen. Diese gibt es zwar schon lange, aber mit dem Aufkommen der Heimautomatisierung ist ihre Anzahl nochmal rasant gestiegen. Hierbei handelt es sich um einfache Logik-Prozesse, die von einem externen System ausgelöst werden und abhängig von definierten Bedingungen in einem anderen System Aktionen auslösen. Ein einfaches Beispiel aus dem Consumer Bereich ist hier IFTT (If-This-Then-That). Ich als Consumer kann hier dem Service meine digitalen Dienste freischalten und diese kann dann für mich dort Aktionen ausführen. Etwa könnte ich mir bei Eingang eines neuen Kalendereintrages automatisch eine Chat-Nachricht schreiben lassen oder ähnliches.

Im Regelfall können diese Plattformen von Haus aus schon mit vielen anderen Systemen Kontakt aufnehmen. Sie geben mir eine einfache grafische Möglichkeit, um Automatisierungen und Prozesse zu erstellen.

Das Problem ist hier aber wie bei den grafisch konfigurierbare Systemen aus dem vorherigen Abschnitt die Transportierbarkeit. Selbst wenn ich auf diesen Plattformen meinen Workflow exportieren und in eine andere Instanz einspielen kann (was nicht immer möglich ist), dann habe ich als Entwickler immer noch das Problem, dass ich Änderungen an den anderen Systemen hiermit nicht transportieren kann.

Wenn ich also eine Änderung an einer "Datenbank" irgendwo habe und zusätzlich eine Änderung an diesem Workflow, dann muss ich als Entwickler beides einzeln im Rahmen eines Changes auf die entsprechenden Produktivsysteme einspielen. Das kann zu mehreren möglichen Fehlerquellen führen und macht eine Entwicklung von komplexen Applikationen hier schwierig.

Bei diesen Lösungen steht die einfache und schnelle Automatisierung von Teil-Prozessen im Vordergrund, nicht die ganzheitliche Entwicklung von Applikationen.

Beispiele für solche Automatisierungsplattformen sind wie schon oben erwähnt IFTT, aber auch Nintex Workflow. Wenn wir die Definition hier etwas ausweiten, dann fallen auch diverse "ETL" Tools in diesem Bereich

4) Komplette Low Code Plattformen

Mit der bisherigen Vorarbeit kommen wir nun zu kompletten Low Code Plattformen. Man kann Sie als Weiterentwicklung der grafisch konfigurierbaren Systeme sehen, die auf der einen Seite schon von Grund auf dafür gedacht und konzipiert sind, um komplette Anwendungsfälle schnell per Low Code grafisch umzusetzen. Auf der anderen Seite sind sie aber auch so erstellt, dass auch das Deployment und das Verteilen der erstellten Applikationen einfach, schnell und zuverlässlich durchgeführt werden kann. Und das im Idealfall auch noch grafisch.

Diese Plattformen bestehen im Regelfall aus wenigstens vier ineinandergreifenden Komponenten:

Einer Komponente zur Datenspeicherung, in der ich einfach Datenstrukturen anlegen kann
Einer Komponente zur Erstellung von Prozessen, mit der ich einfach auf den Daten Prozesse definieren kann
Einer Komponente zur Erstellung von Oberflächen, die es mir möglich machen, mittels Formularen die Daten zu bearbeiten.
Ein Mechanismus, der die Konfiguration der oberen drei Mechanismen portabel in eine Lösung exportieren kann, die ich als Entwickler ohne viel Aufwand einfach auf einem anderen System einspielen kann. Im Idealfall lässt sich dieser Mechanismus sogar noch automatisieren.

Der Unterschied zu den anderen Kategorien besteht hier darin, dass die Idee der schnellen grafische Entwicklung von Applikationen bei der Erstellung der Plattform im Vordergrund gestanden hat, und daher alle Mechanismen ineinander greifen. Damit können mit so einer Plattform komplizierte Applikationen entwickelt werden, die aber auch professionell betrieben und weiterentwickelt werden können.

Als Beispiele für solche Plattformen kann man "Lotus Notes" heranziehen und auch die PowerPlattform von Microsoft. Letztere besteht aus verschiedenen Komponenten, wie etwa

Dataverse zur Datenspeicherung in Tabellen.
Power Automate zur Erzeugung von Prozessen und
Power Apps zur Erstellung von Oberflächen

und stellt zusätzlich mit "Solutions" einen einfachen und effektiven Transportmechanismus zur Verfügung.

Per PowerAutomate eine Mail an eine SharePoint Gruppe senden

Sven Sieverding — Thu, 31 Aug 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-08-31/

Benutzt dazu einfach die "Send an HTTP Request to SharePoint" Aktion und den REST-API Endpunkt "/_api/SP.Utilities.Utility.SendEmail"

In diesem Beispiel schicke ich damit eine Email an alle Mitglieder der SharePoint Gruppe "SharePoint Group"

{
    'properties': {
      'To':['SharePoint Group'],
        'Body': '<h1>Hello Group</h1>',
        'Subject': 'Hello Group'
    }
}

Vortrag: Going Serverless mit Azure

Sven Sieverding — Mon, 21 Aug 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-08-21/

Der Webmontag in Bremen ist eine Veranstaltungsreihe, bei der sich die Webschaffenden des Bremer Umfelds in locker Atmosphere treffen, austauschen und voneinander lernen können.

Am 21.08.2023 habe ich hier einen Vortrag zum Thema "Going Serverless mit Azure" gehalten.

Bei Azure denken viele direkt an riesige Rechenzentren und "Infrastructure as a Service". Was bringt Azure mir aber als Entwickler und was für einen Einfluss kann das auf meine Architektur haben? Ich erkläre euch am Beispiel einer recht simplen Anwendung, wie man Bausteine Stück für Stück durch Azure Komponenten ersetzten kann.... bis die Applikation komplett "serverless" ist.

This browser does not support PDFs. Please download the PDF to view it: Download PDF.

Welchen Seitentyp wann?

Sven Sieverding — Wed, 26 Jul 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-07-26/

Neulich wurde mir die Frage gestellt, warum es in SharePoint denn zwei Seitentypen gibt.

Beim Erstellen einer neuen Seite haben wir die Auswahl zwischen den beiden Seitentypen Teamseite und Kommunikationswebseite. Die beiden Seiten unterscheiden sich auf den ersten Blick nur darin, dass bei der einen die Navigation auf der linken Seite ist und bei der anderen auf der oberen. Auf den zweiten Blick scheint es dann so zu sein, dass ich mit einer Teamseite inhaltlich alles machen könnte, was ich auch mit einer Kommunikationswebseite machen kann.

Also, warum und wofür brauche ich dann diese beiden Seitentypen?

Eine Teamseite ist dafür gedacht, dass du darin mit anderen zusammenarbeiten kannst. Anders ausgedrückt erstellen alle Mitglieder der Site gemeinsam Content und haben dabei mehr oder weniger dieselben Rechte. Du kannst auch recht einfach Dateien mit externen Benutzern teilen. Um die Zusammenarbeit über das Teilen von Dateien hinaus noch einfacher zu machen, wird dir bei Erstellung einer Teamseite automatisch eine M365 Gruppe und ein Teampostfach im Exchange erstellt.

Den Content auf einer Kommunikationswebseite sollte für eine größere Gruppe von Usern, wenn nicht sogar die gesamte Organisation relevant und sichtbar sein. Hier erstellt eine kleinere Gruppe von Autoren Content und eine große Anzahl von Personen konsumiert ihn. Wenn du eine Kommunikationswebseite erstellst, dann bekommst du auch nur diese Site, sonst nicht (also bekommst du keine O365 Gruppe)

In Bezug auf verfügbare Funktionen und Webparts sind auf der Teamseite mehr Webparts verfügbar. Das vor allen Dingen daran, dass wir bei einer Teamseite eine M365 Gruppe zur Verfügung steht. Daher machen manche dieser Webparts auch nur hier Sinn.

Die folgenden Webparts sind nur auf einer Teamseite, aber nicht auf einer Kommunikationswebseite verfügbar

Asana
Bitbucket (and Bitbucket Server)
GitHub (and GitHub Enterprise)
Google Analytics
Incoming Webhook
JIRA
Office 365 Connectors
Planner
RSS
Salesforce
Stack Overflow
Trello
UserVoice

Falls Du aber ein Intranet bauen und etwa Features wie eine Homesite nutzen willst, dann muss diese Seite eine Kommunikationswebseite sein.

Das bedeutet nun alles das Folgende:

Wenn du jetzt also deinen Fokus nur auf eine einzelne Seite legst, dann hat eine Teamseite mehr Features als eine Kommunikationswebseite. In dem Sinne bräuchtest du nie Kommunikationswebseiten.

Aber:

Teamseiten sind stark für die direkte Zusammenarbeit angepasst und kommen, wie oben schon erwähnt, fest verwoben mit einer M365 Gruppe und anderen Einstellungen. Diese machen eine Teamseite aber schwieriger zu nutzen, wenn du beispielsweise ein Intranet aufbauen möchtest, das aus potenziell hunderten von Seiten besteht. Dann müsstest du nämlich entweder all diese M365 Gruppen mit häufig denselben Berechtigungen synchron halten oder du würdest die Gruppen zugunsten einer anderen Berechtigungslösung gar nicht benutzen. In dem Fall sind die Gruppen nicht nützlich und in der Übersicht sogar eher hinderlich.

Bei einer Kommunikationsseite würdest du einfach eine neue Active Directory Gruppe erstellen und die in den "Besucher" Gruppen auf jeder neuen Intranet Seite hinzufügen. Das ist von der Verwaltung her wesentlich einfacher.

Wenn du nun also statt auf eine einzelne Seite deinen Fokus auf deinen gesamten Tenant legst, dann nehmen Kommunikationswebseiten weniger Ressourcen in Anspruch und sind einfacher zu handhaben.

Insbesondere wenn ich zu einem gegebenen Anwendungsfall keine Zusammenarbeitsfeatures benötige, wähle ich daher meistens eine Kommunikationswebseite statt einer Teamseite.

Microsoft Forms, mehrere Antworten und SharePoint

Sven Sieverding — Wed, 26 Jul 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-08-13/

Ich kann recht einfach einen PowerAutomate Workflow definieren, der startet, wenn es in einem MS Forms Formular einen neuen Eintrag gegeben hat und der dann einen neuen Eintrag in einer SharePoint Liste erstellt.

Dafür brauche ich drei Aktionen:

"Bei Übermitteln einer neuen Antwort"
"Antwortdetails abrufen". Hier setzte ich die "Antwort-ID" auf die "Antwort-ID" aus dem vorherigen Schritt.
"Element erstellen". Hier erstelle ich ein neues Element in einer SharePoint Liste und trage die Daten aus dem vorherigen Schritt ein.

So weit so gut, aber wenn ich das Feld "Multiquestion" eine Mehrfachauswahl ist, dann sieht das Ergebnis so aus.

Der Wert im Mehrfachauswahl-Feld wird nämlich im JSON-Format zurückgegeben. Den müssen wir parsen und umformatieren.

["Option 1","Option 2","Option 4"]

Dazu fügen wir zunächst eine "JSON analysieren" Aktion mit ein. In das Feld "Inhalt" fügen wir den Multichoice-Wert aus dem Formular und das folgende Schema in das "Schema"-Feld ein.

{
    "type": "array",
    "items": {
        "type": "string"
    }
}

Damit haben wir dann alle gegebenen Antworten aus dem JSON-Format ausgelesen. Sie stehen uns nun in einem Array zur Verfügung. Dieses Array wollen wir aber umformatieren und alle Elemente in einem Textfeld als eigene Zeilen darstellen.

Dazu benutzen wir nun eine "Verknüpfung" / "Beitreten" Aktion (im Englischen "Join") und fügen in das "Von"-Feld den "Text" aus der vorherigen Aktion ein.

In das "Verknüpfen mit" Feld können wir theoretisch nun jedes Zeichen einfügen. Alle Werte der Mehrfachauswahl werden mit diesem Zeichen als Trennzeichen zusammengefügt.

Wir wollen aber einen Zeilenumbruch haben. Da das ein Sonderzeichen ist, müssen wir den Zeilenumbruch mittels der folgenden Formel darstellen.

decodeUriComponent('%0A')

Damit sieht die Aktion dann so aus

Die Ausgabe dieses Feldes fügen wir nun in der "Element erstellen" Aktion in das Textfeld für "MyChoiceField" mit ein. Das ergibt dann insgesamt diesen Flow

Wenn nun ein neuer Eintrag in das Formular geschieht, dann wird in der SharePoint Liste der Wert entsprechend formatiert eingetragen.

Quick Tipp: Einfach eine publizierte News wieder demoten

Sven Sieverding — Wed, 19 Jul 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-07-19/

Eine Neuigkeit im modernen SharePoint zu publizieren ist einfach. Ein Klick auf den "Höher stufen" (oder im Englischen "Promote") Knopf und schon ist die aktuelle Seite als Neuigkeit geteilt.

Wie macht man das aber wieder rückgängig? Im Standard über die Oberfläche geht das erst mal nicht.

Sehen wir uns einmal die Websiteseiten-Bibliothek genauer an. Hier können wir eine versteckte Spalte "Promoted State" finden. Sie kann ganze Zahlen von 1 bis 3 enthalten, wobei

1 für eine normale Seite,
2 für eine unpublizierte Neuigkeit und
3 für eine publizierte Neuigkeit

steht. Wir müssen also zum "Runterstufen" einer News zu einer "normalen Seite" nur den Wert in dieser Spalte auf "1" anpassen.

Leider haben wir über die Oberfläche keine Möglichkeit, dies zu tun. Es gibt vielfältige Lösungen, um diesen Wert umzusetzen, die aber im Regelfall Powershell, PowerAutomate oder andere Tools benötigen.

Mittels einer eigenen Formatierung auf der Spalte können wir diese Funktionalität aber einfach selber der Oberfläche hinzufügen.

Öffnen Sie die Ansicht aller Webseiten in Ihrer Websiteseiten-Bibliothek und blenden Sie die Spalte "Promoted State", indem Sie "Add column"->"Show or hide columns" auswählen und die Spalte sichtbar machen.
Klicken Sie dann auf den kleinen Pfeil nach unten neben der Überschrift der Spalte und wählen Sie "Column Settings"->"Format this column".
Wechseln Sie in den "Advanced Mode" und fügen Sie das folgende JSON ein:

{
    "elmType": "div",
    "children": [
        {
            "elmType": "button",
            "style": {
                "display": "=if([$PromotedState] == 1 , 'inherit','none')",
                "background-color": "transparent",
                "cursor": "pointer",
                "border": "none"
            },
            "attributes": {
                "class": "ms-fontColor-themePrimary ms-fontColor-themeDarker--hover"
            },
            "customRowAction": {
                "action": "setValue",
                "actionInput": {
                    "PromotedState": "0"
                }
            },
            "children": [
                {
                    "elmType": "span",
                    "attributes": {
                        "iconName": "SortDown"
                    },
                    "style": {
                        "padding": "4px"
                    }
                },
                {
                    "elmType": "span",
                    "txtContent": "Demote to site page"
                }
            ]
        },
        {
            "elmType": "button",
            "style": {
                "display": "=if([$PromotedState] == 2 , 'inherit','none')",
                "background-color": "transparent",
                "cursor": "pointer",
                "border": "none"
            },
            "attributes": {
                "class": "ms-fontColor-themePrimary ms-fontColor-themeDarker--hover"
            },
            "customRowAction": {
                "action": "setValue",
                "actionInput": {
                    "PromotedState": "1"
                }
            },
            "children": [
                {
                    "elmType": "span",
                    "attributes": {
                        "iconName": "SortDown"
                    },
                    "style": {
                        "padding": "4px"
                    }
                },
                {
                    "elmType": "span",
                    "txtContent": "Demote to unpublished news"
                }
            ]
        }
    ]
}

Nun können Sie jede publizierte News wieder zu einer unpublizierten News zurückstufen ("Demote to unpublished news") oder letztere wieder zu einer "normalen" Websiteseite zurückstufen ("Demote to site page")

SharePoint Formulare mit React Formik 1/2

Sven Sieverding — Sun, 02 Jul 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-07-02/

Das ist ein zweiteiliges Tutorial. In diesem Teil beschreibe ich, wie man generell einen Form-Customizer aufsetzen kann und wie man ein sehr einfaches Formular erstellt. Im zweiten Teil erkläre ich, wie man auch komplizierte Formulare mittels dieser Technologie und mittels React Formik umsetzen kann.

SharePoint und Formulare

Ein häufiger Anpassungwunsch an SharePoint ist die Anpassung der Standard-Listenformulare. Normalerweise kommt man hier mit dem Standard-Listenformatting schon zu beeindruckenden Formularen, aber das stößt auch manchmal an seine Grenzen.

Dann hatte ich bisher nur die Möglichkeit, dieses Formular per PowerApps zu customizen. Das geht sehr gut und einfach - hat aber ein paar Nachteile. Zum einen kann ich das Formular nicht so einfach transportieren und an eine andere Liste mit denselben Feldern hängen. Das macht ein Szenario mit einem Test- und einem Produktivsystem schwierig, ganz zu schweigen von dem Fall, dass ich mehrere hundert gleiche Listen habe, die die gleichen Formulare haben sollen.

Mit der Version 1.15 vom SharePoint Framework können wir nun "Form Customizer" erstellen und Formulare in Javascript entwickeln.

Erstellen einer Liste

Erstmal brauchen wir eine Liste, auf der wir den Form-Customizer entwickeln wollen Erstellt zunächst auf einer beliebigen SharePoint Site die Liste "FormCustomizer". Für diesen Teil des Tutorials braucht sie keine weiteren Spalten, wir fügen aber im nächsten Teil neue Spalten mit hinzu. Legt dort aber ein Element an.

Ich nehme im folgenden an, dass eine solche Liste unter der URL "https://.sharepoint.com/sites//Lists/FormCustomizer/" vorhanden ist.

Erstellen eines Form-Customizers

Öffnet zuerst eine Powershell und führt die folgenden Befehle aus, um ein leeres SharePoint Framework Projekt zu erstellen.


md react-formix-form-customizer
cd react-formix-form-customizer

npx -p yo -p @microsoft/generator-sharepoint yo @microsoft/sharepoint
# oder falls ihr @microsoft/sharepoint-spfx und yeoman lokal installiert habt
# yo @microsoft/sharepoint

Beantwortet die nun folgenden Fragen so:

What is your solution name?: react-formix-form-customizer
Which type of client-side component to create?: Form Customizer
Which type of client-side extension to create? Formix Form Customizer
What is your Form Customizer name? FormixCustomizer
Which template would you like to use?: React

Führt danach noch das hier aus, um zusätzliche Bibliotheken zu installieren, die wir noch brauchen werden


npm install @pnp/sp --save

Nachdem der Installationsprozess abgeschlossen ist, müssen wir noch zwei Einstellungen machen, damit die die Erweiterung testen können.

Öffnet zuerst die Datei config/serve.json und passt dort alle "serveConfigurations" an. Ersetzt dort alle vier Einträge von "https://{tenantDomain}" durch "https://.sharepoint.com/sites/" und vier Einträge von "/sites/mySite/Lists/MyList" durch "/sites//Lists/FormCustomizer"

// in serve.json
//...
   {
     "formixCustomizer_EditForm": {
      "pageUrl": "https://<tenant>.sharepoint.com/sites/MyAppPage/_layouts/15/SPListForm.aspx",
      "formCustomizer": {
        "componentId": "431c36f6-3901-469f-8af2-3077d6cd39e7",
        "PageType": 8,
        "RootFolder": "/sites/<MeineSeite>/Lists/FormCustomizer",
        "ID": 1,
        "properties": {
          "sampleText": "Value"
        }
      }
    }
}
//...

Das sind die verschiedenen Konfigurationen unserer Test-Einstellungen für die "New", "Edit" und "Display" Varianten unseres Formulars. In dem Property "ID" gebe ich an, welches ListenElement ich konkret in meinem Formular laden möchte. Unsere Liste hat nur ein Element, deswegen wähle ich hier die "1".

Ihr könnt hier aber auch die Adressen von einer existierenden Liste einpflegen und das Formular sogar gegen eine "produktive" Liste entwickeln. Ändert dafür einfach die Listen-Url und die ID des zu bearbeitenden Dokumentes.

Danach füge ich gerne noch in der package.json Datei neue Scripte hinzu, über die ich den SPFx Development server einfach starten kann

// in serve.json
//...
{
  "scripts": {
    "serve:newform": "gulp serve --config=formixCustomizer_NewForm",
    "serve:editform": "gulp serve --config=formixCustomizer_EditForm",
    "serve:viewform": "gulp serve --config=formixCustomizer_NewForm"
  },
}  
//...

Nun kann ich das Projekt als "NewForm" schnell mittels des folgenden Kommandos starten

npm run serve:newform

Mein Browser öffnet sich, ich bestätige einmal das Popup zum akzeptieren der Debug Skripte und dann ich sehe den konfigurieren Form-Customizer.

Ihr könnt euch den generierten Code für dieses Beispiel hier ansehen und herunterladen.

Anpassen des Customizers

Beziehungsweise genaugenommen sehe ich nun nichts, nur einen leeren Bildschirm. Das liegt daran, dass der Form-Customizer im Moment noch nicht mehr kann. Sehen wir uns mal den Code an.

In der Datei "src\extensions\formixCustomizer" finden wir die Haupteinstiegspunkt des Projektes in der Datei FormixCustomizerFormCustomizer.ts.

Das Laden und Speichern der Formulardaten finden wir nicht. Das liegt daran, dass wir diese Funktionalitäten selber entwickeln und dem Form-Customizer hinzufügen müssen. Dafür haben wir in einem oberen Schritt schonmal die PnPjs Bibliothek installiert und müssen Sie nun konfigurieren.

Zunächst öffnen wir die Datei FormixCustomizerFormCustomizer.ts fügen den Import der nötigen Bibliotheken mit hinzu


import { spfi, SPFI, SPFx } from "@pnp/sp";
import "@pnp/sp/webs";
import "@pnp/sp/lists";
import "@pnp/sp/items";

Danach fügen wir in der Klasse "FormixCustomizerFormCustomizer" oben zwei neue Klassenvariablen mit hinzu. Die eine ist die Instanz für die PnPjs Bibliothek und die andere ist das Listenitem, welches wir geladen haben.


   private _spfi: SPFI;
   private _item: any={};

Nun passen wir die "onInit" Methode an. Diese wird beim Start des Customizers ausgeführt. In ihr initiieren wir nun das PnPjs Objekt und laden danach direkt das Listenelement. Letzteres machen wir aber nur, wenn wir eine ListenID haben und damit auf einem Display- oder Edit-Formular sind. Auf einem "New" Formular haben wir offensichtlich kein Element, welches wir beim Start laden müssen.


    public onInit(): Promise<void> {
    // Setup PnPjs
    this._spfi = spfi().using(SPFx( this.context ));

    if (this.context.itemId!==undefined){
      // itemId is set on an Edit and Displayform
      // if it is set load data from SharePoint
      return this._spfi
      .web
      .lists
      .getById(this.context.list.guid.toString())
      .items
      .getById(this.context.itemId)()
      .then((item:any)=>{ 
        // The following fields need to be removed from the item, if we want to save the object again
        delete item["odata.editLink"];
        delete item["odata.etag"];
        delete item["odata.id"];
        delete item["odata.metadata"];
        delete item["odata.type"];     
        delete item.odata;
        this._item=item;
        console.log(item);
      })
    }  
    
    return Promise.resolve();
  }

Aus dem geladenen Objekt entfernen wir ein paar Eigenschaften wie etwa "odata.editLink". Diese Eigenschaften würden sonst stören, wenn wir dasselbe Objekt wieder speichern werden.

Jetzt passen wir noch die "_onSave" Methode an. Zum einen ändern wir die Signatur, so dass wir der Methode ein Objekt übergeben können, welches wir speichern wollen. Zum anderen prüfen wir nun, ob wir auf dem "Edit" oder "New" Formular sind und rufen danach die relevanten Methoden aus dem "PnPjs" Framework auf. Wichtig ist hierbei, dass nach dem erfolgreichen Speichern immer die Methode "this.formSaved()" aufgerufen wird. Diese sorgt dafür, dass sich das Formular beendet.


    private _onSave = (item:any): void => {

    // If we are in Edit Mode: Update the existing item
    if (this.displayMode === FormDisplayMode.Edit  && this.context.itemId!==undefined) {
      this._spfi
      .web
      .lists
      .getById(this.context.list.guid.toString())
      .items
      .getById(this.context.itemId)
      .update(item)
      .then(()=>{
        this.formSaved();
      })
    };

     // If we are in New Mode: Create a new Item
    if (this.displayMode === FormDisplayMode.New) {
      this._spfi
      .web
      .lists
      .getById(this.context.list.guid.toString())
      .items
      .add(item)
      .then(()=>{
        this.formSaved();
      })
    }   
  }

Schließlich passen wir noch die "render()" Methode an und übergeben dem neu erstellten React Element zusätzlich noch das geladene Item als Parameter mit


   public render(): void {
    const formixCustomizer: React.ReactElement<{}> =
      React.createElement(FormixCustomizer, {
        item:this._item, // <-NEW
        context: this.context,
        displayMode: this.displayMode,
        onSave: this._onSave,
        onClose: this._onClose
       } as IFormixCustomizerProps);

    ReactDOM.render(formixCustomizer, this.domElement);
  }

Damit haben wir alle notwendigen Änderungen an der Datei FormixCustomizerFormCustomizer.ts durchgeführt. Ihr werden in eurer IDE aber wahrscheinlich noch Fehler haben.

Das liegt neben ein paar weiteren Anpassungen am Code noch daran, dass euer Typescript-Compiler sich über ein paar benutze "any" Ausdrücke und nicht abgefangene Promises beschwert. Denkt daran, dass das hier nur ein Tutorial ist und ich die entsprechende Behandlung dieser not-so-best Practices der Einfachheit halber hier nicht durchführe.

Um die Warnungen zu entfernen, öffne ich die ".eslintrc.js" Datei und setze die Werte für die beiden Checks auf 0. Macht das aber nicht so in einem echten Projekt.

...
  '@typescript-eslint/no-explicit-any': 0,
  '@typescript-eslint/no-floating-promises': 0,
...

Auf der anderen Seite müssen wir noch in der Datei components/FormixCustomizer.tsx das Interface "IFormixCustomizerProps" so anpassen, dass wir das geladene Item mit an die React-Komponente übergeben können.

Öffnet nun die Datei components/FormixCustomizer.tsx ..... Und löscht allen Inhalt aus ihr. Wir erstellen sie von Grund auf neu.

Fügt zuerst neue Importe hinzu:

import * as React from 'react';
import { FormDisplayMode } from '@microsoft/sp-core-library';
import { FormCustomizerContext } from '@microsoft/sp-listview-extensibility';
import { PrimaryButton,DefaultButton } from "office-ui-fabric-react/lib/Button";
import { TextField } from "office-ui-fabric-react";

Wir laden hier neben React Objekte, die wir später brauchen, um zwischen Edit- und Display-Modus zu unterscheiden. Des weiterein laden wir noch Buttons und das TextFeld aus der UI-Fabric Bibliothek.

Danach fügen wir das Interface für die Properties hinzu, die wir unserer React-Komponente "FormixCustomizer" übergeben können wollen.

export interface IFormixCustomizerProps {
  context: FormCustomizerContext;
  displayMode: FormDisplayMode;  
  onSave: (item:any) => void;
  onClose: () => void;
  item:any; //<-- New
}

Das ist praktisch identisch mit dem generierten Interface, wir haben hier nur das Attribut "item" mit hinzugefügt. Darin transportieren wir das vom Webpart geladene Element zur Komponente.

Dann erstellen wir die Funktionale React Komponente "FormixCustomizer" und exportieren sie als "Standard-Export"

export const FormixCustomizer=(props:IFormixCustomizerProps)=>{

  return <div>
   <TextField
        name="Title"    
        label="Title"
      />   
    <PrimaryButton text="Save"/>
    <DefaultButton text="Cancel" />
  </div>
}
export default FormixCustomizer;

Dieses Formular hat nun alle Elemente, die wir verwenden wollen, aber noch keine Logik. Wir fügen daher als erstes einen "onClick"-Handler an den Cancel-Button an, der die "onClose" Methode des Webpart aufruft. Damit können wir das Formular schonmal schließen, wenn wir wollen.

...
 <DefaultButton text="Cancel" onClick={
        ()=>{
          props.onClose()
        }
    }/>
...

Das Textfeld hat aber noch keine Daten und wir können seine Daten noch nicht auslesen. Dazu fügen wir nun mittels der "React.useState" Methode einen dynamischen Status in der Komponente ein und verbinden diesen mit dem Textfeld.

 ...
  const [text,setText]=React.useState(props.item.Title)
  return <div>
    <TextField
        name="Title"
        value={text}
        label="Title"
        onChange={(e,value) => {
          setText(value);
        }}
      />   
...

In der Variablen "text" ist nun immer der Wert des Textfeldes gespeichert. Jetzt müssen wir nur noch dazu sorgen, dass beim Klick auf den "Speichern"-Knopf das geladene Element angepasst und danach gespeichert wird.

 ...
     <PrimaryButton text="Save" onClick={
        ()=>{
          props.item.Title=text;
          props.onSave(props.item)
        }
    }/>
...

Damit sieht unsere gesamte Komponente so aus:

export const FormixCustomizer=(props:IFormixCustomizerProps)=>{
  const [text,setText]=React.useState(props.item.Title)
  return <div>
    <TextField
        name="Title"
        value={text}
        label="Title"
        onChange={(e,value) => {
          setText(value);
        }}
      />   
    <PrimaryButton text="Save" onClick={
        ()=>{
          props.item.Title=text;
          props.onSave(props.item)
        }
    }/>
     <DefaultButton text="Cancel" onClick={
        ()=>{
          props.onClose()
        }
    }/>
  </div>
}

Ihr könnt euch den gesamten Code für dieses Beispiel hier ansehen und herunterladen.

Wenn wir mehr Felder in dem Formular bearbeiten wollen, dann müssen wir nur mehr dynamische Status-Variablen über mehr Aufrufe von "React.useState" und diese dann mit neuen Controls verknüpfen.

Bei dem letzten Satz ist euch vielleicht aufgefallen, dass dieses Vorgehen zwar einfach ist, aber natürlich auf Dauer mit einer Wachsenden Parameteranzahl zu sehr, sehr vielen Variablen und einer sehr unübersichtlichen Komponente führen wird.

Wir man das mit React Formik sehr einfach halten kann, erzähle ich euch im nächsten Artikel diese Serie.

Update 09.07.2023

Den nächsten Artikel dieser Serie könnt ihr euch hier ansehen.

Eine Vorlage für eine moderne SitePage mit Inhaltsverzeichnis

Sven Sieverding — Mon, 12 Jun 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-06-12/

Falls du eine große und lange Seite hast, die aus mehreren Sektionen besteht, dann kennst du bestimmt das Problem: Deine Besucher müssen entweder lange scrollen, bis sie zum relevanten Inhalt kommen oder -viel schlimmer- scrollen gar nicht erst nach unten und finden relevanten Inhalt nicht.

Ein Inhaltsverzeichnis auf der Seite ist praktisch und einfach gebaut. Füge einfach Text-Webparts zu deiner Seite mit hinzu (falls sie nicht eh schon vorhanden sind) und setze dort eine Überschrift (Benutze dafür die Überschriften-Vorlagen 1-4).

Publiziere nun die Seite und bewege dann deine Maus auf die Überschrift. Hier wird nun ein kleines "Ketten" Symbol rechts daneben erscheinen. Klicke mit der rechten Maustaste darauf und wähle "Link kopieren"

Du hast nun einen Link zu der Überschrift in deiner Zwischenablage.

Jetzt könntest oben auf der Seite ein Quick-Links Webpart erstellen und diesen Link dort einfügen. Machst du das mit mehreren Überschriften, dann hast du eine einfaches Inhaltsverzeichnis auf der Seite.

Aber

Willst du diese Seite nun kopieren oder gar als Seitenvorlage bereitstellen, dann wirst du enttäuscht sein. Die Links zeigen dann nicht auf die Überschriften in deiner Kopie, sondern immer noch auf die Überschriften im Original.

Das liegt daran, dass du "Absolute" Links kopiert und in das Inhaltsverzeichnis eingefügt hast. Du brauchst hier aber relative Links, die nicht den kompletten Pfad zur Seite enthalten, sondern nur die Information, wie man vom Inhaltsverzeichnis zu den Überschriften kommt.

Dazu müssen wir die Links bearbeiten, die wir uns kopiert haben.

Wenn der Link vorher

https://<tenant>.sharepoint.com/sites/<meineSite>/SitePages/<meinePage>.aspx#%C3%BCberschrift-1

war, dann brauchen wir nur den Anteil nach dem HashTag, also nur

#%C3%BCberschrift-1

Diesen Link können wir aber leider nicht in das Quicklinks- oder Button- Webpart einfügen.

Selbst als einfacher Link in einem Text Webpart lässt SharePoint dies nicht zu.

Der Grund ist, dass aus Sicherheitsgründen SharePoint immer eine komplette URL startend mit "https://" verlangt.

Markdown

Es gibt aber ein Webpart, mit dem wir das umgehen können. Das ist das "Markdown" Webpart.

Markdown ist eine textbasierte Dokumentationssprache, mit der man textbasiert sehr einfach formatierte Inhalte und Dokumente erstellen kann.

Beispielsweise wird aus

# Das ist eine Überschrift

Das ist einfacher Text.

* Das ist der erste Punkt einer Aufzählung 
* Das ist der zweite Punkt
* Das ist der dritte Punkt

das hier

Man kann auch Links einfügen und das machen wir uns nun zu Nutze. Wir fügen ein Markdown-Webpart zur Seite hinzu und fügen unsere Links in dem folgenden Format ein

[Überschrift 1](#%C3%BCberschrift)

[Überschrift 2](#%C3%BCberschrift-2)

[Überschrift 3](#%C3%BCberschrift-3)

![](./Markdown Webpart.png)

Damit sieht unsere Seite dann so aus.... Und wenn wir sie kopieren zeigen die Überschriften-Links auf die Sektionen der aktuellen Seite

Power Automate: Bessere Logs

Sven Sieverding — Fri, 19 May 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-05-19/

Flows sind mächtig. Ich kann mir einfache Benachrichtigungsflows bauen, aber auch komplexe Prozesse erstellen, die mir im Minutenzyklus aus mehreren Systemen Daten aggregieren und selbst aus mehreren Teilflows bestehen.

Wie behalte ich aber einen Überblick über alle meine Flow-Läufe? Ich meine das hier nicht technisch. Dass ein einzelner Flow auf einen Fehler läuft ist leicht zu erkennen. Was ist aber, wenn ein Flow, der hätte laufen sollen, nicht gelaufen ist?

WEnn ich mit einem komplexen Geflecht von Workflows zu tun habe, erstelle ich mir normalerweise noch zusätzlich ein paar Listen im Dataverse, in denen ich dann zusätzliche Informationen zu Flowläufen hinterlege. Das sind normalerweise die drei Tabellen "Process-Runs","Sub-Process-Runs","Process-Messages".

In der Tabelle "Process-Runs" hinterlege ich beim Start der Hauptprozesses alle relevanten Informationen

Spalte	Beschreibung
Process-Name	Der Name des Prozesses, der angestoßen wurde
Process-Params	Die Relevanten Parameter, die dem Prozess übergeben wurden
Process-Run-ID	Eine beim Start zufällig erzeugte guid
Process-Start	Der Zeitpunkt, an dem der Flow gestartet wurde
Process-End	Der Zeitpunkt, an dem der Flow beendet wurde
Process-LastModified	Der Zeitpunkt, an dem aus dem Flow das letzte Mal eine Aktualisierung an diese Liste geschrieben wurde
Process-State	Ein TextFeld, welches von innerhalb des Prozesses aktualisiert wird und mit den aktuellen Status anzeigt (z.B. "Initialisierung","Datenanlagephase","Ende" etc.)

In diese Liste schreibe ich nun einen neuen Eintrag, sobald der Hauptprozess gestartet wurde und setzte den Status und das Start_Datum. Wann immer der Flow eine bestimmte Phase durchlaufen hat, aktualisiere ich diesen Eintrag in der Tabelle, bis der Flow beendet ist.

Damit habe ich schon mal eine gute Grundlage zur Dokumentation und Überwachung meines Flows. Mittels dieser Tabelle kann ich nun recht einfach erkennen, ob ein Flow gestartet wurde und sich nicht innerhalb einer halbwegs erwarteten Zeit wieder beendet hat. Das kann ich zum Beispiel durch einen weiteren Flow überprüfen lassen, den ich zeitgesteuert regelmässig ausführe.

Manchmal macht es Sinn, einzelne Blöcke eines Flows in Child-Flows auszulagern. Oder wir iterieren in einer Schleiße über viele Elemente und wollen jeden einzelnen Schleifenablauf einzeln dokumentieren. Dazu benutze ich dann die Tabelle "Sub-Process-Runs"

Spalte	Beschreibung
Sub-Process-Name	Der Name des Prozesses, der angestoßen wurde
Sub-Process-Params	Die Relevanten Parameter, die dem Prozess übergeben wurden
Process-Run-ID	Die Guid des übergeordneten Flows
Process-State	Der Status des übergeordneten Flows, zu dem dieser Childflow gehört
Sub-Process-Run-ID	Eine beim Start zufällig erzeugte guid
Sub-Process-Start	Der Zeitpunkt, an dem der Flow gestartet wurde
Sub-Process-End	Der Zeitpunkt, an dem der Flow beendet wurde
Sub-Process-LastModified	Der Zeitpunkt, an dem aus dem Flow das letzte Mal eine Aktualisierung an diese Liste geschrieben wurde
Sub-Process-State	Ein TextFeld, welches von innerhalb des Prozesses aktualisiert wird und mit den aktuellen Status anzeigt (z.B. "Initialisierung","Datenanlagephase","Ende" etc.)

Die Tabelle ist analog zur "Process-Run" Tabelle aufgebaut. Hier ist nur das Feld "Process-Run-ID" zusätzlich vorhanden, mit dem ich auf den aufrufenden Flow in der "Process-Run" Tabelle verweise.

Wenn ich nun einen Childflow starte oder in einer Schleife Elemente bearbeite, erstelle ich immer einen Eintrag in dieser Tabelle und setzte entsprechend Statuswerte und Zeitstempel um, wenn es erforderlich wird.

Schließlich erstelle ich noch die letzte Tabelle "Process-Messages"

Spalte	Beschreibung
Process-Run-ID	Die Guid des übergeordneten Flows
Sub-Process-Run-ID	Die Guid des übergeordneten Child Flows (leer, wenn die Nachricht aus dem Hauptflow geschrieben wird)
Process-Message-Date	Der Zeitpunkt, an dem die Nachricht geschrieben wurde
Process-Message-Type	Der Typ der Nachricht, zum Beispiel "PROCESSING_ITEM"
Process-Message-Params	Die Parameter der Nachricht, zum Beispiel eine Item ID

In diese Liste schreibe ich nun Nachrichten, wenn ich bestimmte Phasen in meinen Workflows durchlaufe. Im Prinzip resultiert das ganze dann in einer Log-Datei über mehrere Flow Aufrufe nur für meinen aktuellen Process-Run.

Die ganzen Daten stehen dann als Werte im Dataverse und ich könnte Sie da auswerten. Das ist aber ein wenig mühselig, weswegen ich mir normalerweise nun eine kleine PowerApp baue, in der ich mir die Daten visualisiere.

Zunächst erstelle ich einen Screen, in auf dem ich alle "Process-Runs" zu einem komplexen Workflow darstelle:

Wenn ich auf einen konkreten Run klicke gelange ich auf einen Detailscreen zu diesem Run. Darauf stelle ich von links nach rechts alle möglichen Phasen des Workflows dar. Zu jeder Phase liste ich die durchlaufenden Childflows aus der Tabelle "Sub-Process-Runs" zu diesem Flow auf.

Über einen Klick auf einen der Pfleile nach rechts gelangt man auf eine Ansicht, in der ich alle Log-Einträge aus der Tabelle "Process-Messages" darstelle.

Über diese App kann ich mir nun einfach den Status meines Workflows live anzeigen.

Quick Tipp: Das Site Logo einer Site entfernen

Sven Sieverding — Fri, 05 May 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-05-06/

Es ist aber sehr einfach, das Logo zu "entfernen"

Erstelle dir einfach eine PNG Datei, die aus einem transparenten Hintergrund besteht und füge diese als Logo ein.

Hier ist ein Beispiel für eine solche Datei (Download)

Das ganze sieht dann so aus

Quick Tipp: Alle Elemente in einer Liste per Powershell löschen

Sven Sieverding — Wed, 05 Apr 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-04-05/

Connect-PnPOnline "https://tenant.sharepoint.com/sites/meineseite" -Interactive

$listname="meinlistenname"

Get-PnPListItem -List $listname -PageSize 500 |foreach-object {Remove-PnPListItem -List $listname -Identity $_.Id -Force}

Maximale Anzahl von Elementen in einer Liste? 5.000 vs 30.000.000

Sven Sieverding — Thu, 16 Mar 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-03-16/

Wenn wir uns diese "Microsoft Learn" Seite anschauen, dann steht da, dass ich 30 Millionen Elemente in einer Liste, bzw. 30 Millionen Dateien in einer Bibliothek speichern kann.

Super, also kann ich problemlos meine ca. 50.000 Elemente in meiner Liste speichern und damit arbeiten.

So einfach ist das leider nicht, sondern sogar recht kompliziert. Dieses 30-Millionen-Elemente ist wirklich das theoretische maximale Limit für Elemente in einer Liste. Du wirst aber in der Praxis vorher schon an andere Limits stoßen.

Generell solltest du dir den folgenden Satz merken

SharePoint ist keine Datenbank

Auch wenn SharePoint und Datenbanken im ersten Moment vielleicht ein paar oberflächliche Ähnlichkeiten gibt, arbeiten die Systeme im Hintergrund komplett unterschiedlich.

Datenbanken sind auf große Datenmengen und Verknüpfungen zwischen Tabellen ausgelegt. Dinge wie etwa eine Elementhistorie sind hier nicht vorgesehen.

SharePoint auf der anderen Seite sind für Zusammenarbeit zwischen Menschen gedacht, also etwa für das Erstellen von Aufgabenlisten. Große Datenmengen waren hier nie im Fokus.

Aber schauen wir uns das Thema mal genau an und erzeugen zuerst mal eine Liste mit nur 6000 Elementen. Ich mache das hier per Powershell. Ich füge auch noch ein weiteres Feld "Even" mit hinzu, in dem ich speichere, ob das Element mit einer geraden Nummer oder einer ungeraden Nummer eingefügt wurde.

Connect-PnPOnline "https://tenant.sharepoint.com/sites/meineseite" -Interactive
$listTitle="LargeList"

New-PnPList -Title $listTitle -Template GenericList
Add-PnPField -List $listTitle -DisplayName "Even" -InternalName "Even" -Type Boolean

1..6000 |ForEach-Object {
    Add-PnPListItem -List $listTitle -Values @{"Title" = "Item $($_)"; "Even"=(($_ % 2) -eq 0)}
}

Das sieht auf den ersten Blick super aus. Auf den zweiten Blick erkennen wir aber schon einige Probleme. Zunächst haben wir eine Warnung in den Listeneinstellungen darüber, dass wir mehr als 5000 Elemente in der Liste haben. Wichtiger ist es aber, dass wir die Liste nicht mehr filtern können.

5.000 Elemente in einer Ansicht

Das Problem liegt in der Art und Weise, wie SharePoint Daten aus der "internen" SharePoint Datenbank lädt. Da man im SharePoint Möglichkeiten hat Daten zu filtern, die es in der unterliegenden Datenbank nicht gibt, macht die SharePoint Applikation dieses selber. Das bedeutet, dass SharePoint zunächst alle Daten aus seiner Datenbank lädt und danach im Hauptspeicher des Servers filtert. Dieses Filtern ist aber aufwändig und daher auf 5000 Elemente beschränkt.

Daher kommt das erste Limit. Man kann zwar viele Elemente im SharePoint speichern, aber maximal 5000 Elemente auf einen Rutsch aus der Liste ausladen.

Um mit mehr Daten in der Liste arbeiten zu können müssen wir dafür sorgen, dass unsere erwarteten Ergebnisse schon in den 5000 Elementen sind, die initial vom SharePoint aus der Datenbank ausgeladen werden. Das erreichen wir durch eine geschickte Kombination von Indices und der Formulierung der Abfrage.

Über einen Index können wir die Elemente schon in der Datenbank des SharePoint filtern, bevor sie in den SharePoint geladen werden. Dazu gehen wir in die Listeneinstellungen, klicken auf "Indizierte Spalten" und fügen eine neue Spalte als Index hinzu. Wir können sogar zwei Spalten in einem Index verbinden.

Das können wir in unserem Beispiel etwa mit der "Even" Spalte machen. Darin sind 3000 Elemente mit "true" und 3000 Elemente mit "false" enthalten. Jede der Teilsummen ist kleiner als 3000 Elemente. Wenn wir nun zuerst nach "Even" filtern und danach nach einem anderen Wert können wir auch eine Liste mit mehr als 5000 Elementen filtern.

Das Vorgehen muss aber geplant werden. Wenn wir etwa eine Liste mit 50.000 Elementen haben, dann brauchen einen komplexeren Index. Zum Beispiel können wir ein Feld "Quartal" einführen, in dem wir eine Kombination aus "Quartal" und "Jahr" (z.B. "2023/1") speichern. Je nach unserem Anwendungsfall haben wir vielleicht weniger als 5000 Elemente pro Quartal. Wenn dieses Feld nun im Index ist, dann können wir zuerst nach den Quartal und dann danach nach unseren anderen Werten filtern.

Problematischer wird es, wenn wir mehr als 5000 Elemente in einem Rutsch aus einer Liste laden wollen. Ein Anwendungsfall wäre es etwa, wenn ich alle Elemente einer Liste exportieren möchte. Das müssen wir in mehreren Abfragen mittels eines Index machen und dann die Ergebnisse wieder zusammensetzen. Dazu gibt es aber in der Oberfläche keine einfache Möglichkeit und wir müssten etwas programmieren.

100.000 Elemente

Je mehr Elemente ich in einer Liste habe, desto mehr Funktionalitäten werden out-of-the-box nicht mehr so funktionieren, wie sie mit weniger als 5000 Elementen funktionieren würden. Ein weiteres Beispiel dafür sind Berechtigungen auf einzelnen Elementen.

Bei wenigen Elementen in einer Liste kann ich problemlos einem einzelnen Element andere Berechtigungen geben, als den anderen. Beispielsweise könnte ich ein einzelnes Element nur für Mitglieder einer Abteilung sichtbar machen.

Je mehr ich diese Einzel-Element Berechtigungen aber benutze und je mehr Elemente ich in meiner Liste habe, desto weniger gut wird das funktionieren. Zum einen werden mit die Berechtigungen die korrekte Erstellung von Indices schwieriger machen, zum andern wird das Laden von Elementen aus meiner Liste langsamer und langsamer werden, je mehr Einzelberechtigungen ich benutze. Bei 100.000 Elementen in einer Liste funktionieren Einzelberechtigungen gar nicht mehr.

Ich persönlich empfehle euch, generell wenige Einzelberechtigungen auf Listen zu verwenden. Am besten erstellt ihr mehrere Listen und berechtigt die kompletten Listen für verschiedene Berechtigungsgruppen und verschiebt die Elemente zwischen diesen Listen. Das hilft auch gleichzeitig dabei, die Anzahl der Elemente in den Listen klein zu halten.

30.000.000 Elemente

Das ist die wirklich theoretische Maximalanzahl von Elementen in einer Liste. Rein praktisch werdet ihr niemals an diesen Wert kommen, sondern schon viel, viel früher an etwas anderem scheitern

Quick Tipp: Alle Elemente mit eigenen Berechtigungen in einer Site auflisten

Sven Sieverding — Sun, 05 Mar 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-03-05/

Connect-PnPOnline "https://tenant.sharepoint.com/sites/meineseite" -Interactive


# Skip these list names
$skipTheseLists = @(
    "Style Library", 
    "Form Templates",
    "Site Assets",
    "Site Pages"
)

# Iterate through all lists
Get-PnPList -Includes HasUniqueRoleAssignments | Where-Object { $_.Hidden -eq $false -And -Not $skipTheseLists.contains($_.Title) } | ForEach-Object {
    
    Write-host "Checking for Items with UniqueRoleAssignments in List $($_.Title)"
    
    #Iterate through all items
    Get-PnPListItem -List $_.Title -PageSize 2000 | ForEach-Object {           
    
        $HasUniquePermissions = Get-PnPProperty -ClientObject $_ -Property "HasUniqueRoleAssignments"
        If ($HasUniquePermissions) {
            Write-Host -f Green "Item($($_.ID)) '$($_["Title"])' has Unique Permissions"
        }
    
    }
}

Wie entferne ich das 'Titel' Feld in meiner SharePoint Liste?

Sven Sieverding — Thu, 16 Feb 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-02-16/

Diese Frage habe ich schon häufig gehört. Gerade dann, wenn Benutzer eine neue Liste mit vielen eigenen Spalten erstellt haben, fragen sie sich, wie man diese unnütze Titel Spalte entfernen kann. Nun, darauf gibt es zwei Antworten.

1) Die Titelspalte ausblenden

Das Entfernen der Spalte ist nicht möglich, sie wird intern benötigt. Man kann sie aber einfach ausblenden. Zunächst muss ich dafür sorgen, dass sie kein Pflichtfeld mehr ist.

Dazu wähle ich "Rädchen"->"Listeneinstellungen",

dann suche ich die Spalte "Titel" und setze den Haken bei "Diese Spalte muss Informationen enthalten:" auf "Nein". Danach kehre ich zur Listenansicht zurück.

Um die Titel Spalte in der View zu entfernen klicke ich auf "+ Spalte hinzufügen",

dann auf "Spalten ein-/ausblenden"

und entferne den Haken bei "Titel". Das hat aber keine Auswirkungen auf die Formulare.

Um die Spalte vom Formular zu entfernen muss ich erst auf "+ Neu" klicken, um ein neues Element zu erstellen und dann oben rechts das kleine Menue auswählen und "Spalten bearbeiten" klicken.

Dort entferne ich den Haken bei "Titel" und speichere. Danach taucht das Feld auch auf den Formularen nicht mehr auf.

Soweit so gut, aber...

2) MACHT DAS NICHT

Die Spalte "Titel" ist sehr sinnvoll und ihr braucht sie mit ziemlicher Sicherheit. Sie ist dafür gedacht, dem Leser eine intuitive Zusammenfassung des Listenelements zu geben, damit der Leser auf einen Blick erkennen kann, was das für ein Listenelement ist.

So eine Spalte werdet ihr sehr, sehr wahrscheinlich in eurem Datenmodell haben. Zum Beispiel könnte das eine Auftrags- oder Bestellnummer sein. Benennt doch die Titelspalte einfach entsprechend um und entfernt diese andere Spalte.

Die Titelspalte umzubenennen ist ganz einfach. Wählt einfach "Spalteneinstellungen" und dann "Umbenennen"

Die Titelspalte ist nämlich wichtig und wird an vielen Stellen der Oberfläche benutzt. Falls ihr Sie nicht benutzt, dann habt ihr an vielen Stellen mehr Aufwand.

Zum Beispiel ist das Kontextmenue an dieses Titelfeld gebunden, genauso wie die "Teilen"- und "Kommentar" Funktionen

Wenn das Titelfeld nicht da ist, dann ist auch dieses Kontextmenue nicht da.

Falls ihr "Nachschlagen"- oder "Lookup"-Felder erstellt, dann zeigen die im Standard auch immer auf das Titelfeld der Liste. Und von solchen Beispielen gibt es sehr, sehr viele.

Ihr tut euch also selber keinen Gefallen, wenn ihr das Titelfeld ausblendet. Versucht besser, in das Titelfeld andere Daten einzutragen und es dann nach euren Bedürfnissen umzubenennen.

Listenelemente oder Dokumente, die nur ich und ein Admin sehen kann

Sven Sieverding — Mon, 06 Feb 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-02-06/

Das ist eine häufig gestellte Anforderung. Ich als Mitarbeiter soll/muss in einer Liste Daten eintragen, die aber außer mir und einem Vorgesetzten/Prozessverantwortlichen niemand sonst sehen soll.

Das kann ich mittels eines Power Automate Prozesses lösen, der bei jedem Element die Berechtigungen neu setzt. Brauche ich aber nicht.

Ich kann das nämlich einfach mit SharePoint Bordmitteln lösen. In diesem Beispiel erstelle ich dazu zunächst eine Liste. Mit einer Dokumentenbibliothek geht es aber genauso.

Bei dieser Liste öffne ich die Listeneinstellungen ("Rädchen"->"Listeneinstellungen") und öffne dort "Erweiterte Einstellungen". Dort ist der Abschnitt "Berechtigungen auf Elementebene" für mich interessant.

Hier ändere ich den "Lesezugriff auf "Elemente lesen, die vom Benutzer erstellt wurden" und den "Erstellungs- und Bearbeitungszugriff" auf "Elemente erstellen und bearbeiten, die vom Benutzer erstellt wurden"

Nun kann ich als Benutzer immer noch Elemente in meiner Liste erstellen und sehen, welche Elemente ich erstellt habe.

Was ist jetzt mit dem Vorgesetzten? Den mache ich zum Websitesammlungsadministrator. Geht dazu zu "Rädchen"->Websiteinformationen->"Alle Websiteinformationen anzeigen"->"Websiteberechtigungen" und klickt dann oben auf "Websitesammlungsadministratoren"

Diese Benutzer haben Rechte auf alles in der Site (Tatsächlich ist bei ihnen die Berechtigungsprüfung technisch einfach ausgeschaltet). Damit kann ein Websitesammlungsadministrator auch wiederum alle Elemente in unserer Liste lesen. Also fügen wir den Vorgesetzten hier mit ein.

Das bedeutet aber auch, dass der Vorgesetzte alles andere auf dieser Website sehen und bearbeiten kann. Was ist, wenn ich das nicht will?

Das ist eine Frage der Architektur deiner SharePoint Seiten. Ich persönlich tendiere dazu, viele Seiten zu haben, aber in jeder Seiten wenige oder gar nur einen Anwendungsfall abzubilden. Also würde ich eine komplett eigene Webseite haben, in der nur diese eine Liste liegt. Damit gibt es kein weiteres Berechtigungsproblem.

Power Automate und SharePoint Location Spalten passen nicht zusammen

Sven Sieverding — Sun, 29 Jan 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-01-29/

Wenn ihr im SharePoint eine Liste erstellt, dort eine Spalte vom Typ "Location" hinzufügt und auch noch einstellt, dass sie Informationen enthalten muss, dann funktioniert das in SharePoint sehr gut. Ich kann dann dort nach einer Adresse suchen und bekomme automatisch alle Informationen wie Straße, Postleitzahl etc.

Versuche ich dann aber mit PowerAutomate auf diese SharePoint Liste zuzugreifen, dann bekomme ich diese Fehlermeldung:

The dynamic operation request to API 'sharepointonline' operation 'GetTable' failed with status code 'BadRequest'. This may indicate invalid input parameters. Error response: { "status": 400, "message": "The required field "Location" data type is not supported clientRequestId: d910e62e-3d24-4c76-90cf-af6075b93ab5 serviceRequestId: d910e62e-3d24-4c76-90cf-af6075b93ab5" }

Mit dem Spaltentyp "Location" scheinen die PowerAutomate Aktionen nicht wirklich gut umgehen zu können.

Ein Location Feld auslesen

Das ist aber nicht weiter schlimm, dafür haben wir die "Send an HTTP request to SharePoint" Aktion.

Als Ergebnis bekommen wir für unser Location Feld das hier

{
    ...
     "Location":"{\"EntityType\":\"LocalBusiness\",\"LocationSource\":\"Bing\",\"LocationUri\":\"https://www.bingapis.com/api/v6/localbusinesses/YN873x16209519703153017334\",\"UniqueId\":\"https://www.bingapis.com/api/v6/localbusinesses/YN873x16209519703153017334\",\"DisplayName\": \"Microsoft Corporation\",\"Address\":{\"Street\": \"1 Microsoft Way\",\"City\": \"Redmond\",\"State\": \"WA\",\"CountryOrRegion\": \"US\",\"PostalCode\": \"98052\"},\"Coordinates\": {\"Latitude\": 47.6398811340332,\"Longitude\": -122.12833404541016}}"
   ...  
}

was wir nochmal mittels einer "Parse JSON" Aktion parsen können

{
    "EntityType": "LocalBusiness",
    "LocationSource": "Bing",
    "LocationUri": "https://www.bingapis.com/api/v6/localbusinesses/YN873x16209519703153017334",
    "UniqueId": "https://www.bingapis.com/api/v6/localbusinesses/YN873x16209519703153017334",
    "DisplayName": "Microsoft Corporation",
    "Address": {
        "Street": "1 Microsoft Way",
        "City": "Redmond",
        "State": "WA",
        "CountryOrRegion": "US",
        "PostalCode": "98052"
    },
    "Coordinates": {
        "Latitude": 47.6398811340332,
        "Longitude": -122.12833404541016
    }
}

Damit haben wir alle Informationen, die in der Location Spalte gespeichert waren.

Ein Location Feld aktualisieren

Umgekehrt funktioniert das Updaten eines Listenelements auch mit einer "Send an HTTP request to SharePoint" Aktion.

Hierzu müssen wir das JSON wieder in einem String encodieren und dann mittels der SharePoint API speichern.

Falls wir die ganzen Geo-Koordinaten nicht zur Verfügung haben können wir übrigens SharePoint danach suchen lassen. Damit werden die meisten der Daten automatisch aufgelöst.

Wir können das etwas komplexe JSON oben zu diesem hier vereinfachen.

{
    "DisplayName": "Bremen, Hauptbahnhof",
    "EntityType": "Custom"
}

Solange der DisplayName eindeutig ist, wird dieser Wert automatisch in Geo-Koordinaten aufgelöst,

und wir bekommen den Eintrag zum Bremer Hauptbahnhof

Quick Tipp: Ein Theme als SiteCollection Administrator auf einer SharePoint Site setzen

Sven Sieverding — Mon, 16 Jan 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-01-16/

<?xml version="1.0"?>
<pnp:Provisioning xmlns:pnp="http://schemas.dev.office.com/PnP/2022/09/ProvisioningSchema">
  <pnp:Templates ID="ThemeTemplate">
    <pnp:ProvisioningTemplate ID="ThemeProvisioningTemplate" >
      <pnp:Theme Name="MyColorTheme" IsInverted="false">
        {
        "themePrimary": "#aaaaaa",
        "themeLighterAlt": "#fefcf6",
        "themeLighter": "#fcf3dd",
        "themeLight": "#fae8bf",
        "themeTertiary": "#f4d282",
        "themeSecondary": "#efbe4b",
        "themeDarkAlt": "#d5a32f",
        "themeDark": "#b48a28",
        "themeDarker": "#85661d",
        "neutralLighterAlt": "#f8f8f8",
        "neutralLighter": "#f4f4f4",
        "neutralLight": "#eaeaea",
        "neutralQuaternaryAlt": "#dadada",
        "neutralQuaternary": "#d0d0d0",
        "neutralTertiaryAlt": "#c8c8c8",
        "neutralTertiary": "#a9a9a9",
        "neutralSecondary": "#8d8d8d",
        "neutralPrimaryAlt": "#727272",
        "neutralPrimary": "#020202",
        "neutralDark": "#3a3a3a",
        "black": "#1e1e1e",
        "white": "#ffffff",
        "bodyBackground": "#ffffff",
        "bodyText": "#020202"
        }
      </pnp:Theme>
    </pnp:ProvisioningTemplate>
  </pnp:Templates>
</pnp:Provisioning>

Connect-PnPOnline "https://tenant.sharepoint.com/sites/meineseite" -Interactive

Invoke-PnPSiteTemplate .\theme.xml

Quick Tipp: Die Dokumententemplates an einer Bibliothek per Powershell setzen

Sven Sieverding — Fri, 13 Jan 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-01-13/


Connect-PnPOnline "https://tenant.sharepoint.com/sites/meineseite" -Interactive

$template=@"
[   
    {
     "templateId": "NewFolder",
        "title": "Folder",
        "visible": false
    },
    {
        "templateId": "NewDOC",
        "title": "Word document",
        "visible": false
    },
    {
        "templateId": "NewXSL",
        "title": "Excel workbook",
        "visible": false
    },
    {
        "templateId": "NewPPT",
        "title": "PowerPoint presentation",
        "visible": false
    },
    {
        "templateId": "NewONE",
        "title": "OneNote notebook",
        "visible": false
    },
    {
        "templateId": "NewXSLSurvey",
        "title": "Excel survey",
        "visible": false
    },
    {
        "templateId": "NewXSLForm",
        "title": "Forms for Excel",
        "visible": false
    },
    {
        "templateId": "NewVSDX",
        "title": "Visio drawing",
        "visible": false
    },
    {
        "contentTypeId": "0x0101007083E649E686654AA7A5D0994977BD3E",
        "isUpload": true,
        "templateId": "MyDocumentTemplate",
        "title": "my Document Template",
        "url": "/sites/meineseite/AnyDocumentLibrary/MyTemplateFile.docx",
        "visible": true
    }
]
"@


$view = Get-PnpView -List $listname | Where-Object {$_.DefaultView -eq $true}
$view.NewDocumentTemplates = $template -replace "`n","" -replace "`r",""
$view.Update()
Invoke-PnPQuery

SharePoint Virtual Tables

Sven Sieverding — Wed, 11 Jan 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-01-11/

Man kann seit neuestem SharePoint Listen als virtuelle Tabellen im Dataverse verknüpfen. Das hat den Vorteil, dass auf die Daten im Dataverse über Standardmechanismen zugegriffen werden kann, es aber immer noch im SharePoint Formulare gibt, mit denen ich leicht die Daten bearbeiten kann.

Vorbereitung

Um die virtuellen SharePoint Tabellen einzurichten, installiert zuerst den "Virtual Connector in Dataverse" von diesem Link

https://appsource.microsoft.com/en/product/dynamics-365/mscrm.connector_provider

in euer Zielenvironment im Dataverse.

Legt euch ansonsten noch eine Liste an. Ich erstelle hier eine Liste mit Geburtstagen.

![](./Birthdays SharePoint.png)

Connection Reference erstellen

Danach öffnet das PowerApps Studio und erstellt eine neue Solution. In dieser Solution wählt ihr "New > More > Connection Reference".

![](./2 Connection Reference.png)

Wählt hier nun eine Connection zum SharePoint aus, über die sich die virtuelle Tabelle später verbinden soll. Falls ihr noch keine habt, dann erstellt hier eine.

![](./3 ConnectionReference.png)

Klickt nun oben rechts auf das Rädchen und auf "Advanced Settings" um zu den erweiterten Dynamics Einstellungen zu gelangen.

Virtuelle Entitätsquelle erstellen

![](./4 Advanced Settings.png)

Wählt dort nun Einstellungen->System-> Verwaltung

![](./4 Administration.png)

und dann "Virtuelle Entitätsquellen"

![](./6 Virtuelle Entitaetsdatenquellen.png)

Klickt hier "Neu" und erstellt einen neuen Datenanbieter vom Typ "Virtual Connector Data Provider"

![](./7 Virtual Connector Data Provider.png)

Wählt hier für die Verbindungsreferenz die Referenz aus, die wir vorhin erstellt haben und tragt bei "Dataset-Wert" die URL eurer Site Collection ein (Nicht die die Liste).

![](./8 Virtual Connector Data Provider Config.png)

Ein Job im Hintergrund erstellt und nun einen Entitätskatalog. Das kann es ein paar Minuten dauern.

Die Dataverse Entität erstellen

Verlasst nun die erweiterten Dynamics Einstellungen und kehrt zum PowerApps Studio (https://make.powerapps.com) zurück.

Sucht nun unter "Tables" nach dem neu erstellen Entity Katalog für unsere SharePoint Site.

![](./9 Entity Catalog.png)

Hier sollte nun unser Listenname auftauchen. Markiert diesen Eintrag und wählt "Edit using form"

![](./10 Edit using Form.png)

Aktiviert nun die Entität, indem ihr

"Create or Refresh Entity" auf "Yes"
"Primary key of the Virtual Entity" auf die ID Spalte der Liste und
"Primary field of the Virtual Entity" auf die Titel Spalte der liste setzt.

![](./11 Create Entity.png)

Hier passiert nun ein Fehler. Es wird für euch so aussehen, als hättet ihr die Daten nicht gespeichert. Auch wenn ihr den Eintrag ein zweites Mal mittels "Edit using form" bearbeitet, werdet ihr die Änderungen nicht sehen. Sie wurden aber gespeichert.

Das könnt ihr daran erkennen, dass ein paar Minuten später im PowerApps Studio unter "Tables" eine neue Tabelle auftaucht.

![](./12 New Table.png)

Die Tabelle hat dieselben Daten wie unsere Liste. Änderungen werden automatisch von Tabelle zu Liste gespiegelt, egal, ob ich die Daten nun hier bearbeite oder in der Liste.

Dasselbe funktioniert übrigens nicht nur mit SharePoint Listen sondern mit einer vielzahl anderer Systeme, für die es entsprechende Konnectoren gibt.

Quick Tipp: Mit einem Lookup auf den Dokumentennamen verweisen

Sven Sieverding — Mon, 09 Jan 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-01-09/

Hier erstelle ich ein neues Feld "Related Documents" mit dem ich verwandte Dokumente zu einem Dokument angeben kann. Das geht nicht über die Oberfläche ("Name" bzw. "FileLeafRef" ist hier nicht auswählbar), daher lege ich es per Powershell an.

Connect-PnPOnline "https://tenant.sharepoint.com/sites/meineseite" -Interactive

$ListName="Documents"
$LookupFieldName="RelatedDocument"

# Add the field to the list
Add-PnPField -List $ListName -Type Lookup -DisplayName $LookupFieldName -InternalName $LookupFieldName -AddToDefaultView

# Set the lookup list for the field and set the lookup field to "FileLeafRef"
Set-PnPField -List $ListName -Identity $LookupFieldName -Values @{LookupList=(Get-PnPList $ListName).Id.ToString(); LookupField="FileLeafRef"}

Quick Tipp: Tage bis zu einem Datum in einer Listenspalte anzeigen

Sven Sieverding — Sat, 07 Jan 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-01-07/

Wenn ihr darstellen möchtet, wie viele Tage noch bis zu einem bestimmten Datumswert in einer SharePoint Liste sind, dann geht das nicht mittels einer "Calculated Column" (da diese nur beim Speichern eines Elementes aktualisiert wird), sondern mit diesem JSON List formatting.

Wendet es einfach auf eine beliebige Datumsspalte an.

{
  "$schema": "https://developer.microsoft.com/json-schemas/sp/v2/column-formatting.schema.json",
  "elmType": "div",
  "txtContent": "=floor((Number(@currentField)-Number(Date((getMonth(@now)+1)+'.'+getDate(@now)+'.'+getYear(@now))))/(60*60*24*1000))+' day(s) remaining'"
}

Quick Tipp: Eine Communication Site als Subsite anlegen

Sven Sieverding — Thu, 05 Jan 2023 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2023-01-05/

Connect-PnPOnline "https://tenant.sharepoint.com/sites/meineseite" -Interactive

$Locale = 1031 #1033 English /1031 German
$SiteUrl= "MySubsite"
$Template = "SITEPAGEPUBLISHING#0" #Communication Site

New-PnPWeb -Title $SiteUrl -Url $SiteURL  -Locale $Locale -Template $Template

Microsoft Tech Community: Member of the Week

Sven Sieverding — Sun, 18 Dec 2022 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2022-12-18/

Ich war gestern recht überrascht, als ich die Benachrichtigung erhielt, dass ich im MTC Weekly Roundup als "Member of the Week" erwähnt wurde.

https://techcommunity.microsoft.com/t5/tech-community-blog/mtc-weekly-roundup-december-16/ba-p/3699381

Dankeschön :) #SharingIsCaring #communityrocks

SharePoint Json List Formatting und die nicht existierende WEEKDAY Funktion

Sven Sieverding — Fri, 09 Dec 2022 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2022-12-09/

SharePoint Online bietet die Möglichkeit mittels einer einfachen JSON Formatting Datei das Aussehen von Listenansichten komplett zu verändern. Zum Beispiel kann das Aussehen und Verhalten eines Feldes in einer Ansicht geändert werden, aber auch die gesamte Ansicht. Häufig wird diese Funktionalität aber auch einfach dafür verwendet, um bestimmte Zeilen in einer Liste hervorzuheben und auf sie hinzuweisen.

Zum Beispiel

Markiere alle Elemente, die in einem bestimmten Status sind.
Markiere alle Elemente, bei denen ein Wert eine bestimme Summe übersteigt.
Markiere alle Elemente, bei denen ein Datum in der Vergangenheit liegt.

Das ist alles einfach zu formulieren und unter

https://pnp.github.io/List-Formatting

findet ihr viele Beispiele dafür. Eine komplette Liste der Funktionen, die man zum Berechnen benutzen kann, gibt es bei Microsoft Learn.

Wenn ihr dort aber nach einer "WEEKDAY"-Funktion sucht, also nach einer Funktion, die euch den Wochentag zu einem Datum berechnet, dann werdet ihr da nicht fündig werden. So eine Funktion gibt es nicht.

Aber wir können sie selbst nachbauen.

Hervorheben einer Zeile

Zunächst kümmern wir uns aber erstmal um die Grundstruktur der JSON-Datei, die wir im Folgenden benutzen wollen. Als Beispiel werde ich hier eine Zeile in der Listenansicht hervorheben, wenn eine bestimmte Bedingung eintritt.

Dafür müssen wir nur die "additionalRowClass" abhängig von einer Bedingung setzen.


{
  "$schema": "https://developer.microsoft.com/json-schemas/sp/v2/row-formatting.schema.json",
  "additionalRowClass": "=if(<irgendwas>==<irgendwas>,'ms-bgColor-themeLighter ms-bgColor-themeLight--hover','')"
}

Unsere WEEKDAY Funktion

Dann können wir die fehlende WEEKDAY Funktion mittels ein wenig Mathematik nachbilden.

Mit dem Token

=@now

bekommen wir das aktuelle Datum und darauf aufbauend mit dem Ausdruck

=Number(Date(@now))

die aktuelle Anzahl von Millisekunden seit Donnerstag, dem 01.01.1970 UTC.

Indem wir das durch die Anzahl von Millisekunden in einem Tag teilen

=floor(Number(Date(@now))/ 86400 / 1000)

erhalten wir die Anzahl der Tage seitdem.

Der 01.01.1970 UTC war ein Donnerstag, daher müssen wir zu dieser Summe 4 hinzufügen, um den Sonntag als Start der Woche auszuwählen (Wenn ihr den Montag als Start der Woche haben wollt, dann müsst ihr hier 5 hinzufügen).

Nun können wir diese Summe durch 7 teilen und erhalten die Anzahl der Wochen seit dem 01.01.1970 und einen Rest von Wochentagen. Dieser Rest interessiert uns und wir bekommen ihn mittels der "Modulo" Funktion ("%").

=(floor(Number(Date(@now))/ 86400 / 1000)+4) % 7

Das gibt uns einen Wert zwischen 0 und 6 für den im Moment aktuellen Wochentag in London.

Um das nun wiederum an unsere lokale Zeitzone anzupassen, müssen wir den Zeitstempel 01.01.1970 00:00 noch die Verschiebung mitgeben, die wir in unserer lokalen Zeitzone haben. Ich mach das hier, indem ich die Zeit in Millisekunden vom Zeitstempel 01.02.2020 von 1577836800000 abziehe (Der UTC Zeit in Millisekunden vom "01.01.2020" in London).

=1577836800000-Number(Date('01.01.2020')

Wenn wir das alles zusammenfügen, erhalten wir die folgende „WEEKDAY“ Funktion zum Berechnen des aktuellen Wochentages.

=(floor(((Number(Date(@now))+1577836800000-Number(Date('01.01.2020')))/ 86400 / 1000)+4) % 7

by the way

Mittels derselben Berechnung können wir auch unsere lokale Zeitzone als Unterschied in Stunden von UTC berechnen

=floor((1577836800001-Number(Date('01.01.2020')))/3600 / 1000)

Diese Funktion gibt uns einen Stundenunterscheid zwischen -12 und 12 und sagt uns, um wie viele Stunden uns unsere lokale Zeitzone von UTC unterscheidet (Ich habe 1 zu 1577836800000 hinzugefügt, um sicherzustellen, dass wir keinen "DIVISION BY ZERO" Fehler bekommen, wenn wir in London sind. Die "floor" Funktion gleicht die 1 dann wieder aus).

Alles Zusammen

Damit erhalten wir dann das folgende JSON-Template:


{
  "$schema": "https://developer.microsoft.com/json-schemas/sp/v2/row-formatting.schema.json",
  "additionalRowClass": "=if([$DayOfWeek] == (floor(((Number(Date(@now))+1577836800000-Number(Date('01.01.2020')))/ 86400 / 1000)+4) % 7),'ms-bgColor-themeLighter ms-bgColor-themeLight--hover','')"
}

Wenn wir eine Liste mit dieser Spalte erstellen:

Field	Type
Weekday	Nummer

und dann die folgenden Werte Eintragen

Weekday	Nummer
Sunday	0
Monday	1
Tuesday	2
Wednesday	3
Thursday	4
Friday	5
Saturday	6

Die Ansicht sieht an einem Sonntag dann so aus:

und an einem Mittwoch so:

Die Dateien

Dieses Beispiel ist im PNP Github Repository verfügbar:

https://github.com/pnp/List-Formatting/tree/master/view-samples/highlight-rows-current-weekday

Die versteckte SharePoint Benutzerinformationsliste

Sven Sieverding — Thu, 20 Oct 2022 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2022-10-20/

Es gibt innerhalb jeder SharePoint Site Collection eine versteckte Liste, die "UserInformationList".

Was ist das?

Das ist keine Liste aller User, die es im Verzeichnis gibt, sondern sie hält nur Informationen über die User vor, die in der jeweiligen Site Collection benutzt werden.

Ihr könnt euch die Einträge in der Liste ansehen, wenn ihr eine der folgenden Urls in eurem Browser eingebt:


https:/<Site Collection>/_catalogs/users/simple.aspx
https:/<Site Collection>/_catalogs/users/detail.aspx
https:/<Site Collection>/_layouts/15/people.aspx?MembershipGroupId=0

Ein Personenfeld in einer SharePoint Liste ist zum Beispiel technisch nur ein Lookup auf einen Eintrag in dieser Liste. Der Displayname des Benutzers wie etwa in den "Geändert"- und "Ertellt"-Spalten ist daher genau der Wert, der für den Benutzer in der Benutzerinformationsliste gespeichert ist. Er wird im klassischen SharePoint bei jeder Darstellung des Datensatzes daher auch nicht "live" aus dem Verzeichnis aufgelöst, sondern aus dieser Liste geladen.

Felder

Die folgenden Felder sind in dieser Liste enthalten:

Name	Title
Account	Name
E-Mail	EMail
OtherMail	OtherMail
User Expiration	UserExpiration
User Last Deletion Time	UserLastDeletionTime
Mobile Number	MobilePhone
About Me	Notes
SIP Address	SipAddress
Locale	Locale
Calendar Type	CalendarType
AdjustHijriDays	AdjustHijriDays
TimeZone	TimeZone
Time Format	Time24
Alternate Calendar Type	AltCalendarType
CalendarView Options	CalendarViewOptions
WorkDays	WorkDays
WorkDay StartHour	WorkDayStartHour
WorkDay EndHour	WorkDayEndHour
Multiple UI Languages	MUILanguages
Content Languages	ContentLanguages
Is Site Admin	IsSiteAdmin
Deleted	Deleted
Hidden	UserInfoHidden
Picture	Picture
Department	Department
Job Title	JobTitle
Is Active	IsActive
First name	FirstName
Last name	LastName
Work phone	WorkPhone
User name	UserName
Web site	WebSite
Ask Me About	SPSResponsibility
Office	Office
Picture Timestamp	SPSPictureTimestamp
Picture Placeholder State	SPSPicturePlaceholderState
Picture Exchange Sync State	SPSPictureExchangeSyncState
Picture	PictureDisp
Picture Only	PictureOnly_Size_36px
Picture Only	PictureOnly_Size_48px
Picture Only	PictureOnly_Size_72px

Wann passiert ein neuer Eintrag in der Liste?

Du bekommst für einen Benutzer einen neuen Eintrag in der Liste, wenn du

Einem Benutzer über die UI auf der Seite berechtigst
Einen Benutzer über die UI in einer Lookup Spalte referenzierst
Über die API die "ensureUser" Methode für den Benutzer aufrufst
oder wenn der Benutzer die Seite selbst besucht

Du bekommst KEINEN neuen Eintrag in dieser Liste, wenn du

Eine AD Gruppe auf der Seite berechtigst, die den Benutzer enthält. (Der Eintrag passiert dann erst, sobald der benutzer die Seite besucht)

Wie lösche ich einzelne User aus der Liste?

Wenn ihr die Informationen über den User wirklich komplett aus der Liste löschen wollt, dann könnt ihr das über diese URL tun


https:/<Site Collection>/_layouts/15/people.aspx?MembershipGroupId=0

Zwei neue Features in der Powerplattform, die ich wirklich liebe

Sven Sieverding — Sat, 01 Oct 2022 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2022-10-01/

In den letzten Monaten sind zwei neue Funktionen zum Power Plattform Funktionsumfang hinzugefügt worden, die dem Low Code Entwickler das Leben stark vereinfachen können.

Power Automate: Trigger Outputs

Wenn Sie einen Flow erstellt haben, der sehr häufig ausgeführt wird, dann werden Sie dieses Problem wahrscheinlich kennen:

Die Flow-Historie läuft über und um einen speziellen Flow Run wiederzufinden, müssen Sie jeden einzelnen Run öffnen und die Parameter im Trigger prüfen.

Bei vielen Runs kann das recht lange dauern. Glücklicherweise lassen sich mittlerweile die "Trigger Outputs" als neue Spaten mit in die Flow-Run Tabelle aufnehmen.

Klicken Sie dazu oberhalb der Tabelle auf "Spalten bearbeiten"

und fügen Sie dann die Spalten mit hinzu, die Sie interessieren.

Die tauchen danach dann in der Flow-Run Tabelle auf

Hier können wir nun auf einen Blick erkennen, welche Paramater für die Flow Run benutzt wurden und welche der Flow Runs für uns relevant sind.

Power Apps: Benannte Formeln

Es kann gut sein, dass Sie in einer PowerApp dieselbe Formel immer und immer benutzen. Das kann zum Beispiel passieren, falls Sie mehrere Elemente abhängig von dem Wert in einen Formular sichtbar/unsichtbar machen wollen.

Typischerweise hätten Sie in dem Fall mehrere Einträge der Formel "Visble=myToggle.Value" an verschiedenen Elementen. Das ist ein sich wiederholende Formel, was im Bezug auf Wartbarkeit keine richtig gute Idee ist. Falls ich die Formel mal ändern muss, dann muss ich das zum Beispiel an vielen, vielen Stellen tun.


// Wiederholend in der Visible-Eigenschaft von vielen,vielen Elementen
=myToggle.Value

Besser wäre es, wenn wir hier eine Variable definieren würden, die wir im OnChange Elements des Toggles auf einen Wert setzten und diese Variable dann mit den Elementen zu benutzen, also etwa so

// im OnChange Event von MyToggle
Set(MyAdditionalFormDataVisible,myToggle.Value)

// In der Visible-Eigenschaft von vielen Elementen
=MyAdditionalFormDataVisible

Das ist dann in Bezug auf Anpassbarkeit der vielen Elemente mit den Visible-Eigenschaften schon viel besser, hat aber auf der OnChange-Seite auch ein paar Nachteile.

Zum einen sollte ich die Variable schon bei App.OnStart setzen, damit ich zum Start der App nicht in einem undefinierten Zustand starte. Damit setze ich die Variable schon wenigstens zweimal, mit im schlimmsten Fall sogar mit identischem Code.
Dann ist dieser Programmierstil imperativ (wenn etwas passiert, dann führe XYZ aus) und nicht deklarativ (Ich deklariere, dass der Wert von Feld X immer A+B ist und meine Applikation stellt das sicher) und entspricht damit nicht so richtig der generellen Struktur von PowerApps.
Und zum dritten explodiert die Komplexität dieses Ansatzes, sobald ich den Wert der Variablen nicht mehr nur durch ein einzelnes Toggle-Control berechnen kann, sondern sich der fachliche "Visible" Wert aus den Werten mehrerer Controls zusammensetzt. Dann habe ich in den OnChange Methoden jedes Controls die Anweisung zum Setzen der Variablen.

Besser wäre es, wenn wir zentral eine deklarative Formel definieren könnten, die wir dann bei vielen Elementen einfach benutzen können.

Das genau sind die neuen "Benannten Formeln"

Um diese Funktion zu benutzen zu können, müssen Sie sie aber zunächst in den Einstellungen unter "Bevorstehende Funktionen"/"Experimentelle"/"Benannte Formeln" aktivieren und die App einmal speichern und neu laden.

Danach haben wir auf dem App-Element die neue Eigenschaft "Formulas"

Hier kann ich nun meine Formeln definieren, indem ich einfach einen beliebigen Namen mit einer Formel gleichsetze.

// Unter App.Formulas
MyAdditionalFormDataVisible=myToggle.Value

// In der Visible-Eigenschaft von vielen Elementen
=MyAdditionalFormDataVisible

Diese Formel evaluiert sich nun automatisch zur Laufzeit immer von alleine. Falls sich also mal etwas an myToggle ändert, dann ändert sich sofort automatisch der Wert von "MyAdditionalFormDataVisible".

Falls ich später für die Sichtbarkeit ein weiteres Control mit einbeziehen muss, dann muss ich das nur einmal an dieser zentralen Stelle tun.

// Unter App.Formulas
MyAdditionalFormDataVisible=myToggle.Value && myOtherToggle.Value

// In der Visible-Eigenschaft von vielen Elementen
=MyAdditionalFormDataVisible

Das erleichtert Wartbarkeit und Lesbarkeit der PowerApp enorm.

Clean Code für Flows

Sven Sieverding — Sat, 17 Sep 2022 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2022-09-17/

Auf dem PowerThon 2022 habe ich einen Vortrag zum Thema "Clean Code für Flows" gehalten. Hier zeige ich, wie man aus einem unübersichtlichen, komplizierten und nicht wartbarem Flow mit Best Practices eine vernünftige Lösung erstellen kann.

Download

Sie können sich die Präsentation und Solution hier herunterladen.

5 Tricks, die ich bei jeder Powerapp Entwicklung benutze

Sven Sieverding — Thu, 18 Mar 2021 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2021-03-18/

1) Farben, Schriften etc. als Variablen

Es ist in PowerApps wunderbar einfach, einem Element eine neue Farbe zu geben. Einfach daraufklicken und im Farbauswahldialog auf der rechten Seite oder oben in der Formel-Zeile die neue Farbe angeben und schon sind wir fertig. Wenn wir dieselbe Farbe auf einem anderen Element setzen, dann wiederholen wir das einfach.

Wenn wir diese Farbe aber nun an allen Elementen der PowerApp ändern müssen wird das aber sehr, sehr schnell sehr, sehr aufwändig. Aus dem Grund tendiere ich dazu, diese Einstellungen nur einmal zu machen und in einer Variablen zu speichern und mich später bei allen Komponenten einfach auf diese Variable zu beziehen.

Dazu benutze ich die "App.onStart" Methode. Sie können diese bearbeiten, indem Sie auf der linken Seite in der Baumansicht oben die App auswählen und dann das "On Start" Attribut bearbeiten. Diese Methode wird bei jedem Start der App automatisch ausgeführt und ist ein idealer Platz zum Setzen globaler Variablen. Sie können sie während der Entwicklung aber auch jederzeit händisch ausführen, indem sie bei dem Eintrag "App" auf die drei Punkte klicken und dann "Run OnStart" ausführen.

Ich setze hier die folgenden zwei Variablen

Set(_CompanyColor,RGBA(143, 56, 56, 1));
Set(_CompanyFont,Font.'Segoe UI');

und beziehe mich im Folgenden beim Styling aller Elemente nur noch auf diese Variablen.

2) Debug Modus

Wenn die PowerApp fertig entwickelt ist und im "echten Leben" von Usern benutzt wird kann es natürlich zu Fehlern kommen. Manchmal wäre es dann gut, wenn wir uns einfach den Wert mancher Variablen oder Eigenschaften darstellen könnten.

Das kann man wunderbar einfach machen, indem wir auf den entsprechenden Seiten Labels platzieren, die uns diese Werte zeigen. Diese sollten normalerweise für den Benutzer nicht sichtbar sein und wir müssten entscheiden können, ob diese Labels angezeigt werden oder nicht.

Dazu erstelle ich mir immer eine Variable "_debugMode", die ich in der „App.onStart“ Methode abhängig vom Wert eines QueryString Parameters setze.

Set(_DebugMode,Param("debug")="true");

Danach setzte ich die Sichtbarkeit aller entsprechenden Labels und Controls, die ich nur im Debug Modus sehen möchte, auf den Wert von _DebugMode.

Wenn ich die App nun speichere, im Browser aufrufe und hinten an die URL ein "&debug=true" mit anhänge, werden mir die Debug Informationen in den Labels angezeigt.

Das ist nur eine rudimentäre Lösung, die man noch durchaus erweitern kann. Normalerweise benutze ich zum Beispiel hier keinen einfachen Labels zur Darstellung der Informationen, sondern erstelle mir eine eigene "Debug Komponente", die mir die Werte dann gleich auch hübsch formatiert darstellt. Oder ich habe einen eigenen Screen, auf dem all diese Werte gebündelt sind und auf den ich in der App nur über einen Button komme, der abhängig vom Debug Modus versteckt ist.

3) Mehrsprachigkeit

Die „App.OnStart“ Methode kann man auch noch für viele andere Dinge benutzen. Wenn wir eine App in mehreren Sprachen bereitstellen wollen, dann könnten wir das auch über Variablen tun, die wir abhängig von der gesetzten Browsersprache beim Start setzen. Ich persönlich tendiere hier aber dazu, dieses nicht über einzelne Variablen zu tun, sondern hier dann eine etwas komplexere Datenstruktur aufzubauen

Set(_Resources,
        If(Language()="de-DE" Or Language()="de-DE",
            {
               TITLE       : "Meine Applikation",
               LABEL_SAVE  :"Speichern",
               LABEL_CANCEL:"Abbrechen"     
            },
            {
                TITLE       :"My Application",
                LABEL_SAVE  :"Save",
                LABEL_CANCEL:"Cancel"     
            }
        )
    );

Der Effekt hiervon ist nun, dass wir eine _Ressourcen Variable haben, die verschiedene Attribute enthält. Diese haben in unserem Beispiel normalerweise englische Werte, es sei denn die Browsersprache ist deutsch. Auf verschiedenen Elementen in der Applikation können wir uns nun statt auf einen fixen Text auf die entsprechenden Werte in der _Ressources Variable beziehen.

Denselben Effekt könnten wir auch mit vielen einzelnen Variablen erzielen. Im Regelfall benutzen wir aber bei einer mehrsprachigen Applikation sehr viele Elemente, die lokalisiert werden müssten. Damit ich eine gewisse Übersichtlichkeit bei der IntelliSense im PowerApps Studio behalte, tendiere ich zu dem beschriebenen Vorgehen und benutze die eine _Resources Variable als eine Art Namespace.

Das Vorgehen lohnt sich auch an anderen Stellen. Wenn Sie etwa recht viele Variablen haben, die das Aussehen ihre Applikation steuern (siehe Abschnitt 1), dann kann es durchaus vernünftig sein, diese etwa in einer "_Styles" Variablen zu kapseln.

4) Variable Navigation

Kommen wir nun zur Navigation. Falls ihre Applikation mehr als einen oder zwei Screens benutzt, kann das Handling einer gleichbleibenden Navigation auf allen Seiten schnell aufwändig werden. Wenn sie auf jedem Screen Buttons platziert haben, über die sie auf alle anderen Screens gelangen können, dann müssen Sie nun jeden einzelnen Screen anpassen und um einen Button erweitern. Neben dem Aufwand kann es hier auch recht schwierig sein, ein über alle Screens einheitliches "Look&Feel" aufrechtzuerhalten.

Nehmen wir mal an, dass ich 2 Bildschirme namens "MainScreen" und "Screen2" habe.

Dann definiere ich mir meistens in der App.OnStart Methode eine Collection "_Navigation" mit den zwei Bildschirmen

Set(_Navigation, Table(
            { Name:"Haupt Bildschirm", Screen:MainScreen },
            { Name:"Bildschirm 2", Screen:Screen2 }
            )       
    );

Danach erstelle ich eine Galerie, die als Datenquelle diese Collection hat und füge in das Galerie Template einen Button ein. Den Text dieses Buttons setze ich auf "ThisItem.Name" und die "OnSelect" Eigenschaft auf "Navigate(ThisItem.Screen)".

Nachdem ich diese Galerie dann grafisch so angepasst habe, wie ich sie haben möchte, kopiere ich Sie auf jeden Bildschirm und habe damit eine einheitliche Navigation. Alternativ kann ich mir dafür auch eine eigene Komponente definieren.

Wenn ich jetzt einen dritten Bildschirm "Screen3" bekomme, dann kann ich ihn einfach in der App.OnStart Methode mit einfügen. Er taucht nun automatisch in der Navigation aller Seiten auf.

Set(_Navigation, Table(
            { Name:"Haupt Bildschirm", Screen:MainScreen },
            { Name:"Bildschirm 2", Screen:Screen2 },
            { Name:"Bildschirm 3", Screen:Screen3 },
            )       
    );

5) Deeplinks

Manchmal wäre es bei der Navigation gut, wenn ich schon beim Aufrufen der App über einen Link direkt auf einen Bildschirm gelangen könnte. Wenn wir die Navigation schon als eine Variable definiert haben, ist das sehr einfach und effizient möglich.

Hierzu erweitern wir zunächst die Navigations-Variable aus dem letzten Kapitel und fügen bei allen Screens, bei denen ein „Deeplinking“ möglich sein soll, ein neues Attribut "ScreenId" ein.

Set(_Navigation, Table(
            { Name:"Haupt Bildschirm", Screen:MainScreen },
            { Name:"Bildschirm 2",     Screen:Screen2,    ScreenId:"screen2" }
            )       
    );

Danach fügen wir den folgenden Funktionsaufruf nach der Definition der Navigationsvariable in die „App.StartScreen„ Methode ein.

If( 
    !IsBlank(Param("screen")),
    With(
        {
            SelectedScreen:LookUp(
                _Navigation,
                !IsBlank(ScreenId) && ScreenId = Param("screen")
            )
        },
        SelectedScreen.Screen
    ),
    NormalerStartScreen
)

Dieser Aufruf prüft zunächst, ob der QueryString Parameter "screen" beim Aufruf der App mit angegeben wurde. Falls ja, dann setzt er die Variable "SelectedScreen" mit dem Bildschirm aus der Navigationsvariablen, bei dem die ScreenId mit dem übergebenen Parameter übereinstimmt. Danach wird eine Navigation auf den gefundenen Screen durchgeführt.

Wenn wir in unserem Beispiel an die URL der aufgerufenen PowerApp ein "&screen=screen2" mit anfügen, startet damit die Applikation auf "Bildschirm 2".

Download

Sie können sich meine PowerApps Starter App hier herunterladen.

Neue Governance Möglichkeiten für die PowerPlattform

Sven Sieverding — Tue, 16 Mar 2021 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2021-03-16/

Wussten Sie, dass man mit Microsofts Power Plattform auch auf Ressourcen und Datenbanken im lokalen Firmennetz zugreifen kann? Das ist sogar ganz einfach, denn dazu muss man nur auf einem Windows-Rechner im lokalen Netz das Gateway installieren, dieses bei O365 registrieren und für alle Kollegen freigeben, die dadurch auf lokale Daten zugreifen wollen und fertig.

Der eine oder andere von Ihnen wird sich aber nun die Frage stellen: "Klingt einfach, aber wo definiere ich denn, auf welche Ressourcen genau (also auf welches Netzlaufwerk und auf welche Datenbank) im lokalen Netz dann zugegriffen werden kann?".

Die Frage ist gut, denn im Moment können am Gateway selbst nur die Typen bereitzustellender Ressourcen (etwas Datenbank oder Netzlaufwerk) konfiguriert werden, nicht welche genau dieses sein sollen. Das entscheidet später der Anwender innerhalb der Powerplattform. Damit könnten ggf. Benutzer auch über das Netz auf Datenbanken zugreifen, auf die sie von außerhalb des lokalen Netzes eigentlich nicht zugreifen können sollten. HR Datenbanken sind häufig ein Beispiel dafür.

Die einzige Möglichkeit, sich davor zu schützen war bisher, das Gateway nur auf einem Rechner zu installieren, der durch Firewalls vom Rest des Netzes so abgetrennt ist, dass nur Zugriff auf die gewünschten Datenbanken möglich ist. Das könnte aber schon ein mittelgroßes Infrastrukturprojekt werden und ist mit Sicherheit weit vom "Low Code" Gedanken entfernt.

Twitter als anderes Beispiel

Wenn Sie ansonsten etwa verhindern wollen, dass ihre Mitarbeiter Workflows bauen, die Daten automatisiert bei Twitter posten, dann können Sie natürlich problemlos einfach den gesamten Twitter Konnektor deaktivieren. Die Marketing Abteilung kann dann nun aber auch keinen eigenen Flow mehr bauen, der Daten von Twitter ausliest und aus denen dann automatisiert Marketing Informationen gewonnen werden können. Der Konnektor ist als Ganzes deaktiviert und steht für dieses eigentlich sehr sinnvolle Anwendung nicht mehr zur Verfügung.

Neues von der Ignite

Und genau für diese Anwendungsfälle wurden auf der Ignite endlich neue Lösungsmöglichkeiten vorgestellt. Sie werden in den nächsten Monaten auf alle Tenants ausgerollt.

Endpoint Filtering

Zum einen haben wir da das "Endpoint Filtering". Damit kann im PowerPlattform Admin Center zentral für eine Umgebung definiert werden, auf welche Ressourcen/URLs/Datenbanken jeder einzelne Konnektor zugreifen kann oder auch nicht.

Die oben beschriebene Herausforderung mit dem Zugriff auf lokale Datenbanken wird damit sicherlich lösbar sein. Wir definieren einfach die Datenbanken, auf die unsere Mitarbeiter im lokalen Netz zugreifen dürfen und die anderen sind gesperrt.

Damit haben wir dann auch gleich andere, "unautorisierte" Cloud-Datenbanken für unsere Benutzer gesperrt. Deren Adressen führen wir im Admin Center einfach nicht auf.

Connector Action Controls

Für den "Twitter" Anwendungsfall hilft uns das aber nicht viel. Twitter hat nur eine Adresse, die wir entweder sperren oder nicht sperren können.

Aber eigentlich würde es uns in diesem Anwendungsfall auch schon reichen, wenn wir über den Konnektor nur Lesen könnten und das Posten von neuen Tweets deaktiviert werden würde.

Genau dieses erlauben uns nun die neuen "Connector Action Controls". Hiermit können wir detailliert die Aktionen jedes einzelnen Konnektors für die User in unserer Umgebung aktivieren und deaktivieren und damit sehr granular bestimmen, welche Aktionen durchgeführt werden dürfen.

Tenant Isolation

Schließlich haben wir da dann noch die "Tenant Isolation". Hiermit haben wir nun die Möglichkeit, den Zugriff von und zu Tenants etwa der Konkurrenz oder eines Dienstleisters einzuschränken.

Mit aktivierter "Tenant Isolation" für eine bestimme Adresse können unsere Benutzer per Power Plattform nicht mehr auf die Ressourcen des anderen Tenants zugreifen. In die andere Richtung gilt das auch, da nun auch Mitarbeiter des anderen Tenants nicht mehr per Power Plattform auf Ressourcen unseres Tenants zugreifen können - selbst wenn Sie über die Oberfläche dafür freigeschaltet sind.

Damit können wir dann effektiv unterbinden, dass etwa Dienstleister eigene Powerapps auf unseren Ressourcen aufbauen und einfach bestimmte Auswertungen fahren können.

Wann kommt das?

Im Moment (16.03.2021) sind die drei Einstellungen noch nicht verfügbar, das wird sich aber in den nächsten Wochen ändern.

Die aktuelle Seite in Teams teilen

Sven Sieverding — Sun, 07 Feb 2021 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2021-02-07/

Es ist ja ganz praktisch, wenn ich einen interessanten Artikel, den ich im Netz gefunden habe, auf einfache Art mit etwa meinen Kollegen teilen kann. Falls seine Website haben und diese Funktionalität für Microsoft Teams anbieten wollen, dann geht dieses zum Glück recht einfach.

Öffnen Sie einfach die folgende Website und scrollen Sie nach unten

https://developer.microsoft.com/en-us/microsoft-teams/share-to-teams

Wählen Sie zunächst den Button-Stil und konfigurieren Sie einige Einstellungen.

Danach können Sie sich ein "Code-Schnipsel" runterladen, welches Sie einfach an der entsprechenden Stelle ihrer Website platzieren können.

Damit wird der Teilen-Knopf dann auf Ihrer Seite eingefügt. Beim Klick darauf wird Teams dann aus den Metadaten ihrer Website automatisch den Titel, ein Bild und die Beschreibung erzeugen.

Das funktioniert soweit einwandfrei.... In den meisten Fällen.

Falls Sie den Teilen-Knopf allerdings dynamisch mittels Javascript einfügen oder wie ich innerhalb einer React-Applikation, dann wird das leider nicht so einfach funktionieren. Glücklicherweise gibt es da aber noch einen anderen Weg.

Das Teilen einer Website in Teams lässt sich nämlich auch dadurch bewerkstelligen, dass der Benutzer eine bestimmte URL von Microsoft aufruft (Das ist das, was das Codeschnipsel im Hintergrund auch tut).

https://teams.microsoft.com/share?href=<URL>&referrer=<Domäne>
// <URL> Die Url zu der zu verlinkenden Seite
// <Domäne> Die "Domäne" ihre Seite. In meinem Fall ist das "365Knoten.de"

Danach kann der Benutzer dann dort die Seite in Teams teilen.

Wenn man dann den Aufruf dieser "Teilen" Seite im Javascript noch mittels "window.open" in einem Popup öffnet, dann kommt man in React zu folgender Implementierung.

	  
        <button
          onClick={()=>{
            window.open(`https://teams.microsoft.com/share?href=${articleurl}&referrer=365Knoten.de`,"In Teams teilen","width=800,height=600,status=yes,scrollbars=yes,resizable=yes");
          }}
          <svg .... ></svg>
        </button>

Das funktioniert wunderbar. Probieren Sie es doch gleich unten aus.

Wie breche ich alle laufenden Runs zu einem Flow ab?

Sven Sieverding — Tue, 12 Jan 2021 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2021-01-12/

Ich kam heute in die Verlegenheit, hunderte Ausführungen eines Flows abbrechen zu müssen. Über die Oberfläche kann man das zwar für jede einzelne Ausführung einzeln machen, das ist aber wenig effizient. Auch per Powershell scheint es keine Möglichkeit zu geben. Daher habe ich das Problem "Mehrere Ausführungen eines Flows auf einmal abbrechen" folgendermaßen gelöst.

Ich bin auf die Übersichtsseite der Ausführungen des Flows ("All Runs") gewechselt

und habe dann dort oben rechts in dem Dropdown "Running" ausgewählt, um mir alle laufenden Instanzen anzuzeigen.

Hier habe ich die Entwicklerkonsole im Browser geöffnet (F12) und die folgenden Befehle eingetragen:

	  
// JQuery Nachladen
var jq = document.createElement('script');
jq.src = "https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js";
document.getElementsByTagName('head')[0].appendChild(jq);

	  
jQuery.noConflict();

	  
// Das Alert Fenster immer automatisch bestätigen	  
confirm = function () {return true;};

	  
// In einem Intervall von 2 Sekunden immer den obersten Eintrag auswählen und danach auf "Cancel" drücken
setInterval(function () {
	jQuery('.ms-Button.ms-Button--default:contains("Show more")').last().click();
	jQuery(".fl-StatusInCell[title='Running']").parent().parent().find('.ms-DetailsRow-cell').first().click();
	jQuery('button[name="Cancel"]').click();
},2000);

Danach klickt der Browser in einer Schleife automatisch immer auf das erste Element in der Liste und bricht den Eintrag ab.

Nach einer halben Stunde war damit mein Problem behoben.

Kanal-Kalender in MS Teams

Sven Sieverding — Sat, 09 Jan 2021 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2021-01-09/

Mir ist schon häufig die Anforderung untergekommen, dass Kunden einen Kalender innerhalb eines Teams Kanal haben wollten. Das macht Sinn. Ein Kanal kann durchaus ein eigenes Thema sein und darin kann es notwendig sein, Termine vorzuhalten.

Ein umständlicher Weg: SharePoint Kalender und SPFX Webpart

Mangelns einer entsprechenden Registerkarte von Microsoft habe ich in den Fällen dann häufig auf das PnP Sample Repository zugegriffen und eine der bestehenden Kalenderlösungen von dort angepasst.

Um das zu tun musste ich diverse händische Schritte durchführen, die ich hier mal am Beispiel des "js-modern-calendars" bescheibe:

Zunächst muss das Repository geklont und gebaut werden:

# Das Sample Repository clonen
git clone https://github.com/pnp/sp-dev-fx-webparts
# In das Verzeichnis eines Samples wechseln.
cd sp-dev-fx-webparts\samples\js-modern-calendar
# Die benötigen Javascript-Libraries installieren
npm install
# Die Lösung bauen, bundeln und paketieren
gulp build --ship
gulp bundle --ship
gulp package-solution --ship

Danach steht im Ordner "SharePoint/Solution" eine ".sppkg" Datei zur Verfügung, die nun wiederum im SharePoint-App Katalog des Tenants bereitgestellt werden muss (wenn man die Rechte dafür hat).

Danach muss das Webpart in der Site Collection des Teams installiert (Site-Contents -> Neu -> App), eine neue Modern Page erstellt und das Webpart dort eingefügt werden. Jetzt kann auf der SharePoint Seite noch eine Kalender-Liste erstellt werden (ebenfalls über Site-Contents -> Neu -> App) und dieser Kalender im Webpart verknüpft werden.

Schließlich ist es dann möglich, im Teams über eine Registerkarte der Typs "Sharepoints" die gerade erstellte Seite als neue Registerkarte im gewünschten Kanal einzufügen.... und "schon" ist der Kanal-Kalender fertig.

Viel einfacher: Die neue Teams Registerkarte von Microsoft

Glücklicherweise gibt es da Neuigkeiten von Microsoft. Jeder in einem Team entsprechend berechtige User kann nun in einem Kanal eine Registerkarte des Typs "Kanalkalender" hinzufügen.

Nun steht dem Team in diesem Kanal ein vollwertiger Kalender zur Verfügung. Hier kann ich Termine erstellen und auch weitere Personen einladen, ihre Outlook Terminkalender sehen und Kanal Besprechungen erstellen.

Dieser Kalender ist im Gegensatz zur vorherigen Lösung keine simple SharePoint-Liste sondern greift auf den O365 Gruppenkalender zu, der hinter dem Team liegt. Ich stelle also implizit Ereignisse in dem Gruppenkalender, in den verschiedenen Registerkarten der Kanäle werden mir aber nur die Termine angezeigt, die für diesen Kanal relevant sind. Wenn man sich also im Outlook den Kalender der Gruppe ansieht, dann wird man dort die Termine alle Kanäle des Teams finden. Das finde ich persönlich aber eigentlich auch garnicht schlecht, da man dadurch einen Überblick bekommt, welche Termine denn generell im Team angesetzt sind.

Low-Code-Programmierung: Software selbst bauen

Sven Sieverding — Wed, 25 Nov 2020 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2020-11-25/

Wenn Sie sich ein wenig mit Programmierung auskennen, dann werden Ihnen Begriffe wie IDE (Integrated Software Development Environment), Compiler und Quellcode sicherlich etwas sagen. Für Nicht-Fachleute ist wichtig zu wissen: Um Quellcode zu entwickeln, nutzen Programmierer*innen klassischerweise einen Texteditor oder Entwicklungsumgebungen, die ihnen die wichtigsten Werkzeuge unter einer Oberfläche zur Verfügung stellen. Der Code wird mit Hilfe eines Compilers aus der verwendeten Programmiersprache in Maschinencode übersetzt. Der Computer kann das Programm dann ausführen.

Klingt einfach? Ist es nicht.

Klassisches Programmieren ist anspruchsvoll und braucht Zeit: Ein Software-Developer muss die Anforderungen des Fachbereichs verstehen, die Programmiersprache sprechen und deren Eigenheiten kennen. Teile des Programms beschäftigen sich beispielsweise nur mit dem Speichern der Daten auf der Festplatte, mit der Oberfläche an sich oder mit dem Netzwerk. Diese Elemente müssen oft für jede Anforderung einzeln angepasst werden. Das Ergebnis muss der Entwickler testen, einchecken und auf einem Testsystem deployen, wo es von einem Tester getestet wird. Danach kann die Änderung auf das Produktivsystem eingespielt und vom Fachbereich benutzt werden.

Alternative: Low-Code und No-Code

Es gibt aber eine Alternative. Ein Fachbereich mit ein paar IT-affinen Kollegen kann für eine konkrete Anforderung selbst eine kleine Applikation entwickeln – und zwar ganz ohne zu programmieren. Zu diesem Zweck gibt es Low-Code- oder No-Code-Plattformen. Auf denen kann man ohne große Programmierkenntnisse kleine Applikationen zusammenbauen.

Sie basieren häufig auf grafischen Elementen, die mit der Maus zu neuen Funktionen angeordnet werden können. Viele Nebenfunktionen, wie etwa die Logik zum Dateispeichern, Netzwerkzugriffe oder ähnliches, um die sich normalerweise ein Entwickler kümmert, ist häufig für den Benutzer wegabstrahiert.

Nach einer kurzen Einarbeitung kann sich damit jeder relativ schnell eigene Applikationen zusammenstellen. Die sind zwar nicht ganz so schnell oder skalierbar wie eine von Software-Entwicklern erstellte Applikation. Dafür sind sie schneller erstellt und können – falls nötig – tagesaktuell vom Fachbereich selber angepasst werden.

Solche Low-Code-Systeme gibt es schon seit vielen Jahren. Beispiele dafür sind Lotus Notes und SharePoint, aber auch das in vielen Firmen eingesetzte Microsoft Access. Im Zeitalter der Cloud gibt es mehr und mehr neue Anbieter für solche Plattformen. Beispielsweise hat sich Nintex Workflow von einer reinen SharePoint-Lösung zu einer webbasierten Automatisierungsplattform weiterentwickelt. Ähnliches gilt für IFTTT ("If This Than That"), einer sehr populären Plattform, um persönliche Prozesse im Internet und für das Smart-Home zu automatisieren.

Microsofts Power-Plattform: Komplexe Apps leicht umsetzen

Microsoft hat im Rahmen seiner Power-Plattform eine mächtige Basis geschaffen, um auch sehr komplexe Applikationen mit der Low-Code-Methode umzusetzen. Zum einen gibt es Power Apps. Mit dieser Applikation können grafische Oberflächen und ganze Applikationen zusammengeklickt werden, die sich dann entweder als Webseite, als Applikation auf dem Computer oder auch als Handy-App ausführen lassen.

Der Citizen-Developer – so nennen Fachleute den Low-Code-Entwickler – muss zur Erstellung im Wesentlichen Excel-Formeln kennen und ein grobes Verständnis für Datenquellen und den umzusetzenden Prozess haben.

Mit einer weiteren Anwendung, Power Automate, können Hintergrundprozesse erstellt werden. Mittels eines grafischen Editors kann man den Prozess als Ablaufdiagramm generieren, das Visio ähnelt. Die Anzahl der verwendbaren Aktionen ist hier gewaltig und geht weit über die Microsoft Produkte heraus. Sie können beispielsweise viele weitere webbasierte Dienste wie Salesforce oder Googlemail in Ihre Prozesse einbeziehen, oder auch Ihre hauseigenen Systeme.

Außerdem enthalten ist Power BI, AI Builder und Power Virtual Agents, mit denen sich Dashboards, Künstliche Intelligenzen und Chatbots erstellen und in die Applikationen integrieren lassen.

Was könnte ich damit tun?

Es gibt zahllose mögliche Anwendungsfälle für die Power Plattform. Wenn Sie beispielsweise eine Excel-Datei haben, in die ihre Kolleg*innen Daten eintragen sollen, dann könnten Sie mit Power Apps in weniges Klicks eine einfache Eingabemaske dafür erzeugen. Die kann sogar als App auf ihrem Handy funktionieren. Wenn Sie darüber benachrichtigt werden wollen, dass ein Kollege etwas geändert hat, dann können Sie einen Power Automate Flow erzeugen, der Ihnen die Änderungen per Mail schickt.

Über die Power App könnten Sie auch Fotos von Belegen hochladen. Der AI Builder kann Ihnen automatisch aus den Belegen Informationen extrahieren und in die Excel-Datei eintragen. Oder Sie wagen sich an noch komplexere Anforderungen…

Klingt wunderbar. Wo ist der Haken?

Low-Code Applikationen bergen aber auch Gefahren – dazu eine kleine Anekdote.

Ein Logistik-Unternehmen setzte in seiner Kollaborationssoftware eine No-Code-Workflowkomponente ein. Damit konnten sich die Mitarbeitenden für ihre Dokumente selbst automatische Prozesse erstellen. Das Unternehmen hatte einen Hauptstandort, an dem an mehreren Toren LKWs rückwärts andockten, die Paletten entladen und just-intime auf andere LKWs verladen wurden. Alles funktionierte wunderbar.

Nach einiger Zeit fuhr die IT nach Absprache mit den Fachbereichen den Server herunter, auf dem auch die Kollaborationssoftware lag, um einen Patch einzuspielen. Das sei doch kein Problem, denn dort liege ja „nur“ ein System für interne Kommunikation, das auch mal zwei Stunden nicht erreichbar sein könne.

Als die IT-Kollegen wegen eines dringenderen Problems von dem Patch abgezogen wurden, brach alles zusammen: Keines der Tore ließ sich mehr öffnen. Die LKWs konnten nicht mehr entladen werden. Das Unternehmen hatte einen großen finanziellen Schaden.

Später wurde die Ursache an einer nicht erwarteten Stelle gefunden: Ein Kollege aus der Fachabteilung hatte den Genehmigungsprozess zum Öffnen der Tore durch dieses Kollaborationstool geleitet (weil das so schön einfach ging). Davon wusste aber keiner. Dass der Kollege mittlerweile nicht mehr für das Unternehmen arbeitete, machte das Ganze noch komplizierter.

Schatten-IT: Wie vermeide ich sie?

Dieses Problem nennt sich Schatten-IT und ist eines der größten Probleme bei No-Code- oder Low-Code-Lösungen. In den Fachbereichen können Applikationen entstehen, von denen die IT zum einen nichts weiß und dementsprechend nicht in ihre Betriebsplanung aufnehmen kann. Zum anderen hat auch häufig in den Fachabteilungen niemand den Blick auf erforderliche, vermeintlich nicht-funktionale Anforderungen an Applikationen wie etwa Dokumentation, Datenschutz oder andere Policies und Nebenbedingungen. Die gewährleistet normalerweise die IT.

Schatten-IT lässt sich durch eine enge Kommunikation zwischen Fachbereich und IT-Abteilung vermeiden. Dem Fachbereich muss bewusst sein, welche Applikationen er gefahrlos selbst bauen kann, ohne Unternehmensrichtlinien oder gar Gesetzte zu verletzen. Die IT sollte von allen Applikationen wissen, die der Fachbereich entwickelt hat.

Die Lösung ist häufig eine Key-User-Regelung: In den Fachabteilungen werden bestimmte Kolleg*innen gezielt geschult und so in die Lage versetzt, Low-Code-Applikationen unternehmenskonform zu erstellen und zusammen mit der IT zu betreiben. Die IT kann dann auch den Bedarf nach neuen Applikationen von diesen Key-Usern aufnehmen und eventuell in neue, zentrale Systeme übernehmen.

Manchmal sind weniger Straßen mehr

Sven Sieverding — Mon, 06 Jul 2020 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2020-07-06/

Mittlerweile beginnt das Leben – trotz Corona – wieder gewohnte Wege einzuschlagen. So stand ich neulich abends in der Bremer Überseestadt im Stau und stellte mir aus purer Langeweile einige Fragen: Warum ist das hier immer so – das kann doch nicht nur an der Brücke liegen? Wieso staut sich der Verkehr von einer Ampel zur nächsten? Gibt es einfach zu viele Kreuzungen? Und ginge das vielleicht schneller, wenn da weniger wären?

Tatsächlich gibt es mit dem „Braess Paradoxon“ ein Gedankenspiel aus der Spieltheorie, das – vereinfacht gesagt – zeigt, dass mehr Straßen manchmal zu längeren Reisezeiten führen können. Und das liegt daran, dass alle Verkehrsteilnehmenden immer die Option wählen, die für sie selbst am vorteilhaftesten ist – und nicht die, die für alle am besten wäre. Möchten Sie eine der Grundlagen der Spieltheorie am Beispiel „Feierabendverkehr“ kennenlernen?

Die Ausgangssituation

Stellen Sie sich vor, es gäbe zwei Städte, Stadt A und Stadt D.

Genau mittig zwischen den beiden Städten gäbe es ein sehr schwer zu überwindendes Hindernis, zum Beispiel einen Berg. Auf beiden Seiten des Hindernisses lägen direkt daneben die beiden Orte B und C. Von der Stadt A kann man nun über zwei mögliche Routen zur Stadt D gelangen.

Von A kann man über die nördliche Route mit der Autobahn 1 zu Ort C kommen, diese Autobahn umfährt das Hindernis sehr großflächig und ist mehrspurig ausgebaut. Danach kommt man von Ort "C" über eine sich windende schmale Landstraße 1 zu Stadt D. Auf der Landstraße gibt es häufig Stau, weil sie teilweise nicht für das Verkehrsaufkommen ausgebaut ist.
Auf der anderen Seite gelangt man über die südliche Route über die Landstraße 2 zu Ort B. Genauso wie auf der Landstraße 1 kommt es aber auch hier häufig zu Staus. Danach kann man von B über die Autobahn 2 nach D gelangen. Genauso wie Autobahn 1 führt diese großflächig am Hindernis vorbei und ist gut mehrspurig ausgebaut.

Bei den beiden Autobahnen dauert die durchschnittliche Reisezeit immer 45 Minuten und ist nicht von der Anzahl der darauf fahrenden Autos abhängig, da das Hindernis großräumig umfahren wird.

Bei den beiden Landstraßen ist die Reisezeit abhängig von der Anzahl der darauf fahrenden Autos: Die Straßen sind schmal und schlängeln sich mit vielen Kurven durch die Landschaft. Im Durchschnitt errechnet sich die benötigte Zeit aus der Anzahl der Autos geteilt durch 100.

Egal ob nördliche oder südliche Route: Man braucht für die gesamte Reise (𝒙/𝟏𝟎𝟎+𝟒𝟓)𝒎𝒊𝒏… also zum Beispiel 50 Minuten bei 500 Autofahrern oder 65 Minuten bei 2000 Fahrern.

Zur „Rush Hour“ auf der nördlichen und südlichen Route

Stellen Sie sich vor, dass zur abendlichen Rushhour 4000 Autos von Stadt A zurück nach Stadt D wollen. Ein Teil der Fahrer wird die nördliche und der andere die südliche Route wählen. Da die Situation auf den Landstraßen die Reisedauer bestimmt, werden entweder die Fahrtzeiten identisch sein, weil jeweils ähnlich viele Fahrzeuge unterwegs sind, oder eine Route ist schneller, da dort weniger fahren. Das spricht sich dann aber mit Sicherheit herum, und am nächsten Tag wechseln einige Fahrer auf die vermeintlich schnellere Route.

Dieses System wird über eine gewisse Zeit hin- und herschwingen, bis die Anzahl der Fahrzeuge auf beiden Strecken mehr oder weniger identisch ist. Dieses Gleichgewicht ist in diesem System die bestmögliche Variante für alle Teilnehmer. In der Spieltheorie nennt man es das "Nash-Gleichgewicht".

In unserem Beispiel fahren also jeweils 2000 Fahrzeuge über die nördliche und ebenso viele über die südliche Route. Alle brauchen im Durchschnitt 65 Minuten (𝟐𝟎𝟎𝟎/𝟏𝟎𝟎+𝟒𝟓)𝐦𝐢𝐧 = (𝟐𝟎+𝟒𝟓)𝐦𝐢𝐧=𝟔𝟓 𝒎𝒊𝒏).

Eine vermeintliche Verbesserung

Um die Zeit zu verkürzen, wird eine direkte Straße durch das Hindernis hindurch gebaut.

Mal angenommen, es kostet keine Zeit, über diese neue Straße X zu fahren, dann haben alle Fahrzeuge, die von A nach D wollen, auf einen Schlag zwei weitere Routen zur Verfügung:

Sie können nun die komplette Strecke über die beiden Autobahnen A1 und A2 zurücklegen (A1-X-A2) und brauchen dafür 90 Minuten. (𝟒𝟓𝐦𝐢𝐧+𝟒𝟓𝐦𝐢𝐧=𝟗𝟎 𝒎𝒊𝒏)
Oder sie können die ganze Strecke über die beiden Landstraßen L1 und L2 fahren (L2-X-L1) und benötigen 𝒙𝟏/𝟏𝟎𝟎𝐦𝐢𝐧+𝒙𝟐/𝟏𝟎𝟎𝒎𝒊𝒏 (x1 = Anzahl der Fahrer über die L1; x2 = Anzahl der Fahrer über die L2).

Wie werden sich die Pendler verhalten, die vorher die nördliche oder südliche Route gefahren sind und dafür 65 Minuten gebraucht haben?

Über die Autobahnen A1-X-A2 wird sicherlich niemand fahren, da die Route in jedem Fall 25 Minuten länger dauert als die bisherige nördliche oder südliche Route.
Alle Fahrer könnten wie gehabt in 65 Minuten über die „alte“ nördliche oder südliche Route fahren. Aber das wird eher nicht passieren, denn…
Sehr viel wahrscheinlicher wird wenigstens ein Fahrer etwa der nördlichen Route begreifen, dass er nun statt über die A1 auch über die L2 und dann wie gehabt die L1 fahren kann und damit nur ca. 40 Minuten braucht (𝟐𝟎𝟎𝟎/𝟏𝟎𝟎𝐦𝐢𝐧+𝟐𝟎𝟎𝟏/𝟏𝟎𝟎𝐦𝐢𝐧=𝒄𝒂.𝟒𝟎 𝒎𝒊𝒏).

Ein Zeitgewinn von satten 25 Minuten!

Andere Fahrer auf der nördlichen Route werden das auch schnell begreifen und sehr bald folgen 499 weitere dem Beispiel. Dann dauert die Fahrt schon 45 Minuten. (𝟐𝟎𝟎𝟎/𝟏𝟎𝟎𝐦𝐢𝐧+𝟐𝟓𝟎𝟎/𝟏𝟎𝟎𝐦𝐢𝐧=𝟐𝟎 𝒎𝒊𝒏+𝟐𝟓𝒎𝒊𝒏=𝟒𝟓 𝒎𝒊𝒏).
Je mehr Autofahrer von der nördlichen Route auf die L2 wechseln, desto länger wird aber nun hier die Fahrtzeit: Für die „klassische“ südliche Route werden das 70 Minuten, da auf der L2 nun mehr Verkehr ist (𝟐𝟓𝟎𝟎/𝟏𝟎𝟎𝐦𝐢𝐧+𝟒𝟓 𝐦𝐢𝐧=𝟐𝟓 𝒎𝒊𝒏+𝟒𝟓𝒎𝒊𝒏=𝟕𝟎 𝒎𝒊𝒏).
Durch diesen Zeitverlust werden sicher einige Fahrer von dieser Route auf die L2-X-L1-Route wechseln. Das führt nun wiederum für andere zu einer Verschlechterung der Fahrzeit auf der nördlichen Route, was dort wieder Fahrer veranlasst, auf die L2-X-L1-Route zu wechseln....

Ein Teufelskreis!

Das Nash-Gleichgewicht in diesem neuen System tritt erst dann auf, wenn alle Fahrer über die Route L2-X-L1 fahren. In unserem Beispiel dauert das 80 Minuten! (𝟒𝟎𝟎𝟎/𝟏𝟎𝟎𝐦𝐢𝐧+𝟒𝟎𝟎𝟎/𝟏𝟎𝟎 𝐦𝐢𝐧=𝟒𝟎 𝒎𝒊𝒏+𝟒𝟎𝒎𝒊𝒏=𝟖𝟎 𝒎𝒊𝒏)

Das Paradoxe

Und hier liegt das „Braess-Paradoxon“: Bevor die neue Straße zwischen B und C gebaut wurde, lag die durchschnittliche Reisezeit bei 65 Minuten. Nach dem Bau der neuen Straße bei 80 Minuten. In diesem Beispiel wären alle Verkehrsteilnehmer ohne die neue Straße X schneller am Ziel.

Menschen wählen eher die Option, die für sie selbst am günstigsten ist – in diesem Fall eine Ersparnis von wenigen Minuten – als sich zum Besten Aller zu verhalten.

Dieses Gedankenspiel erklärt aber nicht nur die Theorie, sondern auch, warum in der Praxis manchmal nach der Schließung von großen Verkehrsadern das befürchtete Chaos ausblieb:

In Seoul war lange Zeit der „Cheonggyecheon“ Highway eine wichtige Verkehrsader durch das Zentrum der Stadt. Im Jahr 2005 wurde er komplett entfernt und in ein grünes Naherholungsgebiet umgewandelt. Das von manchen befürchtete Verkehrschaos blieb aus, tatsächlich verbesserte sich die Verkehrssituation insgesamt.
1990 hat die zeitweilige Schließung der 42. Straße in New York zu einer generellen Verbesserung des Verkehrsflusses geführt.
In Stuttgart kam es 1969 nach Ausbau des Straßennetzes rund um den Schlossplatz zu Verkehrsproblemen, die erst wieder durch die Umwandlung eines Teils der Königsstraße in eine Fußgängerzone abgemildert wurden.

Welche Straße muss weg?

Mit genügend Computerleistung könnten wir vorausberechnen, wie Autofahrer ihr Verhalten ändern würden, wenn wir aus einem komplexen Straßennetz eine einzelne Straße entfernen. Die Kunst besteht aber darin herausfinden, welche Straße – in meinem Fall in der Überseestadt – überhaupt zu entfernen wäre, damit ich und viele andere nicht weiter im Stau stehen müssen. Das allerdings würde uns schnell an physische Grenzen bringen: Wir haben zur Berechnung hiervon keinen wirklich effizienten Algorithmus und müssen alles simulieren. Wenn wir alle Kombinationen möglicher Straßensperrungen in einer Stadt einfach durchprobieren wollten, dann wären das bei einem Straßennetz von „nur“ 80 Straßen theoretisch aber schon mehr zu prüfende Kombinationen (2 hoch 80) als es Sterne im Universum gibt (10 hoch 22) – Nicht machbar innerhalb eines Menschenlebens mit heutigen Rechnerkapazitäten.

Bei der Geschwindigkeit, mit der diese aber im Moment wachsen, ist das vielleicht aber nur eine Frage der Zeit. Vielleicht aber auch nicht.

Bevor ich also das nächste Mal zum Feierabend im Stau stehe, überlege ich mir also am besten mit gesundem Menschenverstand eine Alternative. Vielleicht fahre ich doch lieber mit dem Rad…

Teams erstellen mit dem PNP Provisioning Schema

Sven Sieverding — Wed, 01 Apr 2020 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2020-04-01/

Es ist eigentlich eine gute Idee, neue Microsoft Teams nach einem bewährtem Schema anzulegen, sobald sich in der jeweiligen Organisation ein solches durchgesetzt hat. Ich zum Beispiel bin der Meinung, dass jedes Team einen "Lustiges und Ballons" Kanal braucht, in dem die Teammitglieder sich auch mal zu kurzweiligen anderen Themen (z.B. Geburtstagswünschen) austauschen können, um nicht die anderen Kanäle des Teams damit zu "überfluten".

Man könnte natürlich nun diesem Kanal jedes mal händisch anlegen, nachdem ein Team angelegt wurde. Das geht für diesen einen Anwendungsfall noch einigermaßen, sobald aber das Schema zur Teamsanlage komplizierter wird und mehrer Personen Teams anlegen, wird das händisch schnell nicht mehr praktikabel.

Es gibt mehrere Methoden, um automatisch Teams anzulegen. Hier möchte ich euch aber die Methode vorstellen, dieses über die PNP Provisioning Engine zu tun. Seit der Version 2019-03 der geht das nämlich auch damit.

Wir können die Engine entweder aus einer C# Anwendung heraus benutzen oder über das PNP Powershell Modul. Nachdem dieses installiert wurde, brauchen wir nur zwei Befehle auszuführen, um ein Team anhand eines Templates zu erstellen.


# Verbindung zur Admin Site herstellen 
Connect-PnPOnline -Url "https://<Dein Tenant>-admin.sharepoint.com" -Scopes "Group.ReadWrite.All","User.Read.All"

# Die Datei teamsschema.xml anwenden und das Team erstellen 
Apply-PnPTenantTemplate .\teamsschema.xml

Dazu brauchen wir aber natürlich auch noch eine XML Definitionsdatei. Ein komplettes Beispiel aller Möglichkeiten des Provisioning Schemas findet hier hier

Die folgende Datei zeigt nur ein kleines Beispiel davon und demonstriert, wie man ein neues Team mit dem Kanal "Lustiges und Ballons" anlegen kann.


<pnp:Provisioning xmlns:pnp="http://schemas.dev.office.com/PnP/2019/03/ProvisioningSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://schemas.dev.office.com/PnP/2019/03/ProvisioningSchema https://raw.githubusercontent.com/OfficeDev/PnP-Provisioning-Schema/master/OfficeDevPnP.ProvisioningSchema/ProvisioningSchema-2019-03.xsd">
  <pnp:Teams>
  <!-- Das Team erstellen-->
    <pnp:Team MailNickname="DemoTeam" DisplayName="Demo Team" Description="Das ist neu ein Demo" Visibility="Public" Archived="false">
       <pnp:Channels>
       <!-- Den Kanal "Lustiges und Ballons erstellen"-->
        <pnp:Channel DisplayName="Lustiges und Ballons"
                     Description="Benutzt diesen Kanal für alles, was off-topic ist"
                     IsFavoriteByDefault="true">
        <pnp:Messages>
        <!-- Zum Schluss noch eine Willkommensnachricht im Kanal posten -->
            <pnp:Message>
              <![CDATA[ 
              {
                "body": {
                  "contentType": "html",
                  "content": "Benutzt diesen Kanal für alles, was off-topic ist"
                },
                "subject": "Willkommen im Kanal Lustiges und Ballons"
              }
              ]]>
            </pnp:Message>
          </pnp:Messages>
        </pnp:Channel>
      </pnp:Channels>
    </pnp:Team>
  </pnp:Teams>
</pnp:Provisioning>

Exponentielles Wachstum, Digitalisierung und Pandemien

Sven Sieverding — Mon, 23 Mar 2020 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2020-03-10/

Menschen können exponentielles Wachstum nicht so richtig gut begreifen. Wir denken normalerweise eher linear. Nach dem Motto: "Wenn ich doppelt so viel Arbeit in irgendetwas stecke, bin ich doppelt so schnell fertig." Kein Wunder, denn das ist auch die Sichtweise, die uns im alltäglichen Leben weiterhilft. Exponentielles Wachstum funktioniert aber komplett anders, und ich kenne zwei gute Beispiele, an denen man es sich gut verdeutlichen kann.

30 Schritte

Es gibt zum einen das Beispiel mit den 30 Schritten, das ich einmal von dem Hamburger Unternehmer Christoph Magnussen gehört habe:

Blicken Sie jetzt einmal um sich und überlegen Sie, wo Sie in 30 Schritten sein könnten. Können Sie sich das gut vorstellen? Wunderbar. Mit einer durchschnittlichen Schrittlänge vom 1,5 Metern sind Sie damit etwa 45 Meter weit gekommen

((1,5 Meter) * 30 = 45 Meter).

Stellen Sie sich jetzt für ein zweites Gedankenexperiment vor, dass Sie zwar immer noch 30 Schritte machen, aber dass Sie bei jedem Schritt doppelt so viel Strecke zurücklegen, wie beim vorherigen. Also beim ersten Schritt so in etwa 1,5 Meter, beim zweiten drei Meter, beim nächsten sechs Meter und so weiter.

Wo denken Sie, dass sie dann nach 30 Schritten angekommen sind? Noch in Deutschland? Noch in Europa? Vielleicht doch schon in den USA?

Falls Sie die Mathematik nicht langweilt:

(1,5 Meter) * (2^29) = 805306368 Meter = 805306,368 Kilometer

Sie sind also 800000 Kilometer von hier entfernt... Mehr als doppelt so weit weg, wie der Mond von der Erde entfernt ist. Von da an wird es übrigens richtig spannend. Nur ein paar Schritte weiter haben Sie das Sonnensystem verlassen!

Seerosen

Ein anderes Beispiel, das ich neulich auf YouTube gesehen habe (Sobald ich die Quelle wiederfinde, gebe ich sie hier mit an), sind die Seerosen auf einem See. Stellen Sie sich vor, auf einem See gibt es eine Seerose. An jedem Tag verdoppelt sich die Anzahl der Seerosen. Sagen wir weiter, dass der ganze See nach hundert Tagen komplett mit Seerosen bedeckt ist.

Wir können uns nun zwei Fragen stellen, deren Antwort auf den ersten Blick nicht intuitiv richtig erscheint.

An welchem Tag war der See zu 50 Prozent mit Seerosen bedeckt?
An welchem Tag war ein Prozent des Sees mit Seerosen bedeckt?

Die Antworten auf diese Fragen werden die meisten Leute schockieren, die es nicht gewohnt sind, mit exponentiellem Wachstum umzugehen.

Der See war am 99. Tag (also erst am vorletzten Tag) zu 50 Prozent mit Seerosen bedeckt.
Besorgniserregender ist aber die Antwort auf die zweite Frage: Der See war erst am 93. Tag zu einem Prozent mit Seerosen bedeckt.

Falls ich nicht die technische Möglichkeit habe, pro Tag wenigstens ein Prozent des Sees von Seerosen zu befreien und ich nicht spätestens am 93. Tag damit beginne, diese zu entfernen, habe ich nun keine Chance mehr. Das widerspricht sehr stark linearem Denken: Ich hätte mich des Problems schon dann annehmen müssen, als es noch nicht einmal besonders sichtbar aufgetreten ist.

An diesem Beispiel sieht man aber auch eine natürliche Beschränkung von exponentiellem Wachstum. Da der See zu 100 Prozent mit Seerosen bedeckt und alle Fläche aufgebraucht ist, stoppt das Wachstum am 101. Tag. Diese Art von Wachstum (exponentielles Wachstum, das nicht über eine gewisse Grenze hinaus andauern kann) nennt man auch logistisches Wachstum. Dieses ist auch die "Normalform" von exponentiellem Wachstum in unserer Welt.

Digitalisierung

Aber auch im Digitalen gibt es exponentielles Wachstum. Konkret kann man das zum Beispiel an dem im Jahr 1965 formulierten Gesetz von Moore erkennen:

The number of transistors in a dense integrated circuit doubles about every two years.

Die Transistordichte in einem Mikrochip verdoppelt sich alle zwei Jahre. Extrem vereinfacht, aber nicht hundertprozentig richtig, bedeutet das auch, dass sich die Geschwindigkeit von neuen Computern alle zwei Jahre verdoppelt.

Wenn Sie jetzt gerade beispielsweise denken, dass etwa die künstliche Intelligenz die Welt verändert, die wir im Moment in der Cloud kennen und spannende Auswertungen auf Bigdata-Basis möglich macht, dann sollten Sie sich einmal mit Ray Kurzweil (Futurist und "Director of Engineering" bei Google) beschäftigen.

Er sagt für das Jahr 2029 (richtig gelesen: in nur 9 Jahren) voraus, dass dann ein handelsüblicher, 1.000 Dollar teurer Computer 1000-mal so leistungsfähig sein wird, wie das menschliche Gehirn. Kurzweil lag bisher zu 87 Prozent mit seinen anderen Vorhersagen richtig.

Was die allgemeine Verfügbarkeit solch einer Rechenleistung für die Wirtschaft und die Gesellschaft im Allgemeinen bedeuten wird, ist kaum vorzustellen. Die Welt wird sich aber sicher in zehn Jahren komplett verändert haben.

Mit starren Prozessen, die Monate oder gar Jahre brauchen, um sich auf neue Herausforderungen einzustellen, wird man es sehr wahrscheinlich nicht hinkriegen, mit der sich rapide ändernden Welt Schritt zu halten. Dafür ist ein gewisses Umdenken zu schnellen, flexiblen und agilen Prozessen, Mindsets und Geschäftsmodellen nötig, welches wir uns jetzt schon angewöhnen müssten.

Pandemien

Viren verbreiten sich ebenfalls mit exponentieller Geschwindigkeit und darin besteht auch ihre Gefahr. In den ersten Tagen und Wochen stecken sich nur sehr wenige Menschen mit dem Virus an. Und diese sind meist von einem persönlich weit entfernt und man fühlt sich sicher. Dann – schlagartig – hört man von den ersten Fällen im eigenen Umfeld und ein oder zwei Tage später ist auf einmal jeder krank, den man kennt.

Das einzige, was wir – gerade in Zeiten des Corona-Virus – dagegen tun können, ist den exponentiellen Wachstumsfaktor abzuschwächen und damit dafür zu sorgen, dass die tägliche Steigerung von Neuansteckungen unterhalb der Grenze der Leistungsfähigkeit unseres Gesundheitssystems bleibt – und das lange, lange bevor es auch nur den Anschein hat, dass das System überlastet sein könnte.

Um das zu schaffen, müssen wir als Gesellschaft die tägliche Infektionsrate verringern und dafür sorgen, dass die logistische Grenze der exponentiellen Neuansteckungen im Idealfall kleiner als 1 wird (im Gegensatz zu den vorherigen Beispielen, bei denen sie bei 2 lag).

Die Infektionsrate setzt sich hier aus zwei Faktoren zusammen:

Die Anzahl der sozialen Kontakte, die Personen im Durchschnitt täglich haben und an die das Virus weitergegeben werden könnte.
Die Wahrscheinlichkeit der Übertragung von einer Person zur nächsten.

Daraus resultieren auch die beiden wichtigsten Schritte, die wir im Moment ergreifen können:

Jeder von uns muss sich möglichst weit von anderen Personen fernhalten und soziale Kontakte massiv einschränken. Dadurch minimieren wir die Anzahl derer, die sich anstecken könnten.
Jeder von uns muss einfache und eigentlich auch selbstverständliche Hygieneregeln einhalten, wie etwa sich regelmäßig die Hände mit Seife zu waschen, immer nur in die Armbeuge zu husten und viele andere sehr einfach einzuhaltende Regeln.

Nur so können wir vielleicht sicherstellen, dass die Grenze des logistischen Wachstums in dieser Pandemie unterhalb der Grenze der Leistungsfähigkeit unseres Gesundheitssystems bleibt und vielleicht eine Katastrophe verhindern.

XSL Transformation mit Powershell

Sven Sieverding — Fri, 28 Feb 2020 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2020-02-28/

Ich kenne XSL-Transformationen schon lange und benutze Sie gerne. XSL steht für "X"tensible "S"tylesheet "L"anguage und ist für eine Methode, mit der man aus den Daten in einer XML Datei und einem Stylesheet eine Textdatei erzeugen kann.

XSL ist ein wenig aus der Mode gekommen, bietet gegenüber anderen Template Systemen aber ein paar - in meinen Augen sehr interessante - Features, die man sonst nirgendwo findet.

Aber erstmal ein Beispiel:

Mit diesem XML ("input.xml")

<data>
    <row title="Rot" colorcode="#F00" />
    <row title="Blau" colorcode="#00F" />
    <row title="Gelb" colorcode="#FF0" />    
</data>

und diesem XSL ("stylesheet.xsl")

<data>
    <row title="Rot" colorcode="#F00" />
    <row title="Blau" colorcode="#00F" />
    <row title="Gelb" colorcode="#FF0" />    
</data>

können wir die folgende HTML Datei erzeugen ("output.html")

<data>
    <row title="Rot" colorcode="#F00" />
    <row title="Blau" colorcode="#00F" />
    <row title="Gelb" colorcode="#FF0" />    
</data>

Dafür brauchen wir aber ein XSL Transformations Tool. Glücklicherweise können wir uns da aber recht einfach eine Powershell Function erstellen

function Transform-XML{
    param ($xml, $xsl, $output)
    {
        # Prepare settings objects
        $xslt_settings = New-Object System.Xml.Xsl.XsltSettings;
        $XmlUrlResolver = New-Object System.Xml.XmlUrlResolver;
        $argslist= New-Object System.Xml.Xsl.XsltArgumentList;
    
        # Prepare stylesheets 
        $xslt = New-Object System.Xml.Xsl.XslCompiledTransform;
        $xslt.Load($xsl,$xslt_settings,$XmlUrlResolver);

        # Prepare outfile
        $outFile= new-object System.IO.FileStream($output,[System.IO.FileMode]::Create,[System.IO.FileAccess]::Write)

        # Transform the file
        $xslt.Transform($xml,$argslist,$outFile);
        $outFile.Close()
    }

# Invoke the function
Transform-XML ./input.xml ./stylesheet.xsl ./output.html

Müssen E-Mails sein?

Sven Sieverding — Thu, 06 Feb 2020 00:00:00 GMT

This rendering was automatically generated and may have formatting issues. For the best experience, please visit: https://www.365konten.de/blog/2020-02-06/

Kennen Sie das "verlorene Interview" aus dem Jahr 1990 mit Steve Jobs?

Falls nicht, dann finden Sie es über eine kurze Suche auf Youtube. Konkret möchte ich aber hier ihr Augenmerk auf den Abschnitt des Interviews lenken, in dem über E-Mails gesprochen wird: Steve Jobs erklärt hier dem Reporter, der im Jahr 1990 noch nie das Internet gesehen hat, wie man mit E-Mails umgeht:

If we want to — if we’re going to be doing a special project let’s say with a company, and we — and let’s say the company is called, what’s your…WGBH. We’re going to be doing a special project with WGBH. And what we’ll do is we’ll create a special mailbox, WGBH and we’ll put twenty people on it that are going to be helping on this project. Now these twenty people will be from all over our company,

And if one sends a message to this mailbox, they’ll all get it like that, instantly.

And it will be like a beehive.

So I’ll put my own name on this mailbox and I’ll see these thirty mail messages fly by

Again the thoughts, disagreements and decisions of a company fly by a manager in a way that they never could before. And we have seen it reduce the number of meetings we have at least by fifty percent.

Fällt Ihnen etwas auf?

Das klingt im ersten Moment gar nicht danach, wie wir E-Mails benutzen. Er spricht hier davon, pro Projekt bzw. Vorgang ein eigenes Postfach anzulegen, in welches sich dann aus allen Teilen des Unternehmens Menschen einwählen können und die Informationen mitlesen oder mitdiskutieren können. Von einem persönlichen Postfach, an das viele von uns im ersten Moment bei dem Schlagwort "E-Mails" denken würden, spricht er hier überhaupt nicht. Das ist eine gänzlich andere Art, mit der digitalen Post umzugehen. Diese Idee kam in den vergangenen Jahren in Form von chatbasierten Applikationen wieder auf, die zurzeit in den Entwickler-Communities eine enorme Popularität erleben. Vertreter davon sind zum Beispiel "Slack", "HipChat" und Microsofts "Teams".

Aber von diesen Tools sind einige Kollegen in vielen Firmen noch weit entfernt und haben da ganz andere Probleme. Während die einen sich darüber beklagen, dass ihre Archive mit einer Speicherkapazität von 50 GB viel zu klein sind für die Flut von E-Mails, die sie in den letzten Jahren angesammelt haben, beschweren sich die anderen darüber, dass ihr Posteingang viel zu voll ist und sie Tools und Methoden brauchen, um diesen zu organisieren.

Aber muss das so sein? Ich würde gerne im Folgenden einmal mit Ihnen zusammen all ihre E-Mails in Ihrem Posteingang in verschiedene Kategorien einteilen und zeigen, was je für Alternativen zu E-Mails gibt. Sie werden erstaunt sein, wie wenige E-Mails danach noch in ihrem Posteingang übrigbleiben, wenn sie all diese entfernen.

E-Mails als Aufgabe

In vielen Unternehmen ist das der klassischste Anwendungsfall von E-Mails. Ich möchte jemandem einen Arbeitsauftrag zuweisen ("Bitte erledige für mich dieses und jenes") und möchte über den Fortschritt der Aufgaben informiert werden ("Wie ist denn der Stand bezüglich XYZ?", "Wann wird XYZ in etwa fertig") Das per Mail zu tun ist nahezu verführerisch einfach. Ich muss einfach eben mal kurz eine E-Mail schreiben und dann ist das für mich erledigt. Das produziert aber erheblichen, aber im ersten Moment noch verdeckten Aufwand. Ich muss mir selbst in einer Art Aufgabeliste merken, welche Aufgaben ich weggeschickt habe und mein Gegenüber muss dies auch tun. Damit wir sichergehen können, dass wir beide denselben Abarbeitungsstand haben müssen wir uns regelmäßig darüber abstimmen, wie dieser Stand nach unseren beiden Meinungen ist (Die typischen "Wie ist denn der aktuelle Stand von XYZ"-E-Mails) Dazu kommt dann noch, dass ich nicht erkennen kann, ob mein Gegenüber komplett überlastet oder sogar gar nicht im Hause ist und selbst dann noch die Aufgabe aktiv weiterdelegieren muss. Wenn ich E-Mails so benutze, benutze ich meinen Posteingang als eine Aufgabenliste, die jemand anderes als ich pflegt und ich reagiere nur auf Ereignisse und sich permanent ändernden Prioritäten darin. Dadurch werde ich sehr stark durch von meinem Posteingang getrieben.

Viel einfacher wäre es, wenn ich mir mit meinem Gegenüber eine Aufgabeliste teilen würde, in der alle unsere Aufgaben vorhanden sind und jeweils einer Person mit der Bitte zugewiesen werden, diese Aufgabe zu erledigen, zu kommentieren und den Status entsprechend zu ändern. Damit hat dann später jeder die Übersicht über den Stand aller Aufgaben. Im Idealfall könnte sogar noch jemand alle Aufgaben priorisieren und alle Kollegen die Aufgabeliste einfach von oben nach unten abarbeiten.

Das kann man zum Beispiel im einfachsten Fall einfach Outlook Aufgaben sein, bessere Auswertungsmöglichkeiten und gar komplette Workflows haben dann aber zum Beispiel Tools wie Atlassians "Jira". Oder Sie wählen dafür das gute, alte und analoge Kanban Board an der Wand.

E-Mailpostfach als Archiv oder Nachschlagewerk

Eine Sache, die sich schnell bei manchen Mitarbeitern - jenen vom Typus "Jäger und Sammler" - einbürgert, ist eine Sammelwut in Bezug auf E-Mails. Beschreibungen und Anleitungen von Prozessen, wichtige Informationen und auch Passwörter werden in mehr oder minder gut geordneten Ordnerstrukturen in den Postfächern gehortet. Die Kollegen sind auch häufig der Meinung, dass Sie sich hier gut zurechtfinden und können tatsächlich nach Aufforderung schnell die richtige E-Mail zu dem Thema aus ihrem "System" hervorzaubern. ("Das hat mit XYZ 2015 mal geschrieben… warte mal… Habe ich dir weitergeleitet"). Dieses Stück Information kann nun das Gegenüber natürlich in der eigenen E-Mail-Ablage-Struktur ablegen und hat sie dann auf Dauer verfügbar. Wenn dann aber genau der Kollege nicht im Hause ist, dann weiß niemand, wie an diese Information zu gelangen ist. Oder noch viel schlimmer - niemand weiß, dass die Information überhaupt irgendwo vorhanden ist.

Hier würde eher eine gemeinsame, strukturierte Ablage von Informationen Sinn machen. Sobald ich eine Information erhalten habe und sie aufbewahren möchte, dann trage ich sie in der Ablage ein und jeder meiner Kollegen kann sie sich dort ansehen. Das hilft dann auch gegen ein weiteres Problem: Was passiert denn, wenn sich einzelne Informationen in der abgelegten E-Mail nicht mehr aktuell sind? Dann gibt es höchstwahrscheinlich eine zweite E-Mail, in der die neuen Informationen beschrieben sind. Wer die nicht hat, handelt nach veralteten Informationen. Das kann mit einer zentralen Informationsablage, an der immer die aktuelle Information beschrieben ist, nicht passieren.

Häufig werden für solche Informationssysteme in der Praxis Wikis verwendet. Bei manchen Systemen, wie z.B. Atlassians "Confluence" kann man sogar noch einzelne Informationsartikel "abonnieren" um über spätere Aktualisierungen des Inhalts informiert zu werden.

E-Mails als Absicherung

Es gibt noch einen weiteren Grund, aus dem sich manche Leute recht anschauliche Mailarchive aufbauen: "Absicherungen". Das sind E-Mails, die ich mir weglege, weil ich später einmal sagen will: "Das habe ich dir doch schon an Datum ABC gesagt". Typischerweise sind das dann auch E-Mails, bei denen bestimmte Leute im CC mit "ankopiert" werden - aber eigentlich nicht, damit diese Personen etwas tun, sondern nur damit sie jene diese E-Mails auch in ihrem Posteingang haben und am besten auch gleich in ihr persönliches E-Mailarchiv verschieben…. Nur für den Fall. Dahinter steckt die Angst, dass sich das Gegenüber später an einmal getroffene Aussagen nicht mehr erinnern mag und man das dann doch lieber "schriftlich" hätte. Das ist eine verständliche Angst, aber auch eine die eigentlich in einem modernen, agilen Unternehmen eigentlich entkräftet werden müsste.

Hier könnten Sie versuchen, wichtige Entscheidungen und Absprachen immer auf einer Wiki-Seite oder innerhalb eines Dokumentes zusammenzufassen, dieses immer allen Teilnehmern zur Verfügung zu stellen und sich bei allen Entscheidungen nur auf diese, für alle sichtbaren Informationen zu berufen.

Das Vorgehen werden Sie vielleicht kennen: Das ist im Endeffekt einfach sowas wie ein klassisches Protokoll einer Sitzung oder eines Termines

E-Mails als Dokumentenaustausch

Weiter kommt es in Unternehmen natürlich häufig vor, dass Dokumente von mehreren Personen erstellt werden müssen. Diese werden dann auch häufig der Einfachheit halber direkt per Mail hin- und hergeschickt. Das führt aber nun auch wieder zu Problemen und zu einem erhöhten Aufwand. Wenn ich nun an der – in meinen Augen aktuellen - Datei in meinem Posteingang arbeite weiß ich nicht, ob das wirklich die aktuelle Version der Datei ist oder ob jemand anderes schon an der Datei in seinem Posteingang gearbeitet hat und mir das aktuelle Ergebnis nur noch nicht weitergeleitet hat. Im Schlimmsten Fall habe ich dann mehrere Versionen einer Datei, die ich dann aufwändig wieder zusammenführen muss. Einfacher wäre es, wenn ich gar keine Dateien mehr per E-Mail verschicken würde, sondern eine zentrale Ablagen Bereich hätte, in dem ich mit allen meinen Kollegen gemeinsam an dem Dokument arbeiten könnte. Dann bräuchte ich ihnen nur noch eine Mail mit dem Link zu dem Dokument schicken mit der Aufgabe, dieses zu bearbeiten.... Moment mal, wie wir im Abschnitt "E-Mails als Aufgabe" schon erläutert haben, sollte ich selbst dieses nicht tun, sondern meinen Kollegen in unserem Aufgabenverwaltungssystem den Auftrag zur Bearbeitung dieser Datei zuweisen.

Beispiele für zentrale Dateiablagen sind klassische Netzwerklaufwerke aber auch erweiterte Dokumentenplattformen wie etwa "SharePoint" und "Teams" von Microsoft oder "Google Docs". Die erweiterten Plattformen unterstützen dann auch noch gleichzeitige Arbeit an demselben Dokument (ohne die Meldung "Die Datei ist zur Bearbeitung durch den Benutzer XYZ gesperrt") sowie Kommentare und Kommunikationen in Bezug auf das Dokument, die mit außerhalb des Dokumentes Informationen zur Erstellungsverlauf des Werkes geben.

E-Mails als Umfragen

Recht häufig gibt es dann auch noch E-Mails mit einem Umfragen-Charakter. Generell ist das immer so, wenn ich eine größere Gruppe von Kollegen eine Frage stellen möchte und die Ergebnisse schlussendlich in einer Liste zusammenführen möchte. Das könnten zum einen die einfache Erstellung einer Teilnehmerliste für ein Event sein, also etwa "Wer teilnehmen möchte, der kann sich ja kurz per E-Mail bei mir melden". Zum anderen verbergen sich dahinter auch aber auch komplexere Anforderungen etwa der Art: "Schickt mir bitte zum Monatsende alle eure Aufwände für das Projekt zu, damit ich für den Kunden eine Aufstellung erzeugen kann" oder "Hier ist eine neue Handlungsanweisung, bestätige mir bitte, dass du sie zur Kenntnis genommen hast". Das geht natürlich per Mail, sie ist dafür hier aber aus zwei Gründen das falsche Mittel. Zum einen erzeugt so eine Umfrage per E-Mail gleich mehrfach Aufwand, nämlich den nicht vermeidbaren bei dem der die Umfrage beantwortet und gleichzeitig den vermeidbaren bei dem, der die Umfrage auswerten muss. Letzterer muss ja alle E-Mail-Antworten aufnehmen, korrekt interpretieren und in eine zentrale Liste einpflegen. Je nach Anzahl der Antworten kann das eine massiven Aufwand bedeuten. Zum anderen ist die Auswertung der E-Mails fehleranfällig. Es kann leicht passieren, dass eine einzelne E-Mail übersehen wird oder dass eine "Korrektur"-E-Mail eines Umfrageteilnehmers nicht korrekt eingetragen wird. Eine einfache Lösung für das Problem sind formulargestützte Umfragen. Als Ersteller der Umfrage bereite ich ein Formular vor, welches dann alle Teilnehmer ausfüllen können. Die Ergebnisse landen automatisch in einer zentralen Liste Beispiele für solche Umfragetools gibt es äußerste viele, die sich zumeist im Bedienungskomfort und in diversen Nebenanforderungen (etwa Zielgruppe Kollegen/Kunden/Internet oder Anonymisierung und Datenschutz) unterscheiden. Hier würde ich im generellen Business-Umfeld persönlich auf zwei Lösungen verweisen: Microsofts "Forms" und "Google Forms". Ansonsten gibt es auch Umfragen, die speziellere Szenarien zugeschnitten sind, wie etwa "Doodle" zur Koordination von Terminen.

E-Mails als Neuigkeiten oder Newsletter

Schließlich werden auch häufig generelle Neuigkeiten über E-Mails verbreitet. Das könnte dann zum Beispiel der generelle Newsletter des Unternehmens sein oder etwa Neuigkeiten im Produktkatalog eines Zulieferers. Hierzu zählen dann aber auch Statusberichte von Projekten oder die Information über eine neue Handlungsanweisung. Generell ist es hier immer so, dass eine Einzelperson oder kleinere Gruppe Informationen hat, die sie einer größeren Gruppe von Empfängern bereitstellen will. Der "Sender" der Informationen ist hier aber nicht primär an einer Antwort von allen Empfängern auf die Mail interessiert (Obwohl qualifiziertes "Feedback" häufig gewünscht ist).

Nun, aus Sicht des Senders ist es hier nicht falsch, mit E-Mails zu arbeiten, da es ein sicherer und einfacher Weg ist, die Information an die gewünschten Adressaten zu verbreiten. Leider ist dies aber auch das digitale Äquivalent einer Postwurfsendung. Als Empfänger kriege ich die Mail, egal ob ich will oder nicht.

Häufig werden die Informationen aus diesen "Newslettern" dann aber auch nirgendwo anders (etwa dem Intranet) abgelegt. Sie sollten sich dann hier die Frage stellen, ob das nicht einfach reicht. Falls Sie Ihre Mitarbeiter nochmal extra auf den "neuen" Newsletter hinweisen wollen, dann können Sie sie natürlich noch einmal kurz per E-Mail darauf hinweisen. Diese E-Mail können die Empfänger nach Kenntnisnahme aber auch sofort löschen, ohne dass ein Informationsverlust auftritt.

E-Mails als Berichte

In regelmäßigen Abständen bekomme ich einen Bericht, der mir die aktuellen Informationen etwa zu einem Projekt zusammenfasst. Ist das wirklich von der Idee so anders als der oben diskutierte Newsletter? Informationen werden von jemand anderem aggregiert und ggf. kuratiert und mir dann in einer aufgearbeiteten Form zugeschickt. Aber vielleicht bekomme ich denselben Bericht zweimal, weil im ersten ein Fehler war. Und dann habe ich den ersten schon weitergeleitet und habe nun Kommunikationsaufwände, um das wieder gerade zu ziehen.

Den jeweils aktuellen Bericht könnte man besser als ein zentral abgelegtes Dokument oder eine Wiki Seite erstellen. Damit würden wir auch direkt ein - falls gewollt - für andere einsehbares Archiv aufbauen, in dem alle Berichte abgelegt werden. Aktualisierungen eines Berichtes sind dann auch sehr einfach.

Gegen eine kurze E-Mail, die mitteilt, dass es an dem definierten Ort einen neuen Bericht gibt, ist hier nichts einzuwenden. Wir beim Newsletter kann diese Benachrichtigung aber auch sofort nach Erhalt wieder gelöscht werden, da die eigentlich wichtige Information im abgelegten Bericht vorgehalten wird.

Die ganzen restlichen E-Mails

Falls Sie alle oberen Vorschläge berücksichtigt haben, dann sollte sich ihr Postfach schon massiv verkleinert haben. Sicher, da bleiben noch viele E-Mails über, über die man sich analog zu den Beispielen Gedanken machen muss, aber im Prinzip können wir für jede Intention hinter einer E-Mail einen anderen Kanal finden. Und im Regelfall bieten diese Kanäle sogar Vorteile im Gegensatz zur E-Mail.

Ich hoffe, dass Sie de folgende Aussage aus diesem Artikel mitgenommen haben

Eine E-Mail scheint häufig das einfache Mittel zu sein, um eine Aufgabe zu erledigen, sie ist aber selten das Effizienteste.