Posts tonen met het label JavaScript. Alle posts tonen
Posts tonen met het label JavaScript. Alle posts tonen

20 februari 2015

Display Templates - Tips & Tricks

In mijn vorige blogpost heb ik al een introductie geschreven over Display Templates. Deze blogpost is meer een verzameling van kleine dingetjes waar ik tegenaan ben gelopen tijdens het werken met de Display Templates.

Soorten Display Templates

Er zijn verschillende soorten display templates en voor iedere soort zijn er al standaard een aantal verschillende aangemaakt in SharePoint. Het loont dus de moeite om eerst even te checken of er niet al een geschikt template bestaat voor wat je wilt bereiken (Zelf heb ik altijd wel wat te zeuren, dus ik maak toch wel weer eigen templates ☺). Als je ook maar iets afwijkt van de standaard, wijzig dan niet het standaard Template, maar kopieer hem en maak een nieuwe aan.

Je vindt hier een overzicht van soorten en standaard Display Templates.

Managed Properties

Managed Properties zijn de SharePoint velden die je uit kan lezen in de Display Templates. Deze zijn er in alle soorten en maten en daarmee zijn er allerlei verschillende methoden om ze weer te geven. Daarover later in deze blogpost meer.

Er zijn in SharePoint veel meer properties dan alleen de Managed properties, deze heten Crawled Properties. Je kunt die echter niet direct uitlezen in een Display Template. Je moet ze eerst mappen naar een (bestaande of zelf aangemaakte) Managed Property. Hoe je dat doet lees je hier.

Omdat ik in SharePoint Online werk en dus geen Central Admin heb, hier nog even de link naar de Managed Properties lijst:
https://[JouwDomein].sharepoint.com/_layouts/15/listmanagedproperties.aspx?level=sitecol

Managed Properties uitlezen

In de <head> sectie van het Item Display Template Staat een tag <mso:ManagedPropertyMapping msdt:dt="string">. In deze tag moet je de Managed Properties definiëren die je uit wilt lezen. Dit ziet er ongeveer zo uit:
<mso:ManagedPropertyMapping msdt:dt="string">'Link URL'{Link URL}:'Path','Line 1 code'{Line 1}:'Title','Line 2 code'{Line 2}:'Description'</mso:ManagedPropertyMapping>

De definitie van een Managed Property is als volgt:
'Property Display Name'{Property Name}:'Managed Property Name'

  1. Property Display Name is volgens Microsoft de naam van de Property die te zien is in het Web Part bewerkingsmenu wanneer het Display Template is geselecteerd. Persoonlijk snap ik niet wat ze hiermee bedoelen. Ik zie het nergens terug. Als iemand hier meer van weet, hoor ik het heel graag!
    Voor zover ik weet is dit de waarde waarmee je de property aanroept in het script in je Display Template.
  2. Property Name is een identifier die gekoppeld is aan de Managed Property. Deze is zichtbaar als veld in het Web Part bewerkingsmenu onder 'Property Mappings'. Hier kan je ook een andere Manged Property aan datzelfde veld koppelen (dat zie je overigens niet terug in het Display Template, daarin stel je alleen de default waarde in).

    Deze Property Name is dus alleen van waarde als het Web Part de bewerkingsoptie 'Property Mappings' bevat. Is dat niet zo, dan kan je dit ook weglaten en de syntax als volgt gebruiken:
    'Property Display Name':'Managed Property Name'
  3. Managed Property Name is de werkelijke Managed Property, zoals het SharePoint systeem hem herkend. Het kunnen één of meer Managed Properties zijn, gescheiden door een puntkomma (;). Tijdens runtime wordt de lijst (die dus één of meerdere items kan bevatten) van links naar rechts uitgelezen en het eerste item dat een waarde van een Managed Property ophaalt, wordt toegepast.

Nadat je een Managed Property hebt gemapped, kan je het uitlezen door in de <body> van het Display Template een variabele (javascript) aan te maken:
<!--#_
var title = $getItemValue(ctx, "Line 1 code");
_#-->
Ik heb hier even deels de standaard TwoLine Item Display Template van SharePoint gekopieerd (en een beetje aangepast), omdat hierin het verschil goed duidelijk is.

Om de waarde van de Managed Property vervolgens weer te geven in je HTML, roep je de variabele aan op deze manier:
_#= variabele =#_
In het geval van Tekst waarden is het verstandig om de volgende syntax aan te houden:
_#= $htmlEncode(variabele) =#_
De htmlEncode zorgt ervoor dat alle special tekens die een script kunnen laten klappen, gecodeerd worden. Zo wordt een quote (') bijvoorbeeld omgezet naar &#39;.

Neem een kijkje in de standaard Display Templates van SharePoint om te zien wat er allemaal mogelijk is. Ook op deze website staat een hoop waardevolle informatie over scripten in Display Templates.

Afbeeldingen weergeven

De Managed Properties van afbeeldingen en iconen bestaan eigenlijk gewoon uit tekst, namelijk een url. Om dit om te zetten naar een afbeelding moet je de Managed Property dus aanroepen in de src van een <img> tag. De syntax zou er zo uit kunnen zien:
<img src="_#= variabele =#_" alt="" />
Er zit wel een valkuil in: SharePoint vindt urls die zijn onderbroken met een spatie niet zo leuk… Normaal worden die spaties opgevuld met een %20, maar hier dus niet. Zorg er dus voor dat je de Picture Library waar je de afbeeldingen uit wilt halen, GEEN spaties in de naam bevatten, of knutsel wat met JavaScript om de spatie te vervangen voor een %20 (geen idee hoe, niet geprobeerd).

Datums weergeven

Dit is ook een leuke, want je hebt hierin de vrijheid om het door jou gewenst format te gebruiken. Dit zou er bijvoorbeeld zo uit kunnen zien: _#= variabele.format("d MMMM yyyy") =#_ Maar je kan de datum ook splitsen. Zo heb ik bijvoorbeeld eens een gekleurd vakje gemaakt, met de datum daarin opgeknipt in twee stukken. Zo staan de dag en maand onder elkaar ipv naast elkaar: <div class="date-formats">
<span>_#= variabele.format("d") =#_</span> <!-- dag in cijfers -->
<small>_#= variabele.format("MMMM") =#_</small> <!-- maand in woorden -->
</div>

Een overzicht van alle beschikbare formats vind je hier.

File Type Icon uitlezen

Een gevalletje apart, want dit werkt, in ieder geval bij Search Result Display Templates, niet zoals je zou verwachten (mij een raadsel waarom niet, maar het is zo). Het file type icon is het icoontje dat je in bijvoorbeeld document libraries ziet staan als eerste kolom van ieder document. Het kan bijvoorbeeld een MS Word-icoontje zijn, of Excel, PDF, etc.

Om het toch voor elkaar te krijgen, stelen we hem gewoon even van een ContentBySearch Display Template. Dat doe je zo:

  1. In de Control Display Template voeg je het volgende script in: <script>
    $includeScript(this.url, "/_layouts/15/search.cbs.js");
    </script>
  2. In het Item Display Template voeg je de volgende regel code toe: var iconUrl = Srch.ContentBySearch.getIconSourceFromItem(ctx.CurrentItem);
  3. Roep de variabele aan in een <img> tag: <img src="_#= $urlHtmlEncodeString(iconURL) =#_" />

En klaar is Kees! Ik heb hierbij overigens geen styling meegenomen, dus het kan zijn dat je dat nog moet fixen. Binnenkort post ik een gedetailleerde tutorial over het maken van een 'Mijn Documenten' Display Template, waarin ik ook het file type icon meeneem.

Dit was het weer even voor nu, hopelijk heb je er wat aan ☺

Prefer to read this in English?

SharePoint 2013 - Display Templates

Display Templates zijn op zichzelf staande bestanden waarin Managed Properties (SharePoint velden, zoals Title, Description, etc) worden uitgelezen en HTML, CSS en JavaScript kan worden verwerkt. Deze bestandjes worden vervolgens gerenderd in een of meerdere pagina's van je SharePoint site. Je gebruikt ze om de weergave van Web Parts te bepalen. Ze bestaan uit twee HTML-bestanden en bij ieder van deze bestanden wordt automatisch een JS-bestand gegenereerd en gekoppeld. Met deze JS-bestanden doe je zelf niets, dat gaat allemaal automatisch.

Het eerste HTML bestand is de Control Display Template en de tweede is het Item Display Template. De Control Display Template bepaalt de algemene structuur van hoe de resultaten worden gepresenteerd in het Web Part (zoals lijsten, lijsten met paginering, sliders, etc). Bijvoorbeeld een <ul> waar je <li>'s in wilt gaan renderen. Daarnaast wordt het gebruikt om JavaScript en CSS bestanden in te laden.

Het Item Display Template bepaalt hoe elk resultaat in de set wordt weergegeven (zoals lijst items, afbeeldingen, tekst, etc). Dat zou dan dus een <li> (inc inhoud) zijn als we het bovenstaande voorbeeld aanhouden. Één <li>? Ja, het is een template, dus er gaat straks een lus doorheen die steeds diezelfde <li> gebruikt om het geheel op te bouwen. De Web Part instellingen bepalen hoeveel items dat zijn, Display Templates gaan daar niet over.

De reden dat er twee losse (Control en Item) bestanden zijn in plaats van alles in één, is dat je Control- en Item templates willekeurig kan combineren. Het zijn dus niet persé vaste setjes. Het kan heel goed zijn dat je voor dezelfde Control Display Template, meerdere Item Display Templates maakt, die bijvoorbeeld weer steeds andere SharePoint velden (Managed Properties) aanroepen, maar wel dezelfde JS/CSS en (container)markup gebruiken.

Leuk verhaal, maar hoe werkt dit nou in de praktijk?
Laten we beginnen bij het begin. Omdat ik zelf gebruik heb gemaakt van een SharePoint Online omgeving (waar je dus niet wilt deployen vanuit Visual Studio), ga ik daar in deze blogpost ook even vanuit. We gaan zodoende gebruik maken van de SharePoint Design Manager en Notepad++.

Persoonlijk vind ik de 'Search Results' methode het makkelijkst werken. Dat is slechts één en hetzelfde Web Part (namelijk het Search Results Web Part), waar je letterlijk en figuurlijk alle kanten mee op kan. Je plaatst dan dus voor ieder Web Part dat je wilt hebben op je pagina, een Search Results Web Part met een eigen query en laat de Display Templates bepalen hoe en wat er zichtbaar is. Zo kan hetzelfde Web Part er telkens compleet anders uitzien en andere data weergeven.
Nou moet ik toegeven dat ik nog niet van alle soorten Display Templates heb bekeken hoe en waar ze worden toegepast en of er in sommige gevallen dus betere alternatieven zijn dan Search Results. Wat ik wel zeker weet is dat Search Results in ieder geval goed werkt voor wat ik wilde bereiken.

Start

Je vindt de Search Results Display Templates hier:
https://[JouwDomein].sharepoint.com/_catalogs/masterpage/Display%20Templates/Search/

Dit gaat op SiteCollection niveau, dus als je een onderliggende SiteCollection hebt, zou het pad er zo uitzien:
https://[JouwDomein].sharepoint.com/sites/[JouwSiteCollection]/_catalogs/masterpage/Display%20Templates/Search/

Map Network Drive

Het werkt t makkelijkst om de Masterpage Gallery te mappen naar je computer, zodat je deze vanuit de verkenner kan openen. Lees hier hoe.
Let op dat: Je IE moet gebruiken, je bij het inloggen het 'ingelogd blijven' vinkje AAN moet zetten, je SharePoint domein/site aan je trusted sites toe moet voegen en je een willekeurige library moet openen dmv de 'Open in Explorer' optie in de ribbon (alleen mogelijk met IE). Na die stappen zou je moeten kunnen mappen. Zo lang als dat je ingelogd bent op de site, kan je via de verkenner de MP Gallery benaderen. Log je uit, dan kan je er niet meer bij. In de MP Gallery navigeer je naar Display Templates -> Search voor de juiste locatie.

Starter Display Templates

Via de links hieronder kan je 'kale' Starter Templates downloaden om mee te beginnen. De Control bevat een heading en een container voor de items, de Item Template toont de Title en Description.


Inderdaad, de JS files ontbreken. Klopt, die maakte SharePoint namelijk zelf aan, als je bovenstaande bestanden upload naar de Display Template Gallery. Je moet dit dan wel via de SharePoint user interface doen (dus via de browser).

Hoe nu verder?

Omdat het een heeeeel erg lange lap tekst wordt als ik de verschillende uitwerkingen allemaal in deze blogpost ga beschrijven, heb ik losse blogposts gemaakt voor een aantal individuele uitwerkingen:

Dan heb ik nog een blogpost met tips & tricks. Natuurlijk ben ik zelf tegen issues aangelopen waarmee ik heb geworsteld om het op te lossen. Om jullie dit leed te besparen staan in deze blogpost de oplossingen van deze issues en best practices om problemen te voorkomen.

Wat ook heel interessant is, is deze pagina. Je leest hier uitgebreid over het hoe en waarom en de opbouw van Display Templates.

Want to read this in English?

25 april 2014

SharePoint 2013 List Item Attachment

Het heeft even een tijdje geduurd, maar hier ben ik dan weer met een nieuwe blogpost. Het onderwerp waar ik het dit keer over ga hebben is de functionaliteit in SharePoint waarbij een document als attachment bij een list item gevoegd kan worden.

Het probleem waar ik mee geconfronteerd werd, was dat men de attachments graag als lijstje van korte klikbare links in een SharePoint 2013 app wilde weergeven. Omdat dit ietwat ingewikkelder is dan het weergeven van een willekeurige column/field uit een lijst, vind ik het de moeite waard om in een blog uit te leggen hoe je bovenstaande voor elkaar krijgt. SharePoint apps bestaan uitsluitend uit client side code, dus we gaan met javascript aan de slag.

Voor ik begin wil ik nog even vermelden dat ik deze blogpost heb kunnen schrijven dankzij mijn collega’s Mirjam van Olst en Laurens Ruijtenberg, die mij hebben geholpen het mysterie op te lossen.

Wat je nodig hebt

In deze blogpost ga ik er vanuit dat je al een werkende SharePoint omgeving hebt en een SharePoint solution, waarin je (onder andere) de list item attachments wil gaan tonen. Zelf werk ik met Visual Studio 2013, dat is het makkelijkst om SharePoint code te debuggen. De gratis versie heet Visual Studio Express en is hier verkrijgbaar.

Om list item attachments op te halen, heb je vanzelfsprekend een SharePoint list nodig. Zelf heb ik een list met de naam ‘My Items’. Deze naam zal ik, voor de duidelijkheid, ook blijven gebruiken in de code. Je kan de list aanmaken via de solution (best practice), of een list aanmaken via de user interface van SharePoint. Vul je SharePoint list alvast met wat list items en voeg wat attachments aan die items toe. Dat scheelt later weer een hoop hersenkraken over waarom het niet werkt (als er geen attachments zijn, kunnen ze immers ook niet worden weergegeven).

Verder heb je jQuery en de ‘jQuery library for SharePoint Web Services’ nodig. De laatste vind je hier. jQuery zelf kan je via Visual Studio installeren (Tools -> Extensions and Updates).

We gaan in deze blogpost uit van 3 bestanden:

  • Een HTML template waarin we onze content gaan weergeven.
  • Een Javascript bestand welke bepaald wat we gaan weergeven, hoe we het gaan weergeven en waar we het gaan weergeven. Omdat dat ik zelf met de MVC methode heb gewerkt, is in mijn geval de Javascript verdeeld over 2 lossen bestanden. Doe wat je het prettigst vind.
  • Een CSS bestand om de noodzakelijke opmaak toe te voegen.

Beginnen

In het HTML template gaan we een korte structuur aanmaken, zodat we straks een plekje hebben om de list item attachments weer te geven. Ik schrijf niet de complete SharePoint pagina uit, alleen het stukje waar het hier om gaat.

<div class="container">
<h3 id="title">Attachments</h3>
<h3 id="listAttachments"></ul>
</div>

Het is niet veel: Een div om het geheel te positioneren, een header en een lijst waarin ieder attachment straks als list item wordt ingevoegd.

Data aanroepen

Dan komen we nu toe aan het grootste en moeilijkste deel, de javascript code. Er zijn een aantal dingen die we met javascript moeten gaan regelen:

  • We moeten de applicatie gaan vertellen wat we willen zien
    De query bestaat uit XML en die moeten we gaan opbouwen via Javascript.
  • We moeten de applicatie gaan vertellen hoe we het willen weergeven.

Query

De eerste stap is het aanroepen van de SharePoint list en definiëren wat we willen zien van die list.

var MyItemsRepository = function () {
this.QueryListOptions = function (query, viewFields, options) {
var result;

$().SPServices({
operation: "GetListItems",
async: false,
listName: "My Items",
webURL: commonSiteCollectionUrl,
CAMLQuery: query,
CAMLViewFields: viewFields,
CAMLQueryOptions: options,
completefunc: function (xData, Status) {
result = xData;
}
});

return result;
}

// Verderop in de tutorial maken we nog een stukje code aan dat nodig is om de attachments op te roepen, zet die code hier
}

var myItemsRepository = new MyItemsRepository();

In dit stukje code wordt een call gemaakt naar SharePoint en wordt de list met de naam ‘My Items’ aangeroepen. Hier wordt achter de schermen de ‘jQuery library for SharePoint Web Services’ voor gebruikt. Vervolgens zien we een aantal parameters Waar de lettercombinatie CAML in staat. CAML staat voor ‘Collaborative Application Markup Language’. Dit is een op XML gebaseerde taal die in SharePoint wordt gebruikt om fields en views te definiëren. De waarden van deze CAML parameters die je in de bovenstaande code ziet, zijn variabelen die we later gaan definiëren.

CamlDesigner2013

Als je veel verstand hebt van CAML en/of XML, zou je de queries zelf kunnen schrijven. Dit is echter niet nodig, want er bestaat een heel handige tool voor: CamlDesigner2013. Deze vind je hier.

Omdat ik niet zo goed ben in CAML en XML, ga ik deze tool gebruiken om de juiste query te genereren. Als je de tool wilt gebruiken is het van belang dat je hem installeert op een machine die toegang heeft tot je SharePoint site. De CamlDesigner2013 gaat namelijk een connectie maken met de site, om de site (en dus ook onze list) uit te kunnen lezen.

Omdat deze tutorial niet over CamlDesigner gaat, ga ik niet uitgebreid beschrijven hoe het werkt. Ik vertel slechts kort welke stappen je moet nemen in de tool om het voor nu gewenste resultaat te bereiken.

  1. Verbind CamlDesigner als eerste met de SharePoint site waarin de betreffende list staat.
    Rechts bovenin staat een knop ‘Connection’.
  2. Selecteer links in het menu de juiste list (in mijn geval ‘My Items’).
  3. Nu gaan we de code genereren:
    1. Klik, in het middelste venster bovenin, op ‘Where’.
      Sleep het field ‘ID’ naar de rechterkant en typ ‘id’ in de input.
      Je ziet nu onderin de code verschijnen die je hebt gegenereerd.
    2. Klik, weer in het middelste venster bovenin, op ‘ViewFields’.
      Sleep nu het field ‘Attachments’ naar de rechterkant.
      (zie de code weer verschijnen onderin)
    3. Klik, weer in het middelste venster bovenin, op ‘Query Options’.
      Vink ‘Include Attachments URL’s’ aan.

De XML code die we nodig hebben is nu gegenereerd. We kunnen het nu gaan toepassen in het volgende stukje javascript.

Query Part II

In de Javascript code hieronder komt de code die we met de CamlDesigner hebben gemaakt weer terug. De output van de CamlDesigner is hier als waarde toegevoegd aan de variabelen (query, viewFields en options) die we in het volgende stukje code hebben aangeroepen.

Vergeleken met wat de CamlDesigner heeft uitgespuugd, maken we nog een paar kleine wijzigingen:

  1. Rondom de <Where> tag zetten we nog een <Query> tag. Dat heeft de CamlDesigner namelijk nog niet voor ons gedaan.
  2. In de <Value> tag (binnen de <Where> tag), heeft de CamlDesigner een foutje gemaakt. Die heeft er namelijk Type='Counter' van gemaakt, maar wij willen graag Type='Text' zien.
  3. In dezelfde <Value> tag willen we niet ‘id’ als onderdeel van de XML, maar we willen dat daar via Javascript de id wordt aangeroepen. Verander daarom ‘id’ naar ‘" + id + "’ zoals in onderstaande code.

Je uiteindelijke code moet dus vergelijkbaar zijn met onderstaande code.

// Plaats onderstaande code op de plaats waar de comment in het stuk code eerder in deze tutorial dat aangeeft

this.GetById = function (id) {
var query = "<Query>
<Where>
<Eq>
<FieldRef Name='ID'/>
<Value Type='Text'>" + id + "</Value>
</Eq>
</Where>
</Query>";

var viewFields = "<ViewFields>
<FieldRef Name='Attachments' />
</ViewFields>";

var options = "<QueryOptions>
<IncludeAttachmentUrls>TRUE</IncludeAttachmentUrls>
</QueryOptions>";

var data = this.QueryListOptions(query, viewFields, options);

var count = $(data.responseXML).SPFilterNode("rs:data").attr("ItemCount");

if (count > 0) {
return data;
}

return null;
}

Voor de leesbaarheid van deze tutorial heb ik wat extra linebreaks en spacing aan de code toegevoegd. Normaal gesproken staat de gehele XML code op één regel.

Back to the point: Wat doet deze code nou precies?
Als eerste wordt een anonieme function gedefinieerd, die verwijst naar de variabele ‘MyItemsRepository’ (zie het stukje javascript eerder in deze tutorial) via het this keyword. this.GetById roept dus een item uit de list ‘My Items’ aan, aan de hand van de ID’s van de items. Vervolgens zorgen de variabelen ‘query’, ‘viewFields’ en ‘options’ dat de CAML query wordt samengesteld, die de juiste gegevens uit onze SharePoint list haalt.
Hierna maken we een variabele ‘ data’ aan, die de bovenstaande 3 variabelen samenvoegt en als laatste wordt van het geselecteerde item ieder (kunnen er meerdere zijn) attachment opgehaald. Het if statement op het eind kijkt of er überhaupt attachments zijn. Als dat zo is worden ze opgehaald en als er geen attachments zijn is de output null.

Data weergeven

Nu dat we de data hebben opgehaald, gaan we door middel van Javascript bepalen hoe we die data willen weergeven. We gaan de attachments in HTML list items weergeven, we gaan er klikbare links van maken en we gaan de URL’s inkorten.

De code die dat doet ziet er als volgt uit:

var MyItemsController = function () {

var MyItem;

this.showMyItemDetails = function (I_ID) {
if (myItem != "0") {

var xData = MyItemsRepository.GetById(I_ID);

if (xData != null) {
$(xData.responseXML).SPFilterNode("z:row").each(function () {

// Attachments weergeven
if ($(this).attr("ows_Attachments")) {
liHtml = [];

var attachments = $(this).attr("ows_Attachments").split(';#');

if (attachments !== undefined && attachments != null) {
for (var i = 0; i < attachments.length; i++) {
if (attachments[i] !== undefined && attachments[i] != null) {
if (attachments[i].length > 1) {
var fileName = attachments[i].split('/');

liHtml.push('<li><a href="' + attachments[i] + '">' + fileName
[fileName.length - 1] + '<a/></li>');

}
}
};
}

$('#listAttachments').html(liHtml.join(""));
}
});
}
}
}
}

Deze code begint met het kijken of er list items zijn, en als dat zo is worden die list items opgeroepen. Vervolgens begint onder de comment ‘Attachments weergeven’ de code die de Attachments aanroept en weergeeft. Als eerste wordt het field ‘ows_Attachments’ (zo heet het attachments field in de SharePoint list) opgezocht, waarvan de inhoud vervolgens wordt omgezet in een array.

Daarna wordt de variabele ‘attachments’ aangemaakt, waarin de opgehaalde attachments worden gesplitst. Dat is nodig omdat de attachments standaard gezamenlijk als één lange string worden weergegeven. Ieder attachment begint met ;#, dus daar gaan we op splitsen. Omdat de ;# voor ieder attachment staat, inclusief voor het eerste attachment, denkt de code dat ook voor het eerste attachment nog een item is. Die moeten we eruit filteren om te voorkomen dat het resulteert in een leeg eerste (HTML) list item in de uiteindelijke output.

De volgende stap is dat we met de for loop door de attachments heen gaan. In attachments[i] zit nu de URL van het attachment. De code vervolgt zich met twee if statements. De eerste kijkt of er überhaupt attachments aanwezig zijn, de tweede kijkt of de lengte van de attachment URL (attachments[i]) groter is dan 1. Met deze laatste if filteren we het eerste lege array item dat door de split in de array terecht is gekomen.

Vervolgens gebruiken we var fileName = attachments[i].split('/'); welke zorgt dat de totale URL van het attachment wordt gesplit op de /. De fileName variabele bevat nu een array met in elk item van de array een stukje van de URL. Met behulp van fileName[fileName.length - 1] vragen we het laatste stukje van de URL van het attachment op, de echte bestandsnaam.

Hoe werkt dit dan?
Nou, fileName.length geeft het totaal aantal items in de array terug. Als de array 1 item zou bevatten dan zou fileName.length ‘1’ zijn. Omdat de index van een array bij ‘0’ begint, verwijst fileName[fileName.length] naar een niet bestaand item en dus ontstaat er een foutmelding.

Ter illustratie:

laten we nu de ‘- 1’ weg, dan zou de code, in het geval van 4 items in de array, gaan zoeken naar item nummer 4 terwijl hij nummer 3 moet hebben.

Enfin, Door bovenstaande kan je dus in plaats van een hele lange URL, alleen de bestandsnaam weergeven, wat het lijstje attachments een stuk leesbaarder maakt.

In de regel erna worden de attachments in een <li> en een <a> gestopt, zodat de output een keurige HTML list wordt met een klikbare link in ieder list item. De laatste regel vervolgens, koppelt de output aan de <ul> met het id (#) listAttachments, zodat onze output in dat element wordt weergegeven.

Afronden

We zijn er bijna. Het laatste wat we nu nog gaan doen is een paar regeltjes CSS toevoegen, zodat onze HTML output toonbaar is. Natuurlijk kan je dit zelf naar wens aanpassen.

#container {
float:left;
height:200px;
width:300px;
}

#container h3 {
float:left;
width:100%;
}

#listAttachments {
float:left;
width:100%;
margin:10px 0;
padding:0;
}

#listAttachments li {
float:left;
width:100%;
margin:5px 0;
}

Bovenstaande CSS zorgt voor een box van 200x300 pixels met bovenin de header ‘Attachments’ en daaronder de lijst met attachments, keurig onder elkaar weergegeven met wat ruimte tussen ieder element.

Nu is het tijd om je solution te deployen. Als je solution is geïnstalleerd en de feature(s) is/zijn geactiveerd, zie je nu je attachments op de pagina waarop je de HTML hebt toegevoegd.