Il primo passo per poter far funzionare il meccanismo è la definizione di una Secure Store Target Application, ovvero di un elemento che memorizza le credenziali di accesso al sistema esterno, al quale Sharepoint farà riferimento per evitare che vengano chieste all’utente che in quel momento visualizza i dati. E’ tuttavia possibile evitare questo passo, se si desidera che per l’accesso al database esterno vengano utilizzate le credenziali dell’utente connesso anzichè credenziali comuni.
La Secure Store Target Application si crea dalla Central Administration. Navigando nella sezione Application Management, e cliccando su Manage Service Applications sotto a Service Applications. Apparirà una schermata con la lista delle service applications, clicchiamo su Secure Store Service. A questo punto clicchiamo su Generate New Key nel ribbon, si apre una finestra che chiede di impostare una pass phrase, servirà per poter modificare la target application, va quindi appuntata da qualche parte (ma questo appunto è superfluo, no?).

A questo punto si può creare una nuova target application e compilare tutti i campi necessari, come da figura sotto. Come email mettiamo quella di un amministratore di sistema, mentre come Target Application Type in genere si mette Group, perchè in questo modo è possibile associare la target application a un gruppo di utenti.

Nel passaggio successivo è possibile quali campi associare alla target application, in genere sono sufficienti username e password: saranno poi valorizzati con le credenziali che dovranno impersonificare l’utente che si collega al database.

Ora bisogna specificare per quali utenti sarà disponibile questa target application, e quali sono gli utenti amministratori.

Ora che la target application è creata, non resta che settare le credenziali che utilizzerà per gli accessi al database esterno. Selezioniamo la target application dalla lista e premiamo il tasto set credential nel ribbon.

Si aprirà una finestra dove inserire username e password, questo utente deve ovviamente avere accesso ai dati sul database esterno al quale vorremo collegare le liste di Sharepoint.

Ora l’attività si sposta su Sharepoint Designer 2010, per impostare i contenuti esterni e creare le liste che puntano ad essi. La prima cosa da fare è definire un External Content Type: ovvero un contenuto esterno dal quale attingere. Dopo aver aperto un sito, bisogna andare sul menù External Content Type e tramite il comando ribbon crearne uno nuovo.

Diamo un nome al contenuto esterno e clicchiamo sul link per impostare la connessione verso il sistema esterno.

Ora bisogna cliccare sul tasto Add Connection per aggiungere una connessione.

Apparirà una serie di schermate dove compilare i dati per l’accesso al database esterno.

Selezionare come opzione di connessione Connect with Impersonated Custom Identity e mettere il nome della secure store application definita prima sulla Central Administration.

Premendo OK il sistema chiederà le credenziali, inserire quelle dell’utente definito come amministratore della secure store application ai passi precedenti. Una volta validata la connessione, nell’Operation Designer apparirà tra le connessioni disponibili anche quella appena impostata: si espande l’albero per trovare la tabella o la vista contenente i dati che dovranno popolare la lista esterna di Sharepoint.

Una volta individuata, cliccando col tasto destro sulla tabella o sulla lista, è possibile generare le operazioni che servono (lettura, modifica, cancellazione, ecc..). E’ possibile crearle tutte assieme, cliccando su Create All Operation. Nelle finestre successive dovremo dare un nome alle operazioni, si potranno settare filtri e sarà necessario marcare almeno un campo come identifier (ID di lista).

I filtri sono necessari per limitare il numero di record restituiti: di default è 2000 e a volte questo valore potrebbe non essere sufficiente, causando errore nella visualizzazione della lista tramite il browser sul sito Sharepoint.

Per l’operazione Read List, conviene settare qualche campo per la visualizzazione nel picker, altrimenti di default saranno visualizzati tutti e lato utente questa cosa risulta scomoda.

andando su List and Libraries, nei ribbon appare il comando Elenco Esterno.

Per chi volesse approfondire:

http://blog.concurrency.com/sharepoint/accessing-external-data-using-business-connectivity-services-in-sharepoint-2010/

Come fare? Ovviamente javascript e css. La rete è piena di esempi per disabilitare il cut&paste o evitare la stampa di una porzione di pagina su carta; per il primo obiettivo useremo uno script semplicissimo, per il secondo un foglio di stile associato alla stampa. Tutto qui:

<script language="JavaScript">
<!--
// Disable selection of content
function disableselect(e){return false}
function reEnable(){return true}
document.onselectstart=new Function ('return false')
if (window.sidebar){document.onmousedown=disableselectdocument.onclick=reEnable}
// -->
</script>

<script language="JavaScript">
<!--
// Disable right mouse click Script
var message="Function Disabled!";
function clickIE4() {if (event.button==2) {alert(message);return false;}}
function clickNS4(e) {if (document.layers||document.getElementById&&!document.all)
{if (e.which==2||e.which==3){alert(message);return false;}}}
if (document.layers) {document.captureEvents(Event.MOUSEDOWN);document.onmousedown=clickNS4;}
else if (document.all&&!document.getElementById) {document.onmousedown=clickIE4;}
document.oncontextmenu=new Function("alert(message);return false")
// -->
</script>

<style type="text/css"> @media print { body { display:none } } </style>

Con Sharepoint 2010 non è possibile però inserire javascript su una webpart di contenuto, inoltre per raggiungere lo scopo serve mettere alcune righe di codice nel tag <head> della pagina. Dovremo quindi utilizzare Sharepoint Designer, dove possiamo entrare nell’editor della pagina wiki e cliccando su Modalità Avanzata nel ribbon siamo in grado di modificare il codice. Ogni pagina Sharepoint contiene un tag, PlaceHolderAdditionalPageHead, pensato appositamente per aggiungere codice custom nell’head della pagina.

Nell’immagine sopra ecco un esempio pratico: risultato raggiunto! :)

Tutto parte dal menù del sito su cui si intende intervenire: Site Action -> Site Settings. Sotto al gruppo Look and Feel troveremo varie voci, come nell’immagine a sinistra. Una prima veloce sistemata ai colori si può dare cliccando su Site theme, da qui possiamo impostare la tavolozza cromatica che desideriamo. Va detto, a onor del vero, che se vogliamo salvare un nuovo tema cromatico dovremo utilizzare Power Point, ma l’idea di lavorare su un sito web attraverso power point mi sconvolge talmente tanto che non l’ho presa nemmeno in considerazione. Ma volenti o nolenti prima o poi sarà da fare.

Una volta decisi i colori, possiamo cimentarci nella creazione di una master page personalizzata, da utilizzare come base per la nostra web application, a cui associare un foglio di style CSS che conterrà le nostre personalizzazioni ed una eventuale favicon. Per fare ciò è necessario aprire Sharepoint Designer 2010 e caricare il sito web, dal menù di sinistra dobbiamo quindi selezionare la voce “List and Libraries” e successivamente entrare nella cartella “Style Library” (vedi figura sotto).

In questa cartella andremo a creare una nuova cartella, chiamandola “mystyle” dove posizioniamo il CSS e la favicon, oltre a eventuali immagini utili per abbellire tramite CSS il nostro sito web.

A questo punto è il momento di creare la master page. Come prima, da menù, andiamo sulla voce “Master Pages” (vedi figura sotto).

Noteremo che ci sono due pagine fondamentali, una dal nome “default.master” e l’altra “v4.master”. Le pagine master definiscono una struttura comune per tutte le pagine Web in Microsoft SharePoint Server. Per impostazione predefinita, quando viene richiesta una pagina, la pagina master e la pagina di contenuto sono combinate per produrre una singola pagina. Utilizzando una pagina master, tutte le pagine di contenuti e applicazioni condividono la stessa struttura della pagina e hanno lo stesso look & feel. La pagina default.master è utile per la retro compatibilità con SharePoint 2007, la versione 2010 utilizza la pagina v4.master, famosa per l’interfaccia a ribbon tipica di Office.

Per completezza, ecco la descrizione delle master page di default dal sito Microsoft:

Copiamo quindi la pagina v4.master e nominiamola ad esempio mypage.master. Ora doppio clic sulla pagina appena creata e si presenterà davanti a noi una schermata, al centro c’è la voce “edit file”, clicchiamoci sopra per fare il check-in della pagina e iniziare a modificarla secondo le nostre esigenze. L’obiettivo è inserire il riferimento a un CSS che utilizzeremo per modificare esclusivamente ciò che ci interessa. Passiamo quindi alla visualizzazione del codice.

All’interno del tag <head> possiamo inserire i riferimenti al CSS e ad una favicon specifici.

<SharePoint:SPShortcutIcon runat="server" IconUrl="/Style Library/mystyle/favicon.ico"/>
<SharePoint:CssRegistration name="/Style Library/mystyle/style.css" After="corev4.css" runat="server"/>

Abbiamo messo il riferimento ai file salvati in precedenza nella cartella appositamente creata. A questo punto dobbiamo salvare e impostare la master page appena creata come pagina di default. Per fare ciò, si può cliccare col tasto destro sul nome del file e selezionare la voce “Imposta come pagina master predefinita” oppure dal menù Site Action sul browser selezionare la voce “Master page” e impostare la pagina custom come quella predefinita (vedi immagine sotto).

Ora siamo liberi di modificare il CSS come meglio crediamo, nel mio caso ad esempio ho inserito questo codice:

body { background: #fff url(bg_erbetta.png) repeat-x bottom left;}
.s4-title { background: #fafafa url(header_bg.png) no-repeat bottom right;}
.s4-socialdata-notif, s4-socialdata {
background: #fafafa;
/* Fallback for web browsers that doesn't support RGBa */
background: rgb(250, 250, 250);
/* RGBa with 0.6 opacity */
background: rgba(250, 250, 250, 0.9);
/* For IE 5.5 - 7*/
filter:progid:DXImageTransform.Microsoft.gradient(startColorstr=#99fafafa, endColorstr=#99fafafa);
/* For IE 8*/
-ms-filter: "progid:DXImageTransform.Microsoft.gradient(startColorstr=#99fafafa, endColorstr=#99fafafa)"; }
.s4-ca { background: transparent;}

Ovviamente le possibilità di personalizzazione della master page sono tante altre, si possono spostare gli elementi o inserire pezzi di codice specifici. In questi appunti ho trascritto solo l’ABC, chi più ne ha più ne metta..

Chiudo con alcune utili risorse per chi vuole approfondire il tema:

• http://msdn.microsoft.com/en-us/library/gg430141.aspx
• http://office.microsoft.com/en-us/sharepoint-designer-help/customize-a-master-page-to-brand-your-site-HA102449505.aspx
• http://www.thesharepointmuse.com/sharepoint-2010-branding/
• http://nonsolosharepoint.wordpress.com/2010/01/26/its-a-ribbon-behaviour/ -> utile riferimento sul tema ribbon..
• http://nonsolosharepoint.wordpress.com/2009/12/23/migrare-una-master-page-da-sharepoint-2007-a-sharepoint-2010/

In realtà la laurea è avvenuta a Marzo, i festeggiamenti pure.. in un poetico irish pub addobbato a festa per San Patrizio.

Durante lo stage e nei mesi a seguire mi sono occupato di PDM (Product Data Management) e di intranet (sorprendendomi di un versatilissimo Sharepoint) in un gran bel gruppo industriale. Avevo già pubblicato qualche idea, ora è il momento del pdf. Pubblico solo in parte, per ovvi motivi di riservatezza, il capitolo 7 relativo alla intranet sviluppata in azienda.

L’intero lavoro è rilasciato con licenza Creative Commons.
Scarica il PDF: Tecnologie ICT per l’Enterprise 2.0: tra Project Management e Collaborazione

Tecnologie ICT per l’enterprise 2.0: tra project management e collaborazione by Davide Del Monte is licensed under a Creative Commons Attribuzione-Non commerciale-Non opere derivate 2.5 Italia License.
Permissions beyond the scope of this license may be available at www.diplod.it.

Di cosa parla questo lavoro? Il sommario vale più di mille parole:

1.Introduzione……………………………………………………………………………….. 11

2.Lo scenario…………………………………………………………………………………. 13
(a)Project Management in R&D………………………………………………. 14
(b)La struttura organizzativa…………………………………………………… 18
(c)Importanza della gestione progetti e Open Innovation………….. 21
(d)Intranet: condivisione e architetture Service Oriented…………… 25
(e)Gestione documentale abbinata ai progetti…………………………. 27

3.Gli strumenti per l’innovazione…………………………………………………….. 31
(a)Ai confini del Knowledge Management……………………………….. 32
(b)Crowdsourcing…………………………………………………………………. 35
i.caso Goldcorp………………………………………………………… 37
ii.caso Colgate-Palmolive…………………………………………… 38
(c)Triz Innovation…………………………………………………………………. 38

4.Social Network e analisi delle reti di persone…………………………………. 45
(a)Enterprise 2.0 e reti sociali………………………………………………….. 44
(b)I bisogni emergenti: Social Network e Appartenenza aperta……. 47
(c)Social Network Analysis e Value Network Analysis…………………. 53
(d)Gli strumenti per l’analisi delle reti sociali…………………………….. 59
Approfondimento tecnico: il software Ucinet……………… 64
(e)Small world network e i 6 Degrees su Facebook…………………….. 68
(f)Le reti a invarianza di scala e la dinamica dei sistemi complessi.. 70
(g)Elementi teorici per la costruzione di un Social Network…………. 74

5.Governance ICT: integrazione e architetture service oriented…………… 83
(a)complessità crescente e bisogno di integrazione……………………. 84
(b)Service Oriented Architecture (SOA) e Software as a Service
(SaaS), Business Process Management (BPM) e Rich Internet Applications (RIA) nei modelli organizzativi rizomatici…………… 85
(c)Dalle prime forme di scambio informazioni alla Enterprise
Application Integration (EAI)………………………………………………. 93
(d)Accoppiamento del software: bene o male?…………………………. 97
(e)Il ruolo dell’ICT: Perché i progetti falliscono………………………….. 99

6.Gli strumenti della Social Era…………………………………………………………. 103
(a)Virtual workspaces: tra wiki, blog e team di lavoro…………………. 104
i.caso Lago………………………………………………………………… 109
ii.caso Serena……………………………………………………………. 111
(b)Sharepoint e Project Web Access: la collaborazione sui progetti
secondo Microsoft…………………………………………………………….. 112
(c)Qualche cenno sui vendor internazionali e i player italiani……… 119
(d)Qualche cenno sul mondo Open Source………………………………. 124

7.Il caso LandiRenzo SpA: intranet per il reparto R&D……………………….. 129
(a)L’azienda e l’unità R&D………………………………………………………. 130
(b)L’analisi di partenza…………………………………………………………… 133
i.Persone e progetti………………………………………………….. 133
ii.Metodologie e prassi lavorative……………………………….. 134
iii.La collaborazione e gli strumenti……………………………… 136
iv.I network relazionali………………………………………………. 138
v.I rapporti con le sedi estere…………………………………….. 141
(c)Il re-design della intranet R&D: metodologie e problematiche.. 142
(d)Sharepoint e PWA: personalizzazioni della piattaforma e Web Parts……………………………………………………………………………….. 145
i.Utenti, sincronizzazione Active Directory e
ristrutturazione RBS……………………………………………….. 149
ii.Calendari condivisi per i banchi e la strumentazione
tecnica………………………………………………………………….. 152
iii.Template Landi………………………………………………………. 155
Approfondimento tecnico: Creazione tema Sharepoint…………………………………………………… 156
iv.Realizzazione prototipo di project workspace: uno spazio collaborativo con wiki e blog……………………………………. 159
(e)Product Data Management con il software CoCreate Model
Manager: workflow e integrazione SAP……………………………….. 166
i.Creazione di una nuova classe documentale………………. 174
ii.Creazione di nuovi materiali…………………………………….. 176
iii.Definizione workflow di approvazione disegni……………. 178
(f)Punti di forza e debolezza dei sistemi e ipotesi di sviluppo……… 180
i.PWA: i Key Users…………………………………………………….. 181
ii.PDM: integrazione SAP…………………………………………….. 183
iii.Scarso utilizzo e mancanza di incentivi………………………. 184
iv.Web Services con PDM……………………………………………. 185
v.Integrazione tra Sharepoint e SAP Portal……………………. 186

8.Conclusioni: una nuova intranet di Gruppo…………………………………….. 191

Riferimenti Bibliografici………………………………………………………………… 199
Appendice A: Una Web Part con le news da Google, XML e XSL all’opera 202
Appendice B: procedura per il deploy di un Application Template Sharepoint…………………………………………………………………………………… 206
Ringraziamenti…………………………………………………………………………….. 209

Mi piacerebbe se da questo lavoro nascessero spunti di riflessione, se qualcuno si facesse avanti per indicarmi esperienze simili, per scambiare pareri e conoscenze. Buona lettura ;)

Questa dei libri in azienda l’ho sentita per la prima volta ad una conferenza su Sharepoint organizzata da Amicucci Formazione. A detta di molti, Sharepoint sembra essere il non plus ultra per creare una intranet 2.0 come si deve: ormai è pubblicizzato in ogni dove come miglior piattaforma, io ancora devo convircermi fino in fondo: il basso supporto di browser diversi da IE e la non validità del codice secondo i canoni di accessibilità W3C mi fa pensare.. Vuoi per il buon marketing che sanno fare dalle parti di Microsoft, vuoi perchè effettivamente si tratta di una piattaforma duttile, questo cosino inizia a piacermi sul serio.

Così, tra le verie idee, ve n’era una che mi ha catturato più di altre: Libri in Azienda. Alla base di tutto c’è la volontà di diffondere proposte di lettura ai dipendenti; la novità è che il tutto viene realizzato secondo le logiche 2.0. Ai dipendenti è lasciata facoltà di commentare e recensire i libri proposti, loro stessi possono proporli. L’azienda può limitarsi a dare consigli di lettura oppure istituire una biblioteca vera e propria, in qualche stanzino vicino alla sala caffè: dove le persone possono recarsi per prendere in prestito i libri.

Ho pensato di mettere in pratica la faccenda (solo a livello virtuale), con ciò che avevo a disposizione: WSS e Sharepoint Designer. Ecco allora che che i titoli sono presentati attraverso la intranet, che l’azienda apre un profilo su Anobii e tramite i feed RSS la libreria viene presentata su una xml web part.

Le strade possibili erano due:

• Utilizzare due liste Sharepoint, dove vengono catalogati libri e recensioni.
• Utilizzare un social network esterno come Anobii, presentandone l’attività tramite i feed RSS

Cosa è meglio? Beh.. non si tratta di business, semmai di formazione collaterale del personale. Non ci sono dati sensibili, non ci sono dati da salvare; la scelta è presto fatta: servizio esterno!

Tramite un tenplate XSL si può processare il feed di Anobii e il codice è piuttosto snello:

<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:atom="http://www.w3.org/2005/Atom"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:foo="http://purl.org/rss/1.0/"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
xmlns:admin="http://webns.net/mvcb/"
xmlns:content="http://purl.org/rss/1.0/modules/content/"
xmlns:wfw="http://wellformedweb.org/CommentAPI/"
version="1.0" xmlns:ddwrt2="urn:frontpage:internal">
<xsl:template match="/rss" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:foo="http://purl.org/rss/1.0/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:sy="http://purl.org/rss/1.0/modules/syndication/" xmlns:admin="http://webns.net/mvcb/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:ddwrt="http://schemas.microsoft.com/WebParts/v2/DataView/runtime">
<html>
<head>
<style type="text/css">
img {border: none;}
</style>
</head>
<body>
<div>
<ul style="list-style: none; margin: 0; padding:0">
<xsl:for-each select="channel/item">
<li style="border: 1px dotted #ccc; margin: 5px; padding: 5px; background: #f9f9f9;">
<xsl:element name="a">
<xsl:attribute name="href">
<xsl:value-of select="link"/>
</xsl:attribute>
<xsl:value-of select="title"/>
</xsl:element>
<br/>
<small style="color: #666; text-align: right"><xsl:value-of select="pubDate" /></small>
<xsl:value-of select="content:encoded" disable-output-escaping="yes" />
</li>
</xsl:for-each>
</ul>
</div>
<div id="footer" style="display: none;">
<xsl:value-of select="channel/copyright" />
</div>
</body>
</html>
</xsl:template>
</xsl:stylesheet>


Dal punto di vista tecnico è tutto ok, adesso si tratta solo di seguire gli sviluppi e i risultati dell’esperimento! Qualcuno ha provato cose del genere?

Che ci sarà di così difficile? Nulla, se non il fatto che WSS è davvero poco user friendly quando si tratta di date.

Le prime cose da sapere riguardano la manipolazione delle date con XSL, bisogna partire dalle basi e poi da qualche esempio. Le date gestite su Sharepoint sono la @EventDate (data di inizio) e la @EndDate (data fine) e vengono restituite generalmente nel formato seguente: 2009-25-19T11:15:02Z.

Ovviamente l’ambiente di lavoro è Sharepoint Designer. Per prima cosa, una volta creata la nuova dataview webpart, bisogna associargli un form (una DataForm WebPart) tramite il quale passare gli intervalli di selezione delle date. Pubblico subito il codice sorgente di questo form:

<SCRIPT type="text/javascript" src="dhtmlgoodies_calendar/dhtmlgoodies_calendar.js?random=20060118"></script>
<link type="text/css" rel="stylesheet" href="dhtmlgoodies_calendar/dhtmlgoodies_calendar.css?random=20051112" media="screen"></LINK>
<table>
<script language="JavaScript">
function setStartTimeNow()
{
var d = new Date();
var currYear = d.getFullYear();
var currMonth = d.getMonth() + 1;
var currDate = d.getDate();
var currHour = d.getHours();
var currMin = d.getMinutes();
timeA = currYear + "" + currMonth + "" + currDate + "0001";
timeB = currYear + "" + currMonth + "" + currDate + "2359";
theInputA = document.getElementById('dataa');
theInputA.value = timeA;
theInputB = document.getElementById('datab');
theInputB.value = timeB;
}
</script>
<tr><td>Data e ora Inizio: </td><td><td><input id="dataa" type="text" value="" readonly name="T1"><input type="button" value="Seleziona data e ora.." onclick="displayCalendar(document.getElementById('dataa'),'yyyymmddhhii',this,true)"></td></tr>
<tr><td>Data e ora Fine: </td><td><td><input id="datab" type="text" value="" readonly name="T2"><input type="button" value="Seleziona data e ora.." onclick="displayCalendar(document.getElementById('datab'),'yyyymmddhhii',this,true)"></td></tr>
</table>
<br/>
<input type="button" value="Voglio sapere gli assenti di oggi.." onclick="setStartTimeNow()"/>
<input type="button" value="Mostra Risultati" onclick="javascript:_SFSUBMIT_"/>

Per creare questo form ho utilizzato il comodissimo javascript dhtmlgoodies_calendar, che permette di avere il classico calendarietto tramite il quale selezionare la data. La particolarità è che il formato della data passato all’input element del form è del tipo yyyymmddhhii, ovvero vengono passate data e ora sottoforma di numero. Ad esempio, la data 25/12/2009 – 13:52, viene passata come 200912251352. In questo modo sarà possibile confrontarla con altre date tramite gli operatori logici (maggiore, minore, uguale..).
T1 e T2 sono i parametri del form che verranno connessi alla web part XML.

Veniamo ora al dunque della web part che deve mostrare i dati, tramite Sharepoint Designer è necessario attivare due parametri: che chiameremo per comodità T1 e T2 (esattamente come gli elementi del form).

Una volta fatto ciò, il grosso del lavoro sta tutto nell’impostare correttamente il filtro attraverso una espressione XSL. Prima il codice, poi i commenti:

<xsl:variable name="Rows" select="/dsQueryResponse/Rows/Row[ ( ddwrt:FormatDateTime(string(@EventDate) ,1033 ,'yyyyMMddHHmm') &lt;= $T1 and ddwrt:FormatDateTime(string(@EndDate) ,1033 ,'yyyyMMddHHmm') &gt;= $T1 )  or  ( ddwrt:FormatDateTime(string(@EventDate) ,1033 ,'yyyyMMddHHmm') &lt;= $T2 and ddwrt:FormatDateTime(string(@EndDate) ,1033 ,'yyyyMMddHHmm') &gt;= $T2 )  or  ( ddwrt:FormatDateTime(string(@EventDate) ,1033 ,'yyyyMMddHHmm') &gt;= $T1 and ddwrt:FormatDateTime(string(@EndDate) ,1033 ,'yyyyMMddHHmm') &lt;= $T2 ) ]"/>

Cosa fa questa funzione? Posto che i parametri T1 e T2 identificano rispettivamente la data di inizio e la data di fine dell’intervallo di selezione (il periodo per cui vogliamo sapere chi era assente), il codice del filtro trasforma tutte le date nel formato numerico descritto sopra, e le confronta in base ai parametri T1 e T2, verificando se esistono eventi iniziati prima della data T1 e ancora in corso nell’intervallo [T1;T2], iniziati e conclusi all’interno dell’intervallo oppure iniziati in [T1;T2] e con conclusione dopo T2. In questo modo si ottiene la lista di tutti gli assenti all’interno di un determinato periodo, anche degli assenti per solo alcuni giorni e non per tutto l’intervallo stesso.

Nota bene, in linea di massima anche questo filtro dovrebbe essere corretto:

<xsl:variable name="Rows" select="/dsQueryResponse/Rows/Row[ ( substring(translate(translate(translate(translate(@EventDate,'-',''),':',''),'T',''),'Z',''),1,12) &lt;= $T1 and substring(translate(translate(translate(translate(@EndDate,'-',''),':',''),'T',''),'Z',''),1,12) &gt;= $T1 )  or  ( substring(translate(translate(translate(translate(@EventDate,'-',''),':',''),'T',''),'Z',''),1,12) &lt;= $T2 and substring(translate(translate(translate(translate(@EndDate,'-',''),':',''),'T',''),'Z',''),1,12) &gt;= $T2 )  or  ( substring(translate(translate(translate(translate(@EventDate,'-',''),':',''),'T',''),'Z',''),1,12) &gt;= $T1 and substring(translate(translate(translate(translate(@EndDate,'-',''),':',''),'T',''),'Z',''),1,12) &lt;= $T2 ) ]"/>

La funzione translate depura la stringa della data dai vari caratteri e lascia solo 14 numeri, la funzione substring leva gli ultimi due numeri (relativi ai secondi dell’ora della data). Ma così non funziona, per un qualche strano motivo Sharepoint anticipa di un’ora la data di tutti gli eventi, e ciò che concettualmente era infallibile, decade durante la prova effettiva, con buona pace per tutto il tempo trascorso sopra a ragionarci.. Argh!

L’utilità? Lasciare ai soli amministratori la possibilità di editing di determinati campi.

Questo il codice di base proposto:

<script language="javascript" type="text/javascript">
_spBodyOnLoadFunctionNames.push("avvioControlli");
function avvioControlli() {
hideFields();
}
function findacontrol(FieldName) {
   var arr = document.getElementsByTagName("!");
   // get all comments
   for (var i=0;i < arr.length; i++ )
   {
      // now match the field name
      if (arr[i].innerHTML.indexOf(FieldName) > 0)
      {         return arr[i];      }
   }
}
function hideFields() {
   var control = findacontrol("Stato");
   control.parentNode.parentNode.style.display="none";
   control = findacontrol("Comments");
   control.parentNode.parentNode.style.display="none";
}
</script>

Dove si mette? Appena soto al PlaceHolderMain, nella pagina NewForm.aspx della relativa lista, tramite Sharepoint Designer: una figura vale più di mille parole. Dopo aver aperto l’albero della lista su Sharepoint Designer, è sufficiente editare il codice della pagina.

L’approccio è perfetto e geniale, il javascript non fa altro che ricercare nel documento i commenti per poi oscurare tramite una proprietà CSS la visualizzazione. Ci sono però alcuni difetti su questo codice: piace a internet explorer e non agli altri browser.
Ecco allora come modificarlo per renderlo compatibile con i vari Firefox, Chrome e compagnia bella:

<script language="javascript" type="text/javascript">
_spBodyOnLoadFunctionNames.push("avvioControlli");
function avvioControlli() {
hideFields();
}
function findacontrol(FieldName) {
//se browser Internet Explorer cerco i commenti
if (navigator.userAgent.indexOf("MSIE")!=-1) {
   var arr = document.getElementsByTagName("!");
   // get all comments
   for (var i=0;i < arr.length; i++ )
   {
      // now match the field name
      if (arr[i].innerHTML.indexOf(FieldName) > 0)
      {         return arr[i];      }
   }
   }
//se browser diverso da Internet Explorer cerco i titoletti
   else {
   var arr = document.getElementsByTagName("H3");
   // get all comments
   for (var i=0;i < arr.length; i++ )
   {
      // now match the field name
      if (arr[i].innerHTML.indexOf(FieldName) > 0)
      {         return arr[i];      }
   }
}
}
function hideFields() {
   var control = findacontrol("Stato");
   control.parentNode.parentNode.style.display="none";
var control = findacontrol("Comments");
   control.parentNode.parentNode.style.display="none";
}
</script>

Se poi volessi piazzare da qualche parte un pulsantino per far riapparire questi campi, magari solo per determinati utenti, sarà sufficiente creare questa funzione:

function showFields() {
   var control = findacontrol("Stato");
   control.parentNode.parentNode.style.display="block";
var control = findacontrol("Comments");
   control.parentNode.parentNode.style.display="block";
}

Buona personalizzazione!

• http://www.codeplex.com/FeedReader/ - Web part per aggrerare feed multipli, progetto ospitato su Codeplex
• http://sharepointrss.com/ - Una utility per generare una webpart in dwp, caricabile direttamente sul proprio sito sharepoint

 Se vogliamo però utilizzare le funzionalità standard, è possibile fare in casa con una semplice XML Web Part. Nel campo XML Link si riporta l’url del feed RSS, vedi figura sotto:

Nell’editor XSL, inserire il codice seguente:

<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/rss">
<html>
<head>
 <link href="xsl.css" rel="stylesheet" type="text/css" />
</head>
<body>
 <div id="logo" style="border-bottom: 1px solid #ccc; margin-bottom: 5px; font-size: 1.2em; font-weight: bold;">
  <xsl:element name="a">
   <xsl:attribute name="href">
    <xsl:value-of select="channel/link" />
   </xsl:attribute>
   <xsl:value-of select="channel/title" />
  </xsl:element>
 </div>
 <div>
  <ul style="list-style: none; margin: 0; padding:0">
   <xsl:for-each select="channel/item">
     <li>
      <xsl:element name="a">
       <xsl:attribute name="href">
        <xsl:value-of select="link"/>
       </xsl:attribute>
       <xsl:value-of select="title"/>
      </xsl:element>
      <small style="color: #ccc; text-align: right"><xsl:value-of select="pubDate" /></small>
     </li>
  </xsl:for-each>
  </ul>
 </div>
 <div id="footer" style="display: none;">
  <xsl:value-of select="channel/copyright" />
 </div>
</body>
</html>
</xsl:template>
</xsl:stylesheet>

Apparirà così una web part che riporta i titoli e la data di pubblicazione degli elementi del feed. Se volessimo far apparire anche il corpo degli elementi (ad esempio il testo degli articoli di un feed), si può utilizzare il seguente codice XSL, all’interno del ciclo <xsl:for-each select=”channel/item”> :

<xsl:value-of disable-output-escaping="yes" select="description" />

Se dobbiamo leggere un feed da una lista sharepoint c’è un passaggio fondamentale per far in modo che tutto funzioni: è necessario attivare l’accesso anonimo sulla lista che produce il feed. Nei Settings della lista, sotto a Permissions and Management -> Permissions for this list, nel menu Settings -> Anonymous Access, abilitare in visualizzazione l’accesso.

Uno dei maggiori tanti limiti di Sharepoint Designer è quello di non poter creare un workflow in grado di inviare mail a diversi utenti prendendoli da un campo di tipo person picker, quando questo è impostato per accettare più di un solo utente. Se infatti si permette l’inserimento multiplo, al momento della creazione del workflow non sarà visibile tale campo tra quelli selezionabili come destinatari della mail.

Il mio obiettivo è dare la possibilità all’utente, in una lista di tipo calendario, di invitare diverse persone ad un evento e far partire un workflow che avvisi via mail queste persone al momento del salvataggio dell’appuntamento. Ovviamente gli invitati posso essere più di uno, nonchè un gruppo di utenti.
Ho trovato una soluzione, un workaround, che può sempre tornare utile condividere: semmai qualcuno avesse idee migliori..
Questa soluzione non prevede l’utilizzo di Visual Studio, che è decisamente più fastidioso.

Innanzi tutto bisogna creare nella lista in questione un campo di appoggio, che possiamo chiamare come ci pare, di tipo single line text e non obbligatorio. Utilizzeremo questo campo per salvarci dentro i valori presenti nel campo di tipo person picker.
Una volta fatto ciò dobbiamo oscurare questo campo dal modulo di inserimento di un nuovo appuntamento.
Per far ciò ci sono diverse strade:

1. La prima prevede il solo intervento sulle configurazioni della lista.
   Andiamo in List Settings -> Advanced Settings e mettiamo yes nell’opzione Allow management of content types?
   Fatto ciò basta tornare nei List Settings, dove sarà presente una sezione riguardante i Content Types
   
   Cliccando sopra si aprirà la lista dei content type, dove è possibile decidere di rendere hidden l’elemento Appoggio appena creato
2. L’altra strada prevede l’intervento via Sharepoint Designer, utilizzando un javascript che vada ad oscurare il campo. Nella pagina NewForm.aspx della lista in questione, dopo il pezzo di codice <asp:Content ContentPlaceHolderId=”PlaceHolderMain” runat=”server”>, si può inserire un javascript di questo tipo:
   
<script language="javascript" type="text/javascript">
function Oscura() { 
 document.forms[0].NameDelCampoInputAppoggio.disabled=true;
 }
_spBodyOnLoadFunctionNames.push("Oscura");
</script>
   Dove al posto di “NameDelCampoInputAppoggio” mettiamo la stringa dell’attributo name dell’input relativo ad Appoggio, ricavabile dall’HTML del form visualizzato da un browser.

Fatto questo siamo pronti per impostare il workflow da Sharepoint Designer.
I passi sono semplici: sulla lista in questione, all’atto di creazione di un nuovo item, al primo passo impostiamo nel campo Appoggio il valore del campo Avviso (quello del person picker con la possibilità di scegliere più utenti), se quest’utlimo contiene valori.

Al passo 2 inviamo la mail utilizzando come destinatario il campo Appoggio.

Funziona!