Google Maps application for
Google Maps application for
Google Maps application for
You also want an ePaper? Increase the reach of your titles
YUMPU automatically turns print PDFs into web optimized ePapers that Google loves.
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
<strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong><br />
Microsoft Sharepoint<br />
David Kaae Frøhlich Sørensen<br />
Løbenummer:<br />
IMM-B.Eng-2009-31<br />
Denne rapport indeholder 64 sider, inklusiv denne, eksklusiv kildekode.<br />
1
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Indholds<strong>for</strong>tegnelse<br />
Indholds<strong>for</strong>tegnelse .............................................................................................................................. 2<br />
Indledning ............................................................................................................................................ 5<br />
Forkortelser .......................................................................................................................................... 6<br />
Applikationens plat<strong>for</strong>me ..................................................................................................................... 7<br />
Hvad er <strong>Google</strong> <strong>Maps</strong>? .................................................................................................................... 7<br />
Hvad er Microsoft Sharepoint? ........................................................................................................ 8<br />
Analyse................................................................................................................................................. 9<br />
Problemstilling ................................................................................................................................. 9<br />
Usecase........................................................................................................................................... 10<br />
Usecasediagram ......................................................................................................................... 10<br />
Usecase beskrivelser .................................................................................................................. 11<br />
Datatyper .................................................................................................................................... 15<br />
Delkonklusion – Analyse ............................................................................................................... 16<br />
Design ................................................................................................................................................ 17<br />
Brugergrænseflade ......................................................................................................................... 17<br />
Mockup ...................................................................................................................................... 17<br />
Data ................................................................................................................................................ 19<br />
<strong>Google</strong> <strong>Maps</strong> markeringstyper ................................................................................................... 19<br />
Sharepoint data ........................................................................................................................... 20<br />
Applikation data ......................................................................................................................... 21<br />
Applikationens opbygning ............................................................................................................. 22<br />
Applikationen som bindeled ...................................................................................................... 22<br />
3-Lags model (Model-View-Controller) .................................................................................... 23<br />
Grafisk design ............................................................................................................................ 24<br />
Databehandling .......................................................................................................................... 24<br />
2
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Delkonklusion – Design ................................................................................................................. 25<br />
Implementering .................................................................................................................................. 26<br />
Brugergrænseflade ......................................................................................................................... 26<br />
Konfigurationsvariabler ............................................................................................................. 26<br />
Brug af usercontroller ................................................................................................................ 27<br />
<strong>Google</strong> Map................................................................................................................................ 28<br />
Backend .......................................................................................................................................... 34<br />
DataMapper ................................................................................................................................ 34<br />
Controller ....................................................................................................................................... 36<br />
Hjælpeklasse .................................................................................................................................. 37<br />
Applikationens opbygning ............................................................................................................. 38<br />
Interfaces ........................................................................................................................................ 40<br />
Data ................................................................................................................................................ 41<br />
SharePoint data .......................................................................................................................... 41<br />
Applikationsdatatyper ................................................................................................................ 49<br />
<strong>Google</strong> <strong>Maps</strong> data ...................................................................................................................... 50<br />
Dynamisk data................................................................................................................................ 51<br />
Tilgængelighed........................................................................................................................... 52<br />
Brug af data. ............................................................................................................................... 53<br />
Delkonklusion – Implementering................................................................................................... 56<br />
Test ..................................................................................................................................................... 58<br />
Delkonklusion – Test ..................................................................................................................... 60<br />
Konklusion ......................................................................................................................................... 61<br />
Perspektivering................................................................................................................................... 62<br />
Udvidelses ideer ............................................................................................................................. 64<br />
Underskrift ......................................................................................................................................... 64<br />
3
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Appendiks .......................................................................................................................................... 65<br />
Test ................................................................................................................................................. 65<br />
ScreenShot ..................................................................................................................................... 69<br />
Kildekode ........................................................................................................................................... 84<br />
4
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Indledning<br />
Denne rapport er en del af Diplom IT eksamensprojektet fra DTU. Den omhandler brugen af online<br />
tjenesten <strong>Google</strong> <strong>Maps</strong> i en webapplikation, og udviklingen af GIS. GIS står <strong>for</strong> ”Geografisk<br />
In<strong>for</strong>mationssystem”. GIS bruges om systemer, hvor data præsenteres ved markeringer på et kort.<br />
Rapporten er inddelt i følgende afsnit: Analyse og kravspecifikation, Design, Implementering, Test<br />
med gennemgang af brugen af produktet, Perspektivering hvor <strong>Google</strong> <strong>Maps</strong> sammenlignes med<br />
andre lignende services og til sidst en Konklusion på rapporten.<br />
Applikationen er udviklet i ASP.NET og til at køre på en MOSS 2007. MOSS 2007 er Microsoft<br />
Office SharePoint Server. Applikationen henter data fra Microsoft SharePoint. Men der er lagt vægt<br />
på, at designet og implementeringen af applikationen er lavet, så dele af den nemt vil kunne<br />
udskiftes, og <strong>for</strong> eksempel hente data fra andet sted end SharePoint.<br />
5
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Forkortelser<br />
I tabellen herunder <strong>for</strong>klares nogle af rapportens <strong>for</strong>kortelser og engelske udtryk. Denne tabel er<br />
lavet i håb om at <strong>for</strong>bedre læsningen af rapporten.<br />
Forkortelse Forklaring<br />
ASP.NET Microsofts .Net struktur (framework) til webprogrammering.<br />
MOSS eller MOSS 2007 Microsoft Office SharePoint Server – Microsofts svar på en portal til<br />
store samarbejdsportaler, dokumentstyring og videndeling.<br />
API Application Programming Interface – Dette er en samling af<br />
metoder, som stilles til rådighed og giver mulighed <strong>for</strong> andre<br />
systemer at snakke med den givne applikation. For eksempel <strong>Google</strong><br />
<strong>Maps</strong> API, er en samling metoder, så man kan kommunikere med<br />
<strong>Google</strong> <strong>Maps</strong>.<br />
MVC Model View Controller – En programmerings arkitektur, som deler<br />
et program op i 3 lag. Opdelingen gør det nemmere at vedligeholde,<br />
programmerne og/eller erstatte enkelte dele.<br />
WPF Windows Presentation Foundation – En .NET struktur (framework),<br />
som var planlagt til at erstatte WinForms til udvikling af Windows<br />
programmer.<br />
GUID “Globally Unique Identifier” – Dette er et identificerings nummer,<br />
som er unikt <strong>for</strong> hvert element/objekt i en applikation.<br />
Event En begivenhed eller en handling. Et event er typisk et bruger input<br />
til en kontrol. For eksempel kan det være når brugeren trykker på en<br />
knap, eller indtaster tekst i et felt.<br />
KML Keyhole Markup Language – Dette er en XML standard udviklet af<br />
<strong>Google</strong> til at udtrykke geografisk data og visuelle markeringer.<br />
IIS Internet In<strong>for</strong>mation Services – Dette er en Microsoft tjeneste<br />
(service), som gør Windows brugbar som webserver.<br />
GIS Geografiske In<strong>for</strong>mationssystemer<br />
6
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Applikationens plat<strong>for</strong>me<br />
I dette afsnit vil der blive redegjort <strong>for</strong> den teori, som ligger til grund <strong>for</strong> udviklingen af<br />
applikationen. Dette er nyttig baggrundsviden, som <strong>for</strong> eksempel, lidt teori om hvad <strong>Google</strong> <strong>Maps</strong><br />
er, og hvordan man programmerer op mod <strong>Google</strong> <strong>Maps</strong>. Teori afsnittet vil også indeholde et kort<br />
afsnit om Microsoft Sharepoint, som applikationen vil blive udviklet til.<br />
Hvad er <strong>Google</strong> <strong>Maps</strong>?<br />
<strong>Google</strong> <strong>Maps</strong> er en del af det åbne internet. Det bygger på en Web 2.0 tankegang, hvor de primære<br />
ideer er, at viden skal være tilgængelig og at viden skal skabes i fællesskab. Nogle tidlige eksempler<br />
på Web 2.0 var Blogs og Wikis. Men også sider som Facebook, Myspace og lignende er gode Web<br />
2.0 eksempler. I alle disse eksempler er det brugerne, som skaber sidens indhold. Andre eksempler<br />
er tagclouds, hvor viden bliver grupperet ud fra brugernes tags. Men også <strong>Google</strong> <strong>Maps</strong> er Web 2.0,<br />
her består åbenheden i det frie API, som er offentligt tilgængeligt og gratis at benytte. Det står alle<br />
frit <strong>for</strong>, at oprette geografisk data, og lægge det på et kort ved hjælp af <strong>Google</strong> <strong>Maps</strong>.<br />
<strong>Google</strong> <strong>Maps</strong> er en af mange online services, hvor data kan blive repræsenteret på et kort. Disse<br />
data er de såkaldte geodata (geografiske data). Neden<strong>for</strong> ses et billede af <strong>Google</strong> <strong>Maps</strong>’ egen<br />
hjemmeside, hvor deres egen service benyttes.<br />
7
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
<strong>Google</strong> har lavet en række API’er 1 , som er tilgængelige <strong>for</strong> programmører, hvis de ønsker at<br />
implementere et <strong>Google</strong> kort i deres hjemmeside. API står <strong>for</strong> ”Application programming<br />
interface”. Et API består af en række metoder, som udviklerne af applikationen har stillet til<br />
rådighed <strong>for</strong> andre udviklere. I dette tilfælde, har <strong>Google</strong> stillet en række API’er til rådighed <strong>for</strong><br />
andre udviklere, som kan benytte disse API’er og deres metoder til at programmere op i mod<br />
<strong>Google</strong> <strong>Maps</strong>. De <strong>for</strong>skellige API’er er: ”<strong>Google</strong> <strong>Maps</strong> Javascript API”, hvor programmøren via<br />
javascript kan loade <strong>for</strong>skellige kort og lægge lag af data hen over. Javascript er et objektorienteret<br />
scriptsprog, som de fleste moderne webbrowsere er i stand til at læse. Javascript eksekveres på<br />
klient siden i en webkommunikation mellem klient og server. Et andet API er ”<strong>Google</strong> <strong>Maps</strong> API<br />
<strong>for</strong> Flash”, som giver programmøren mulighed <strong>for</strong> det samme, via flash. Et tredje er ”<strong>Google</strong> Static<br />
<strong>Maps</strong> API”, som loader kort og data via url parametre. Den sidste og fjerde mulighed <strong>for</strong> at indsætte<br />
et kort på en hjemmeside er ved at få <strong>Google</strong> til at generere den nødvendige html kode. Dette sker<br />
ved, at man går ind på www.maps.google.dk og søger sig frem til det kort man ønsker. Derefter<br />
trykker man ”link” og man kan nu kopiere den html, som bliver genereret. Hvis man indsætter<br />
html’en i sin hjemmeside, vil man få et kort tilsvarende det man havde søgt sig frem til. Dette er<br />
ligesom ”<strong>Google</strong> Static <strong>Maps</strong> API” en statisk måde at få vist sit kort på.<br />
I dette projekt vil det første API blive benyttet, som er ”<strong>Google</strong> <strong>Maps</strong> Javascript API”, da vi ønsker<br />
muligheden <strong>for</strong> dynamisk, at kunne lægge geodata på vores kort.<br />
Hvad er Microsoft Sharepoint?<br />
Microsoft Sharepoint er en webbaseret portal. Denne portal har videndeling og dokumentstyring<br />
som primære <strong>for</strong>mål. Gennem Microsoft Sharepoint har man adgang til dokumentbiblioteker, blogs,<br />
wikis og andre specialiserede websteder. På disse websteder kan man indsætte tilpassede webdele.<br />
Det er sådan en tilpasset webdel, som denne applikation vil benytte sig af.<br />
Microsoft Sharepoint har et avanceret rettighedssystem, hvor rettigheder kan gives til grupper eller<br />
enkelte brugere på alt fra webstedsniveau og ned til folderniveau i en filstruktur. Da Sharepoint<br />
indeholder dette rettighedssystem, vil dette blive benyttet i applikationen.<br />
Microsoft Sharepoint applikationer er skrevet i ASP.NET 2.0 og kører på Microsofts IIS og har en<br />
Microsoft SQL Database, som underliggende database.<br />
I den nuværende version, går Microsoft Sharepoint under navnet MOSS 2007. Dette vil ændre sig<br />
inden <strong>for</strong> det næste halve år, hvor 2010 versionen udkommer. Denne vil gå under navnet Sharepoint<br />
2010.<br />
1 <strong>Google</strong> <strong>Maps</strong> API: http://code.google.com/intl/da/apis/maps/documentation/index.html<br />
8
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Analyse<br />
I dette afsnit, vil der blive opsat en problem<strong>for</strong>mulering, som præciserer hvad applikationen skal<br />
kunne. Dette afsnit vil bygge videre på de krav der kort blev nævnt i indledningen.<br />
Analysen vil være opbygget som en samlet problem<strong>for</strong>mulering, med en kort problemstilling og<br />
nogle mere dybdegående usecase analyser.<br />
Problemstilling<br />
Der skal undersøges, hvorledes <strong>Google</strong> <strong>Maps</strong> fungerer, og om man kan lave en applikation, som<br />
kan læse data og vise dem geografisk ved hjælp af <strong>Google</strong> <strong>Maps</strong>. Altså en GIS applikation med<br />
brug af <strong>Google</strong> <strong>Maps</strong> tjenesten.<br />
Applikationen skal kunne læse <strong>for</strong>skellige typer af data og vise dem på et kort. Med dette menes,<br />
data som <strong>for</strong> eksempel steder, ruter, områder m.m. Til disse data skal der kunne vises in<strong>for</strong>mationer<br />
i <strong>for</strong>m af blandt andet tekst og billeder.<br />
Applikationen skal være opbygget, så datalaget, også kaldet backend delen, nemt ville kunne<br />
udskiftes. Med datalaget menes den del af applikationen, som kommunikerer med datakilden. Der<br />
skal laves en undersøgelse af, hvor tilgængeligt geografisk data er, og hvordan offentlig tilgængeligt<br />
data kan tilgås og vises i applikationen.<br />
I resten af rapporten vil en kommune ind imellem blive inddraget som <strong>for</strong>klarende eksempel. Det<br />
kan eventuelt være som eksempel på brugen af en markør. Dog bliver applikationen ikke udviklet<br />
som en kommune specifik løsning. Der vil blive lagt stor vægt på fleksibilitet under<br />
implementeringen. Der vil blive lagt vægt på at skabe en system arkitektur, som gør det muligt at<br />
udskifte og genbruge centrale dele af koden. Der vil også blive lagt vægt på at gøre applikationen<br />
fleksibel i dens brugervenlighed. Det skal være nemt at indstille applikationen og dens datatyper, så<br />
de passer til <strong>for</strong>skellige typer af brugere. For eksempel Kommuner, virksomheder, privat personer<br />
osv.<br />
<strong>Google</strong> <strong>Maps</strong> og Sharepoint er to <strong>for</strong>skellige systemer, som kodes i hver sit sprog og hver har deres<br />
specifikke måde at arbejde med data på. Ud over at give en masse funktionalitet skal applikationen<br />
også være et bindeled mellem de to <strong>for</strong>skellige systemer, Sharepoint og <strong>Google</strong> Map.<br />
9
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Usecase<br />
Til at oprette et usecasediagram og de dertil hørende usecase beskrivelser, bliver der taget<br />
udgangspunkt i, hvordan en kommune vil kunne benytte denne applikation. Applikationen vil ikke<br />
være specifikt udviklet til kommuner, men da kommuner har institutioner i mange <strong>for</strong>skellige<br />
størrelser, vil disse være gode som udgangspunkt. Som eksempel, vil man inden <strong>for</strong> kommuner<br />
kunne finde både områder, lokaliteter, ruter, afstande m.m. Disse ting er ideelle at vise på et kort.<br />
Usecasediagram<br />
Neden<strong>for</strong> ses et usecase diagram over systemet. Diagrammet er opdelt i system og aktører.<br />
Aktørerne kan påvirke systemet gennem en række usecases. Disse usecases er de hvide cirkler, som<br />
blandt andet er ”opret markering” eller ”søg i markeringer”.<br />
Aktørerne er opdelt i to grupper. En bruger og administratorer. Brugerne har mulighed <strong>for</strong> at<br />
benytte applikationen til at søge og få vist data. I et kommuneeksempel, kunne denne bruger <strong>for</strong><br />
eksempel være en anonym borger, som via sin browser kom ind på hjemmesiden, hvor<br />
applikationen lå. Her ville han kunne få vist et kort og de geografiske data, som er indtastet i<br />
systemet. Det kunne være, at borgeren havde behov <strong>for</strong> at finde kommunens genbrugsstationer. Han<br />
kunne gå ind på kommunens hjemmeside, og søge eller klikke sig frem til genbrugsstationer og se<br />
deres placeringer på kortet. Han vil måske have behov <strong>for</strong> at finde den nærmeste og en rute dertil.<br />
Dette vil han kunne gøre via <strong>Google</strong> <strong>Maps</strong> applikationen.<br />
En anden type af bruger kunne være en sagsbehandler. Man kunne <strong>for</strong>estille sig, at sagsbehandleren<br />
havde behov <strong>for</strong> at finde in<strong>for</strong>mation omkring, kommunens faciliteter, når han behandler en borgers<br />
sag. Han vil på samme måde som brugeren kunne klikke sig frem til de korrekte in<strong>for</strong>mationer, eller<br />
bruge søgemuligheden.<br />
Administratoren har rettigheder til at oprette og vedligeholde data. Han kan specificere markeringer,<br />
markeringstyper og markeringsikoner. Hvis administratoren vil have vist de geografiske data, som<br />
han har tastet ind, vil han selvfølgelig kunne agere som bruger. Dette er dog valgt ikke at blive<br />
tegnet ind på usecasediagrammet af hensyn til overskueligheden.<br />
10
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Aktører:<br />
Bruger<br />
Udvælg<br />
markering<br />
Søg i<br />
markeringerne<br />
Vis markering<br />
af område<br />
Vis punkt<br />
markering<br />
Vis rute<br />
markering<br />
System<br />
Opret/<br />
Vedligehold<br />
Markering<br />
Opret/<br />
Vedligehold<br />
markeringstyper<br />
Opret/Vedligehold<br />
markeringsikoner<br />
Aktører:<br />
Administrator<br />
Usecase beskrivelser<br />
Neden<strong>for</strong> vil alle usecases blive gennemgået. Hver usecase vil blive beskrevet med pre- og postkondition,<br />
aktører og en gennemgang af den kommunikation der vil ske mellem aktøren og<br />
systemet.<br />
Opret/Vedligehold Markering<br />
Der vil ikke være den store <strong>for</strong>skel på oprettelse og vedligeholdelse. Det er tiltænkt, at samme<br />
<strong>for</strong>mular <strong>for</strong> markeringen skal bruges.<br />
Pre-kondition<br />
Administratoren vil være logget ind.<br />
Post-kondition<br />
En markering vil være oprettet i systemet.<br />
Aktører<br />
Administrator.<br />
11
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Gennemgang af kommunikationen<br />
1. Aktøren vælger ”Opret Område”, ”Opret Punkt” eller ”Opret Rute”.<br />
2. Systemet viser oprettelses<strong>for</strong>mularen <strong>for</strong> den valgte type.<br />
3. Aktøren indtaster de nødvendige data.<br />
a. Aktøren indtaster Titel<br />
b. Aktøren indtaster Beskrivelse<br />
c. Aktøren indtaster/angiver Koordinat<br />
4. Aktøren trykker ”opret”<br />
5. Systemet godkender eller afviser oprettelsen<br />
a. Systemet har godkendt oprettelsen og <strong>for</strong>mularen skjules igen.<br />
b. Systemet afviser oprettelsen og giver en <strong>for</strong>klarende fejlbesked.<br />
6. Hvis oprettelsen er godkendt, kan kommunegrænsen nu vælges og ses på kortet.<br />
Opret/Vedligehold Markeringstype<br />
Der vil ikke være den store <strong>for</strong>skel på oprettelse og vedligeholdelse. Det er tiltænkt, at samme<br />
<strong>for</strong>mular <strong>for</strong> markeringstypen skal bruges.<br />
Pre-kondiion<br />
Administratoren vil være logget ind.<br />
Post-kondition<br />
En markeringstype vil være oprettet i systemet.<br />
Aktører<br />
Administrator.<br />
Gennemgang af kommunikationen<br />
1. Aktøren vælger ”Opret markeringstype”.<br />
2. Systemet viser oprettelses<strong>for</strong>mularen <strong>for</strong> den valgte type.<br />
3. Aktøren indtaster de nødvendige data.<br />
a. Aktøren indtaster titel <strong>for</strong> markeringstypen<br />
b. Aktøren angiver hvor i en hierarkisk struktur at typen hører til.<br />
4. Aktøren trykker ”opret”<br />
5. Systemet godkender eller afviser oprettelsen<br />
a. Systemet har godkendt oprettelsen og <strong>for</strong>mularen skjules igen.<br />
b. Systemet afviser oprettelsen og giver en <strong>for</strong>klarende fejlbesked.<br />
6. Hvis oprettelsen er godkendt, kan markeringstypen bruges ved oprettelse af nye markeringer<br />
eller udvælgelse og visning af markeringer.<br />
Opret/Vedligehold Markeringsikon<br />
12
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Der vil ikke være den store <strong>for</strong>skel på oprettelse og vedligeholdelse. Det er tiltænkt, at samme<br />
<strong>for</strong>mular <strong>for</strong> markeringsikonet skal bruges.<br />
Pre-kondition<br />
Administratoren vil være logget ind.<br />
Post-kondition<br />
Et nyt ikon vil være oprettet i systemet.<br />
Aktører<br />
Administrator.<br />
Gennemgang af kommunikationen<br />
1. Aktøren vælger ”Tilføj nyt ikon”.<br />
2. Systemet beder aktøren om at oploade det nye ikon.<br />
3. Aktøren oploader ikonet.<br />
4. Systemet beder aktøren navngive ikonet.<br />
5. Aktøren navngiver ikonet med en titel.<br />
6. Aktøren trykker ”Godkend”.<br />
7. Systemet godkender eller afviser oprettelsen<br />
a. Systemet har godkendt oprettelsen og <strong>for</strong>mularen skjules igen.<br />
b. Systemet afviser oprettelsen og giver en <strong>for</strong>klarende fejlbesked.<br />
8. Hvis oprettelsen er godkendt, kan ikonet tilknyttes punkt markeringer ved oprettelse eller<br />
redigering af disse.<br />
Udvælg Markering<br />
Selvom der er <strong>for</strong>skellige typer<br />
Pre-kondition<br />
Bruger har åbnet siden med applikationen på.<br />
Post-kondition<br />
Den udvalgte markering er vist på kortet.<br />
Aktører<br />
Bruger.<br />
Gennemgang af kommunikationen<br />
1. Aktøren åbner siden med applikationen.<br />
2. Systemet viser siden.<br />
3. Aktøren trykker på en markeringstype i listen over markeringstyper.<br />
4. Systemet finder alle data relevante <strong>for</strong> den valgte type og viser dem på kortet.<br />
13
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
5. Aktøren kan nu indsnævre sin udvælgelse, hvis der er specificeret undertyper under den<br />
allerede valgte.<br />
6. Systemet viser de relevante data på kortet.<br />
7. Aktøren kan få vist beskrivelser omkring dataene ved at holde musen over, eller trykke på<br />
markørerne på kortet.<br />
Søg i markeringer<br />
Pre-kondition<br />
Bruger har åbnet siden med applikationen på.<br />
Post-kondition<br />
Den fremsøgte markering er vist på kortet.<br />
Aktører<br />
Bruger.<br />
Gennemgang af kommunikationen<br />
1. Aktøren åbner siden med applikationen.<br />
2. Systemet viser siden.<br />
3. Aktøren indtaster søgeord i søgetekstfeltet.<br />
4. Aktøren trykker ”søg”.<br />
5. Systemet finder alle data der er relevante <strong>for</strong> det indtastede søgeord.<br />
6. Systemet viser søgeresultatet på en overskuelig måde.<br />
7. Aktøren trykker på et af søgeresultaterne.<br />
8. Systemet viser det valgte resultat på kortet.<br />
Vis punkt markeringer<br />
Pre-kondition<br />
Bruger har åbnet siden med applikationen på.<br />
Post-kondition<br />
Det fremsøgte punkt er vist korrekt på kortet.<br />
Aktører<br />
Bruger.<br />
Gennemgang af kommunikationen<br />
1. Aktøren åbner siden med applikationen.<br />
2. Systemet viser siden.<br />
3. Aktøren udvælger en markeringstype, som har tilknyttet en punktmarkering.<br />
4. Systemet finder alle data der er relevante <strong>for</strong> den valgte type.<br />
5. Systemet viser punkter med ikon, titel og beskrivelse på deres korrekte position.<br />
14
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Vis rute markeringer<br />
Pre-kondition<br />
Bruger har åbnet siden med applikationen på.<br />
Post-kondition<br />
Det fremsøgte punkt er vist korrekt på kortet.<br />
Aktører<br />
Bruger.<br />
Gennemgang af kommunikationen<br />
1. Aktøren åbner siden med applikationen.<br />
2. Systemet viser siden.<br />
3. Aktøren udvælger en markeringstype, som har tilknyttet en rutemarkering.<br />
4. Systemet finder alle data der er relevante <strong>for</strong> den valgte type.<br />
5. Systemet viser ruter med startpunkt, slutpunkt, rute imellem punkterne og eventuelt en<br />
vejledning.<br />
Vis markering af område<br />
Pre-kondition<br />
Bruger har åbnet siden med applikationen på.<br />
Post-kondition<br />
Det fremsøgte punkt er vist korrekt på kortet.<br />
Aktører<br />
Bruger.<br />
Gennemgang af kommunikationen<br />
1. Aktøren åbner siden med applikationen.<br />
2. Systemet viser siden.<br />
3. Aktøren udvælger en markeringstype, som har tilknyttet markeringer i typen område.<br />
4. Systemet finder alle data der er relevante <strong>for</strong> den valgte type.<br />
5. Systemet viser områdemarkeringen med et farvet polygon og en farvet flade imellem<br />
polygonkanterne.<br />
6. Aktøren kan få vist områdets beskrivelse ved at trykke på området.<br />
Datatyper<br />
Ud fra en kommune som et tænkt eksempel på en kunde til dette system, kan vi <strong>for</strong>stille os følgende<br />
data kunne være relevant at få vist på et kort.<br />
Områder som Kommunegrænsen, Parkeringspladser, Grønne områder osv.<br />
15
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Institutioner som Rådhus, Ældreboliger osv.<br />
Begivenheder, som <strong>for</strong> eksempel en Koncert eller en Festival.<br />
Hjemmeplejeruter, så sagsbehandlere vil kunne svare på, hvornår de ældre får besøg.<br />
Vi kan se, at der kan være behov <strong>for</strong> <strong>for</strong>skellige markeringstyper på kortet. Man kunne også<br />
<strong>for</strong>estille sig, at et kort med mange punkter kunne være svært at overskue. Der skal der<strong>for</strong> være<br />
mulighed <strong>for</strong> at simplificere markeringerne, når der er behov <strong>for</strong> større overblik.<br />
Neden<strong>for</strong> er markeringerne skrevet op på punkt<strong>for</strong>m, med deres tilhørende grafiske udseender.<br />
Kommunegrænse, Parkeringspladser, Grønne områder osv.<br />
o Område<br />
Institution, Rådhus, Ældreboliger osv.<br />
o Punkt<br />
o Område (Kunne være et dækningsområde (<strong>for</strong> eksempel dækningsområde af et<br />
hjemmeplejecenter) eller et tilhørende areal til institutionen)<br />
Begivenhed, Koncert, Festival osv.<br />
o Punkt eller Område alt efter begivenheden<br />
Rute<br />
o Rute<br />
Der ses, at det kunne være relevant at have markeringer der dækker større områder, enkelte punkter<br />
og eventuelt ruter og afstande mellem to punkter.<br />
Delkonklusion – Analyse<br />
Der er i analyseafsnittet blevet opstillet en række krav, som skal være opfyldte <strong>for</strong> at give den<br />
færdige applikation den ønskede funktionalitet og brugervenlighed. Der er blevet opstillet krav til<br />
data<strong>for</strong>mater og funktionalitet <strong>for</strong> henholdsvis brugere og administratorer.<br />
16
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Design<br />
I dette afsnit, vil designet af applikationen blive beskrevet. Afsnittet er delt op i tre underafsnit, hvor<br />
det ene er det grafiske design, det som slutbrugeren ser. Dette afsnit er kaldt ”Brugergrænsefalde”.<br />
Det andet afsnit omhandler databehandlingen. Her beskrives hvordan data i systemet skal være<br />
struktureret og tilgængeligt. Dette afsnit hedder ”Data”. Det sidste afsnit beskriver applikationens<br />
overordnede design. Hvilken skabelon der ligger til grund <strong>for</strong> opbygningen, og hvordan der<br />
kommunikeres i sådan et system. Dette afsnit hedder ”Applikationens opbygning”.<br />
Brugergrænseflade<br />
Brugergrænsefladen vil blive lavet som en .NET webpart. Derved kan den sættes ind alle de steder i<br />
en webløsning, hvor man har webpart zoner. Webparts har de <strong>for</strong>dele, at de kan genbruges flere<br />
steder i en webløsning. I Sharepoint kan webparts modificeres, indsættes og flyttes rundt direkte fra<br />
wepbrowseren. Dette giver administratorer mulighed <strong>for</strong> at kunne personalisere websteder efter<br />
deres eget ønske.<br />
Mockup<br />
I dette afsnit beskrives de første udkast til det, som skal blive applikationens GUI (grafiske bruger<br />
interface).<br />
Det første mockup viser, hvordan applikationen kan sættes ind i en webløsning. Applikationen kan<br />
sidde som en del af en side. Der kan godt være andet indhold på samme side. Applikationen kan<br />
selvfølgelig også være eneste indhold på siden, og derved fylde mere. Neden<strong>for</strong> kan man se første<br />
mockup.<br />
Anden mockup viser, hvordan applikationen skal være opdelt i en søgedel, en data udvælgelsesdel<br />
og en visningsdel, i <strong>for</strong>m af kortet. Søgekontrollen består af tekstboksen og søgeknappen øverst til<br />
venstre. Søgeresultaterne bliver vist ned langs venstre side, og udvælgelsen af datatyper sker øverst<br />
over kortet. Dette mockup kan ses neden<strong>for</strong>.<br />
17
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Det tredje mockup viser, hvordan det er tænkt, at de <strong>for</strong>skellige geodata skal vises på kortet. Det vil<br />
sige, hvordan et punkt består af enkelte markeringer, og hvordan et område består af et farvet<br />
polygon. En rute består af et startpunkt og et slutpunkt, samt en rute mellem de to punkter. Et punkt<br />
kan også vises med <strong>for</strong>skellige typer af ikoner. Det tredje mockup kan ses neden<strong>for</strong>.<br />
18
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Data<br />
Til opbevaring af data vil Microsoft Sharepoint blive benyttet. Microsoft Sharepoint vil også blive<br />
opsat til at håndtere brugerrettighederne. Det vil sige, hvem der har administratorrettigheder og<br />
derved lov til at oprette nyt data. Data vil blive opbevaret i lister i Microsoft Sharepoint. Dette kan<br />
der læses mere om i designafsnittet ”Microsoft Sharepoint”.<br />
Der bliver tre gennemgående data i applikationen. Et data, som oprettes ved brug af <strong>Google</strong> <strong>Maps</strong><br />
API, og som kan lægges på et kort og give den visuelle effekt af markeringer. Et data i Sharepoint,<br />
som bruges til dataopbevaring. Det sidste data er internt data <strong>for</strong> applikationen, som bruges til at<br />
skabe et bindeled mellem Microsofts Sharepoint og <strong>Google</strong>.<br />
<strong>Google</strong> <strong>Maps</strong> markeringstyper<br />
Ud fra analysen kan vi se, at vi skal bruge følgende markeringstyper. Et punkt, som er en<br />
enkeltmarkering på kortet. En rute, som er to punkter på kortet, hvor i mellem der angives en rute.<br />
Et område, som er afgrænset af en række punkter. Til alle datatyperne hører sig en beskrivelse og et<br />
udseende af markeringen.<br />
En beskrivelse består af html, og kan der<strong>for</strong> indeholde alt fra tekst til billeder og eventuelt film.<br />
Udseendet af den markering på kortet som datatypen repræsenterer, kan variere med farver, ikoner,<br />
størrelser m.m. Dette kan være <strong>for</strong>skelligt alt efter hvordan man ser på kortet. Med dette menes,<br />
hvilken korttype der kigges på. Hvilket zoomniveau der kigges med osv.<br />
Rute<br />
o Startpunkt<br />
o Slutpunkt<br />
o Beskrivelse<br />
Område<br />
o Titel<br />
o List<br />
o Beskrivelse<br />
o Farver<br />
Punkt<br />
o Titel<br />
o Højdegrad<br />
o Breddegrad<br />
o Beskrivelse<br />
o Ikon<br />
Beskrivelse<br />
o Html<br />
o Ekstra felter, som kan indsættes i beskrivelsen<br />
19
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Sharepoint data<br />
I dette afsnit beskrives dataopbevaringen i Microsoft Sharepoint, og hvordan lister, indholdstyper<br />
og datafelter dannes.<br />
Microsoft Sharepoint vil være kilde til data. Der vil blive oprettet lister med specielt konstruerede<br />
indholdstyper, hvori data skal gemmes. Listen vil være en brugerdefineret liste med dataelementer<br />
der nedarver fra item. Dette giver mulighed <strong>for</strong> en masse metadata til hvert element, uden krav om<br />
filer, som dokumenter, billeder og lign.<br />
Der vil også blive oprettet et billedbibliotek til opbevaring af ikoner. Dette skal give mulighed <strong>for</strong> at<br />
skifte ikon på markeringerne.<br />
Lister:<br />
Navn: <strong>Google</strong>MapData<br />
Beskrivelse: Her vil geodataen blive gemt.<br />
Navn: <strong>Google</strong>MapDataTypes<br />
Beskrivelse: Denne liste vil indeholde <strong>for</strong>skellige datatyper, som <strong>for</strong> eksempel ”Kommunegrænse”,<br />
”Skole”, ”Bibliotek” og lign. Det vil være disse typer, som bruges til at udvælge og vise geodata på<br />
kortet.<br />
Bibliotek:<br />
Navn: <strong>Google</strong>Map.PictureLibrary<br />
Beskrivelse: Dette bibliotek vil holde ikoner af <strong>for</strong>skellige typer. Disse ikoner er tilgængelige og<br />
kan knyttes på en punktmarkering.<br />
Indholdstyper (Content types):<br />
Disse typer er allerede beskrevet tidligere i designafsnittet og er som følgende:<br />
Rute<br />
Område<br />
Punkt<br />
Men <strong>for</strong> at adskille nogle af alle de <strong>for</strong>skellige typer i applikationen navngives disse som følgende:<br />
MapRute<br />
MapOmraade<br />
MapLokation<br />
Fælles <strong>for</strong> alle indholdstyper er, at de har en titel og en beskrivelse. Der<strong>for</strong> laves der en fælles<br />
indholdstype, som resten nedarver fra. Denne indholdstype vil blive kaldt:<br />
<strong>Google</strong>MapMarkerBase<br />
20
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Sikkerhed/Rettigheder<br />
Sharepoint har et detaljeret rettighedssystem, hvor rettigheder kan gives på Site, Web, Lister eller<br />
helt ned på elementer i listerne. Der<strong>for</strong> vil Sharepoint håndtere rettighederne i <strong>Google</strong> <strong>Maps</strong><br />
applikationen, hvor der skal differentieres mellem almindelige brugere og administratorer.<br />
Sharepoint kan importere sine brugere og deres rettigheder fra Active Directory. Active Directory er<br />
en Microsoft implementering af en objektdatabase af netværks in<strong>for</strong>mation omkring rettigheder.<br />
Applikation data<br />
Denne datatype lever kun når der skal mappes mellem Sharepoint data og <strong>Google</strong> data. Denne<br />
ekstra applikations data skal give systemet fleksibilitet nok til, at man eventuelt ville kunne udskifte<br />
enten datakilden (Sharepoint) eller den grafiske præsentation (<strong>Google</strong> Map) uden at skulle udskifte<br />
resten af applikationen.<br />
For at kunne lave en ordentlig overgang fra Sharepoint data til <strong>Google</strong> data skal der bruges følgende<br />
applikations datatyper:<br />
Rute<br />
Omraade<br />
Punkt<br />
Koordinat<br />
Søgeresultat<br />
Rute, Område og Punkt giver lidt sig selv. Koordinat er en datatype til at opbevare et koordinat, så<br />
det kan mappes mellem tekststrengen i Sharepoint og en GLatLng i <strong>Google</strong>, som deres koordinater<br />
hedder.<br />
Et søgeresultat bruges som container <strong>for</strong> søgningerne. Da det er muligt både at søge på ruter,<br />
områder og punkter skal alle typerne kunne blive vist i samme søgeresultat.<br />
21
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Applikationens opbygning<br />
I dette afsnit beskrives hvordan applikationen opbygges i <strong>for</strong>m af komponenter, og hvordan<br />
Microsoft Sharepoint og <strong>Google</strong> kan fungere i samme applikation. Der bliver også beskrevet hvilke<br />
komponenter der tager sig af det grafiske og databehandling. Dette afsnit er opbygget af fire<br />
underafsnit.<br />
Applikationen som bindeled<br />
Neden<strong>for</strong> ses et billede af, hvordan applikationen er tænkt som et bindeled mellem Sharepoint og<br />
<strong>Google</strong> <strong>Maps</strong>, som er to <strong>for</strong>skellige teknologier.<br />
<strong>Google</strong><br />
Map<br />
JavaScripts Klient side<br />
Applikation –<br />
Bindeled mellem<br />
C# og JavaScript<br />
Sharepoint<br />
C# - Data<br />
Som beskrevet i analyseafsnittet er der stor <strong>for</strong>skel på <strong>Google</strong> <strong>Maps</strong> og Sharepoint. En af de ting der<br />
adskiller de to teknologier er hvor i en klient-server-kommunikation deres logik primært kører.<br />
Bruger<br />
Kienter Server Data<br />
<strong>Google</strong> <strong>Maps</strong> er rent klient eksekveret kode, som skrives i JavaScript. Først når klienten har<br />
modtaget sit respons fra serveren kører JavaScripts. Der<strong>for</strong> må der hele tiden tages <strong>for</strong>behold <strong>for</strong>, at<br />
den logik, som <strong>Google</strong> <strong>Maps</strong> API’et skal udføre, er det sidste der bliver kørt. Det er også først på<br />
klientens maskine, at et kald til <strong>Google</strong> om at få adgang til deres <strong>Maps</strong> API bliver udført. Så de<br />
metoder der ligger i <strong>Google</strong> <strong>Maps</strong> API’et er først tilgængelige sidst i processen.<br />
22
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Microsoft Sharepoint er derimod installeret på serveren og dataudtrækning sker udelukkende på<br />
serversiden af klient-server kommunikationen. Sharepoint har samtidig sin helt egen datastruktur,<br />
som gør at en direkte kommunikation til <strong>Google</strong> <strong>Maps</strong> API vil binde applikationen til kun at kunne<br />
fungere på en Sharepoint installation. Det er der<strong>for</strong> nødvendigt, at applikationen kan omskrive data<br />
fra Sharepoint struktur til noget <strong>Google</strong> <strong>Maps</strong> API kan <strong>for</strong>stå.<br />
Kommunikationen bliver der<strong>for</strong>, at brugeren fra sin klient sender en <strong>for</strong>espørgsel til serveren, som<br />
kigger ned i Sharepoint. Her finder den det <strong>for</strong>espurgte data, trækker det ud af Sharepoint og<br />
opbevarer det som intern datatype. Derefter omskrives denne data igen til <strong>Google</strong> <strong>Maps</strong> datatyper,<br />
som bliver lagt ud på kortet ved hjælp af <strong>Google</strong> <strong>Maps</strong> API’et. Denne opdeling af applikationen kan<br />
der læses mere om i næste afsnit ”3-Lags model (Model-View-Controller)”.<br />
3-Lags model (Model-View-Controller)<br />
En 3 lags model er valgt som grundlæggende applikationsmodel, <strong>for</strong>di den giver stor mulighed <strong>for</strong><br />
genbrug, vedligeholdelse og modificering af systemet. De tre lag er Model, View og Controller og<br />
stammer fra design arkitekturen af samme navn ”Model-View-Controller”. Denne model er ofte set<br />
i webapplikationer. Model-komponenten mapper op til databasen og repræsenterer data i systemet.<br />
View-komponenten håndterer præsentationen af data og det grafiske brugerinterface, mellem<br />
menneske og maskine. Controller-komponenten modtager brugernes input og bearbejder det.<br />
Neden<strong>for</strong> kan en standard opsætning af MVC ses. Billedet er taget fra wikipedia.com 2 .<br />
Figur 1: Graf over MVC<br />
Hvis man har opbygget sin applikation efter ovenstående model, vil det være nemmere at udskifte<br />
delkomponenter. Det kunne være, at man ønskede en applikation, som kan det samme, men<br />
opbevarer sin data et andet sted. For eksempel kunne det være at der skulle læses fra xml filer i<br />
stedet <strong>for</strong> Sharepoint. Denne omstrukturering af applikationen er mulig på grund af 3-lags<br />
strukturen, hvor man kan nøjes med at lave et nyt ”model” lag, da Controlleren og Viewet ikke har<br />
direkte med datamapping at gøre, men ren bearbejdning og visning af data.<br />
Vil man derimod have en applikation, som skal vises et andet sted end i en webapplikation, <strong>for</strong><br />
eksempel et windowsprogram opbygget i WPF eller WinForms, så vil man kunne udskifte View<br />
2 http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller<br />
23
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
laget. Der vil selvfølgelig ikke være mulighed <strong>for</strong> at køre de samme javascripts og lave samme<br />
præsentation som på et googlemap, men man vil kunne lave en anden type grafisk præsentation. I<br />
dette tilfælde vil controller og model-komponenterne kunne <strong>for</strong>blive de samme.<br />
Der skal nævnes, at MVC arkitekturen er meget omdiskuteret, og der er mange <strong>for</strong>skellige måder at<br />
implementere og <strong>for</strong>stå denne arkitektur på. Men nogle af de vigtige principper er opdeling af<br />
funktionalitet.<br />
Dette giver stor fleksibilitet af applikationen. Det giver projektet høj binding og lav kobling mellem<br />
objekterne i de <strong>for</strong>skellige lag. I den version af 3-lags modellen, som der vil blive implementeret,<br />
går kommunikationen ikke direkte mellem Model-laget og View-laget. Der vil Controlleren blive<br />
sat imellem, <strong>for</strong> at give den ekstra opdeling, som skal gøre applikationen mere overskuelig med<br />
henblik på at binde de to teknologier sammen. Dette er mere en standard 3-lags model, og ser ud<br />
som nedenstående, men ansvarsområderne i View, Controller og Model er det samme som i MVC.<br />
View «interface»<br />
Controller «interface»<br />
Model<br />
GUI Interface: Controller<br />
Interface: Model<br />
Data<br />
Grafisk design<br />
Til at lave det grafiske design er der taget udgangspunkt i de mockups, som blev lavet under<br />
analysen.<br />
Listen til udvælgelse af hvilken type data der skal vises på kortet er blevet til en hierarkisk struktur,<br />
som giver mulighed <strong>for</strong> at indsnævre og specificere udvælgelsen.<br />
Søgeinterfacet er en tekstboks og en knap med teksten ”søg”, som aktiverer søgningen i<br />
controlleren. Resultaterne listes vertikalt som en række af søgeresultater. Søgeresultaterne bliver<br />
mulige at klikke på, og derved få vist resultatet på kortet.<br />
Når et nyt geografisk område skal oprettes i systemet, skal der <strong>for</strong> administratorer være mulighed<br />
<strong>for</strong> at få vist en ”opret nyt område” skabelon. Dette område vil give administratoren mulighed <strong>for</strong> at<br />
udvælge et eller flere punkter på kortet og angive det med titel, beskrivelse og andet data.<br />
Funktionaliteten til at oprette nye områder vil kun være tilgængelig <strong>for</strong> administratorer. Denne<br />
funktionalitet skal implementeres som specielt udviklede felter til Sharepoint.<br />
Layoutet på elementerne i applikationen, som tekstbokse, knapper m.v. vil være standard html og<br />
ASP controller. Der vil ikke blive designet specielle elementer.<br />
Databehandling<br />
Databehandlingen administreres i Controller-komponenten af applikationen. Et kald til Controllerkomponenten<br />
sendes direkte ned til Model-komponenten <strong>for</strong> at få det efterspurgte data. Modelkomponenten<br />
udtrækker det egentlige data fra datakilden. Når det korrekte data er fundet, returneres<br />
24
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
dataet til Controlleren, som sikrer dataet inden det returneres til View-komponenten. View-<br />
komponenten skaber herefter en grafisk præsentation i <strong>for</strong>m af markeringer på kortet, eller en liste<br />
med søgeresultater osv.<br />
Delkonklusion – Design<br />
Der er i designafsnittet blev gennemgået de <strong>for</strong>skellige datatyper, applikationens arkitektur og<br />
grafisk layout. Der er lagt op til en fleksibel applikation, som kan benyttes af flere <strong>for</strong>skellige typer<br />
af Sharepoint kunder, uden at binde sig til udelukkende at skulle køre Sharepoint som data lag.<br />
25
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Implementering<br />
I dette afsnit vil implementeringen af systemet blive beskrevet. Implementeringen vil blandt andet<br />
være delt op på samme måde som designafsnittet. Der vil blive <strong>for</strong>klaret implementeringen af det<br />
grafiske lag, Logik laget og Data laget, som også er henholdsvis Viewet, Controller og Model fra<br />
den valgte designskabelon. Men da implementeringsafsnittet går i dybden med applikationens kode,<br />
vil der være afsnit, som ikke har været direkte beskrevet i Designdelen af rapporten.<br />
Brugergrænseflade<br />
Brugergrænsefladen er opbygget af webparts (webdel). For at bygge en .NET webpart, kræver det<br />
at man lader sin control nedarve fra ”WebPart”. En webpart i sig selv er en webcontrol, som kan<br />
indsættes i en webpartzone på en ASP.NET webside. En webcontrol indeholder metoder til at skabe<br />
en grafisk præsentation af controllen og metoder til at indsætte indlejrede controller.<br />
Konfigurationsvariabler<br />
Der er implementeret muligheden <strong>for</strong> at bruge webdele til at styre konfigurationsvariabler <strong>for</strong><br />
applikationen. Dette er opsat ved at gøre variablerne tilgængelige under redigering af webdelene.<br />
Neden<strong>for</strong> kan man se variablerne til konfiguration af kortets startposition og dens zoom-niveau,<br />
samt den individuelle <strong>Google</strong> <strong>Maps</strong> API key, som kræves på hver server. En anden vigtig<br />
konfigurationsvariabel er ”showDescription”, som angiver om en rute skal præsenteres med en<br />
tilhørende vejledning.<br />
Disse variabler gør applikationen nem at installere på <strong>for</strong>skellige websider, og hver side kan have sit<br />
kort konfigureret <strong>for</strong>skelligt.<br />
Som standard bliver konfigurationsvariabler af typen ”string” vist som enkeltliniers tekststreng. Der<br />
er desuden implementeret muligheden <strong>for</strong> at administratorer kan tilføje en smule javascript til siden<br />
i et flerlinjers tekstfelt. Dette kunne <strong>for</strong> eksempel udnyttes til at indtaste et punkt, som altid skulle<br />
vises på kortet, eller referere til en KML fil på en helt anden hjemmeside. For at læse mere om<br />
KML filer, henvises til implementeringsafsnittet ”Dynamisk Data”. At tilføje et javascript vil<br />
selvfølgelig kræve en del viden om programmering, som måske ikke alle administratorer besidder.<br />
Dette er dog også kun en ekstra funktion og ikke en del af applikationens primære funktionalitet.<br />
26
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
For at få vist et flerlinjers tekstfelt, var det nødvendigt at implementere en ny ”EditorPart”.<br />
Neden<strong>for</strong> kan der ses, hvordan denne ”EditorPart” vises som en flerlinjers tekstfelt. Linje 19 er den<br />
vigtigste <strong>for</strong> at gøre tekstboksen tilgængelig.<br />
Brug af usercontroller<br />
Til at kode den grafiske brugergrænseflade er der valgt at lave usercontroller. Disse er mere<br />
intuitive at arbejde med end webparts. Usercontroller giver muligheden <strong>for</strong> at skrive den grafiske<br />
præsentation af controllen i html. Forskellen består i, om man indlejret i kontrollerne skriver<br />
”HtmlTable table = new HtmlTable()” eller om man på sin præsentationsside skriver html tagget<br />
””. Det sidste er langt mere overskueligt, og dette er ikke muligt i webparts, der<strong>for</strong><br />
loader applikationens webparts <strong>for</strong>skellige usercontroller.<br />
Neden<strong>for</strong> kan man se, hvordan usercontrollen loades i ”OnInit” metoden af webparten, og tilføjes i<br />
”CreateChildControls”. Det ses også hvordan alle usercontrollens variable sættes inden controllen<br />
tilføjes.<br />
27
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Disse usercontroller består af en .ascx fil og en .cs fil. Neden<strong>for</strong> ses et billede af projektet, hvor de<br />
to på hinanden tilhørende filer ligger.<br />
I en sådan usercontrol kan man instantiere sine webcontroller i .ascx filen, sammen med sin html.<br />
Dette giver langt større overskuelighed <strong>for</strong> programmøren, da .ascx filen tilsvarer det output, som<br />
webcontrollen viser på hjemmesiden. I .cs filen kan man på serversiden give webcontrollerne de<br />
nødvendige data, og det er muligt at lytte på <strong>for</strong>skellige events, som er kontrolbegivenheder, som<br />
<strong>for</strong> eksempel når en knap trykkes, eller når tekst udfyldes m.m.<br />
<strong>Google</strong> Map<br />
Neden<strong>for</strong> <strong>for</strong>klares hvordan <strong>Google</strong>s kort vises i usercontrollen. Her kontrolleres først, at browseren<br />
er kompatibel til at køre <strong>Google</strong> <strong>Maps</strong>, og derefter findes der den webcontrol, som er oprettet til at<br />
holde kortet. Denne kaldes ”map_canvas”. Denne sendes med i <strong>Google</strong> <strong>Maps</strong> API konstruktøren<br />
”GMap2”. Derefter modtager man en instans af kortet, som der kan opsættes som man ønsker. Her<br />
sættes der center og UI, samt en ekstra korttype ”satellite_3d”. Knapperne til at skifte mellem<br />
28
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
korttyperne sættes med en instans af ”GMapTypeControl”. ”” er en<br />
servervariabel, som udfyldes med alt det output, som skal vises på kortet.<br />
<strong>Google</strong> <strong>Maps</strong> API’et er som tidligere beskrevet kun tilgængeligt på klientsiden via JavaScripts.<br />
Der<strong>for</strong> er det også nødvendigt at alle punkterne og deres events (click-, drag- og dropbegivenheder)<br />
bliver sat via JavaScript. Da data ligger på serversiden er det nødvigt at skabe disse<br />
JavaScripts på serversiden, og derefter skrive det ud til klienten, når hjemmesiden bliver kaldt.<br />
Denne metode bruges blandt andet, når applikationen viser punkter på kortet, som er udvalgt af<br />
brugerne.<br />
Punkter<br />
Neden<strong>for</strong> ses et lille udsnit af metoden til at skabe punkter på kortet. Tilsvarende metoder findes <strong>for</strong><br />
ruter og polygoner. Som parameter til metoden er der en liste af punkter, kaldet ”points”. For hvert<br />
punkt i denne liste skabes der en del af et JavaScript. Dette JavaScript bliver skrevet ud til websiden<br />
i variablen ”” fra ovenstående screenshot. For hvert punkt bliver der gennemgået<br />
dets variabler. Neden<strong>for</strong> kan ses to af et punkts mange variabler. Hver variabel skal håndteres<br />
<strong>for</strong>skelligt. Disse variabler kan blandt andet være ”draggable”, som bestemmer om punkter må<br />
kunne flyttes rundt, eller ”iconPath”, som bestemmer om punkterne på kortet skal vises med<br />
<strong>for</strong>skellige ikoner.<br />
29
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Et <strong>Google</strong> <strong>Maps</strong> punkt består af en række muligheder <strong>for</strong> den grafiske præstentation. Dette er blandt<br />
andet de to variabler, draggable og ikonet, fra ovenstående eksempel. Men det består også af en<br />
beskrivelse. En beskrivelse af et punkt kan frembringes med interaktion af et punkt. Det klassiske<br />
eksempel fra <strong>Google</strong>s eget kort er taleboblen, som kommer frem når der trykkes på en markering.<br />
Når en administrator skal gøre en markering meningsfyldt, er det i beskrivelsen at han uddyber<br />
betydningen af markeringen. Det er også denne beskrivelse, som er den mest konfigurerbare del af<br />
en markering. In<strong>for</strong>mation omkring et punkt kan også angives ved hjælp af brugerdefinerede ikoner.<br />
For eksempel kan en koncert få et icon af musik, et teater kan få en maske eller lign. Styringen af<br />
indhold i beskrivelsen og ikonerne vil blive beskrevet senere i implementationsafsnittet ”Backend”.<br />
Inden beskrivelsen knyttes til en <strong>Google</strong> markering i applikationen, tilføjes en ekstra funktion.<br />
Funktionen er muligheden <strong>for</strong> at få en rutevejledning fra en selvskreven adresse til det udvalgte<br />
punkt på kortet. Hvis en bruger har brugt applikationen til at finde den nærmeste børnehave, så<br />
kunne det være, at brugeren gerne ville vide, hvordan man kom dertil. Her kan han bruge ekstra<br />
funktionaliten ”Rute vejledning”, der er implementeret som en del af markeringens beskrivelse.<br />
Dette er lidt ekstra html kode, som tilføjes den allerede generede beskrivelse. Hvis der også ønskes<br />
at få selve kørselsvejledningen vist på siden og ikke kun ruten på kortet, er det implementeret sådan,<br />
at det kan styres fra konfigurationsvariablerne på webdelene. Neden<strong>for</strong> kan det ses, hvordan<br />
metoden ”appendInfoBox()” bliver kaldt lige inden beskrivelsen tilføjes til punktets ”click event”.<br />
30
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Her under kan lidt af metoden ”appendInfoBox” ses. Dette er en stump html, der kalder en række<br />
JavaScripts. På den måde kan brugeren på sin klient få en rute fra det udvalgte punkt, til et han selv<br />
skriver.<br />
Et eksempel på en lokation, hvor ikon og beskrivelse angiver hvad der er på det givne punkt, kunne<br />
være som nedenstående. Hvor der er lavet et punkt <strong>for</strong> Webtop (den røde pil er tegnet på<br />
efterfølgende). Punktet er vist med et brugerdefineret ikon, her er det et hus. Dette ikon kan vælges<br />
når punktet oprettes. Beskrivelsen har her fået en titel, en beskrivende tekst og et administrator<br />
oprettet felt ”Dato”, som administratoren dynamisk kan slette, ændre eller oprette nye af, og som<br />
automatisk vil blive fundet og vist i beskrivelsen. Dette beskrives nærmere i afsnittet ”Data”.<br />
Områder (Polygoner)<br />
Som med punkter er der også en metode til at skabe de polygoner, der skal vises på kortet. At få vist<br />
polygonerne på kortet sker på samme måde som med punkterne, hvor der skabes et JavaScript, som<br />
til sidst skrives ud på hjemmesiden. Denne metode hedder ”presentOmraader” og parametrene til<br />
metoden er en liste af ”Omraade”. Disse områder er af applikationsdatatypen ”Omraade”, som<br />
beskrives i afsnittet ”Data”. Et polygon består af en række af punkter. Disse punkter skal danne<br />
hjørnepunkter i polygonerne. Neden<strong>for</strong> kan man se omraade variablen ”polypoints” bliver læst som<br />
en samling af ”Koordinater”, og derefter dannes der et <strong>Google</strong> <strong>Maps</strong> punkt ud fra disse koordinater.<br />
Alle punkter løbes igennem, og til sidst tilføjes startpunktet, <strong>for</strong> at lukke polygonet.<br />
31
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Mellem hjørnepunkterne på polygonet tegnes en kantstreg, som man kan angive med en farve og en<br />
gennemsigtighed. Ligeledes kan der angives farve og gennemsigtighed <strong>for</strong> området mellem<br />
kantstregerne. Hvis ingenting angives er der implementeret en standard farve, som polygonet<br />
automatisk oprettes med. Standardfarverne er i røde nuancer, som kan ses på billedet neden<strong>for</strong>. Et<br />
område der er oprettet i applikationen vil se ud som nedenstående. Her er den nordlige del af<br />
Bornholm markeret, og man kan gøre det så detaljeret, som man har lyst til.<br />
Da et område, som på billedet oven<strong>for</strong> ikke nødvendigvis giver megen <strong>for</strong>klaring, er der<br />
implementeret muligheden <strong>for</strong>, at et polygon kan have en beskrivelse. Det er ikke standard, at et<br />
<strong>Google</strong> <strong>Maps</strong> polygon har beskrivende tekst. For at implementere dette, er der udviklet logik til at<br />
finde et sted midt i polygonet, oprette et usynligt punkt, og give det en beskrivelse. Samtidig<br />
oprettes der et ”click eventet ”på polygonet, som viser beskrivelsen af området på det usynlige<br />
punkt. Dette kan ses med nedenstående kode og resultatet kan ses på ”ScreenShot1” i appendiks.<br />
32
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Ruter<br />
Ruter i <strong>Google</strong> <strong>Maps</strong> API’et kan loades via metoden ”load” på et objekt af typen ”GDirections”. En<br />
rute består af to punkter, startpunkt og slutpunkt. Et startpunkt eller slutpunkt <strong>for</strong> ”GDirections” kan<br />
enten være koordinatsæt eller adresser. Der<strong>for</strong> er denne applikation udviklet til at kunne tage højde<br />
<strong>for</strong> begge. Applikationen kigger på det input, som er blevet tastet ved oprettelsen af en rute, og ud<br />
fra dette afgøres, om der er tastet en adresse eller et koordinat. En rute kan præsenteres på to måder.<br />
Den ene er en rute aftegnet på kortet, og den anden er en detaljeret kørselsvejledning. Det er<br />
tidligere beskrevet at muligheden <strong>for</strong> at slå kørselsvejledninger til og fra er implementeret som en<br />
konfigurationsvariabel. Denne variabel bruges når en rute skal vises på kortet. Neden<strong>for</strong> ses<br />
logikken, som skal afgøre, om der skal vises en rutevejledning eller ej. Her benyttes variablen<br />
”showDescribtion”.<br />
33
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Backend<br />
I dette afsnit beskrives backenden af systemet, som er den del af systemet, hvor der datamappes fra<br />
datakilden til applikationen. Dette lag er implementeret med en klasse til at håndtere<br />
dataudtrækning fra kilden.<br />
DataMapper<br />
Datamapperen i denne applikation snakker med systemet Microsoft Sharepoint. Til at sikre<br />
konsistens mellem datamapper klassen og resten af systemet er der implementeret et interface. Dette<br />
interface sikre at datamapperen har metoder, som systemet spørger på, og at de returnerer værdier,<br />
som systemet kan arbejde med. Dette kan der læses mere om i afsnittet ”Data”.<br />
I denne applikation kigger datamapperen ned i SharePoint og den bliver der<strong>for</strong> kaldt<br />
”SPDataMapper”. SPDataMapper har metoder til at hente punkter, områder, ruter, finde<br />
søgeresultater og finde nødvendige variabler, så markeringstyperne kan blive korrekt præsenteret<br />
<strong>for</strong> brugerne. Neden<strong>for</strong> ses en liste af sammenklappede metoder, som SPDataMapper har<br />
implementeret fra interfacet.<br />
Som <strong>for</strong>klarende eksempel, kan der kigges på metoden ”getPoints”, som tager listenavn og typeId<br />
som parametre. Listenavnet bruges til at finde listen i Sharepoint, hvor markeringerne er oprettet.<br />
Denne liste hedder som standard ”<strong>Google</strong>Map.Markers”. TypeId er en streng med id’er på de<br />
markeringstyper, som brugeren har klikket sig frem til, og ønsker vist på kortet. Neden<strong>for</strong> kan der<br />
ses et udsnit af metoden. Til at finde de rigtige markeringer bruges .NET biblioteket Linq. Dette kan<br />
bruges <strong>for</strong>di listeelementerne nedarver fra ”IEnumerable”, hvilket kan ses med metoden<br />
”.Cast”. Herefter kan man bruge det såkaldte lambda-udtryk i Linq, som kan ses med<br />
udtykket ”=>” i Where betingelsen. Udtrykket udvælger markeringstyper, som nedarver i<br />
contenttypen (indholdstypen) fra ”MapLokation”. Enten på første eller anden nedarving. Sharepoint<br />
gemmer sine indholdstyper på en gruppe af websteder som nedarves til det aktuelle websted. Herfra<br />
nedarves det derefter til listerne og til sidst til elementerne. Når vi kigger på anden nedarving,<br />
kigger vi på indholdstyperne på det aktuelle websted. Dette giver en stor brugervenlighed <strong>for</strong><br />
administratorerne, da de selv kan oprette nye indholdstyper, og derved Sharepoint markeringstyper.<br />
Det eneste krav er, at de skal nedarve fra en af følgende ”MapLokation”, ”MapOmraade” eller<br />
”MapRute”. Når de korrekte elementer er fundet i koden neden<strong>for</strong>, løbes de igennem en <strong>for</strong> en.<br />
34
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
For at gøre administratorens arbejde så brugervenligt som muligt, er der udviklet en funktionalitet,<br />
som giver administratorerne mulighed <strong>for</strong> at konfigurere beskrivelserne af en markering med<br />
Sharepoint felter. Der kan altså oprettes ekstra felter, få dem tilknyttet en markeringsindholdstype<br />
og automatisk få de felter med i beskrivelsen. Det eneste krav til feltet er, at dets navn starter med<br />
tegnet ”_”. Hvis navnet starter med underscore er en af funktionerne, at feltets navn og værdi vil<br />
blive udskrevet efter hinanden i beskrivelsen. I koden neden<strong>for</strong>, kan dette ses og der kan man også<br />
se, hvordan der tages specielt højde <strong>for</strong> datofelter. Et større billede kan ses i Appendiks<br />
ScreenShot4.<br />
For at <strong>for</strong>klare dette er der lavet et eksempel, hvor et punkt er blevet oprettet med feltet ”_Dato” og<br />
værdien ”01-01-2001”. Dette felt kan ses neden<strong>for</strong>, og <strong>for</strong> at se resultatet af beskrivelsen, når<br />
nedenstående felt anvendes, henvises der til Appendiks ScreenShot2.<br />
I ovenstående tilfælde udskrives datoen på liste<strong>for</strong>m efter beskrivelsen. Ovenstående kode giver<br />
også mulighed <strong>for</strong>, at administratoren kan få vist feltværdien midt i beskrivelsen. En administrator<br />
kan lave en beskrivelse i stil med nedenstående. Teksten omklamret af firkantede parenteser skal<br />
svare til navnene på felterne. Hvor disse parenteser står, vil feltets værdi i stedet blive vist. For at se<br />
resultatet af nedenstående beskrivelse henvises til Appendiks ScreenShot3.<br />
35
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Dette afsnit viste, hvordan Sharepoint bliver konfigureret og udnyttet til at give administratorerne så<br />
meget frihed som muligt, når de opretter og vedligeholder markeringsdata.<br />
Controller<br />
I dette afsnit vil Controlleren fra applikations-strukturen blive gennemgået.<br />
Imellem præsentationslaget og datalaget, er der placeret et tredje lag. Dette lag kaldes ”kontrol<br />
laget” eller ”Controller”. I controlleren håndteres kommunikationen fra View til Model laget.<br />
Controlleren implementerer interfacet ”IController”. Dette sikrer kommunikation til<br />
præsentationslaget. Controlleren opretter også en instans af ”IDataMapper”. I denne applikation er<br />
det en ”SPDataMapper”, som henter data fra Sharepoint.<br />
Controlleren kan virke lidt som et mellemled, men den bidrager med et ekstra lag af fleksibilitet i<br />
applikationen. De fleste metodekald fra præsentationslaget sender controlleren direkte videre til<br />
datalaget. Dette kan ses neden<strong>for</strong>.<br />
Hvis man kigger på interfacet ”IController”, som kan ses på Appendiks ScreenShot15, kan man se,<br />
at metoden ”search” også er en del af interfacet. ”search” sender ikke bare metodekaldet videre,<br />
den opretter også søgeresultaterne og sender dem tilbage som en streng, klar til at blive vist på<br />
hjemmesiden. Neden<strong>for</strong> kan controllerens metode ”search” ses, hvor søgeresultaterne oprettes.<br />
36
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Hjælpeklasse<br />
Applikationen benytter sig af en hjælpeklasse. Med hjælpeklasse menes en klasse, som ikke direkte<br />
har indflydelse på applikationens logik, men som stiller genbrugelig funktionalitet til rådighed <strong>for</strong><br />
andre klasser.<br />
Hjælpeklassen er ”Helpers”. Denne klasse giver applikationens webdele mulighed <strong>for</strong> at sikre, at<br />
det korrekte stylesheet er registreret på siden. Der sker med metoden neden<strong>for</strong>. Her oprettes<br />
stylesheet referencen, og derefter kontrolleres der på dets id, <strong>for</strong> at se om det er registreret på siden i<br />
<strong>for</strong>vejen. På den måde kan de tre webdele uafhængigt af hinanden blive sat ind på en vilkårlig side<br />
og være stylet korrekt.<br />
37
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Applikationens opbygning<br />
En applikation til Microsoft Sharepoint udvikles i Visual Studio solutions, som kompilere til WSP<br />
filer. En WSP fil er i bund og grund en CAB fil. CAB fil <strong>for</strong>matet står <strong>for</strong> ”cabinet” og er et<br />
fil<strong>for</strong>mat til en samling af andre filer. Det specielle ved en WSP fil er, at den har en helt bestemt<br />
struktur. Strukturen skal svare til MOSS’s ”hive”. Dette ”hive” er en ressource folder, hvor alle<br />
skabeloner, stylesheets, indholdstyper m.m. bliver hentet fra.<br />
Denne applikation består af 4 solutions. Den første er kaldet ”Webtop.<strong>Google</strong>Map.Resources”. I<br />
denne solution defineres alle de skabeloner, som skal bruges i Sharepoint <strong>for</strong> at få oprettet de<br />
nødvendige felter, indholdstyper og lister. Den anden er kaldet<br />
”Webtop.<strong>Google</strong>Map.CustomFields”. Denne solution installerer de to specialudviklede felttyper,<br />
som bliver brugt af applikationen til at give markeringerne koordinater og typer. Den tredje er<br />
”Webtop.<strong>Google</strong>Map.DataLib”. Heri defineres de applikationsdatatyper, som benyttes til at<br />
<strong>for</strong>binde Sharepoint og <strong>Google</strong> <strong>Maps</strong>. Der defineres også interfaces, som sikrer korrekt<br />
kommunikation mellem de <strong>for</strong>skellige applikationslag. Her tænktes på præsentations-, kontrol- og<br />
data laget. Disse interfaces og applikationsdatatyper sikre at applikationen ikke er afhængig af en<br />
bestemt datakilde eller grafisk brugergrænseflade. Der kan læses mere om, hvordan disse interfaces<br />
bliver implementeret i implementeringsafsnittet ”Interfaces”. Den fjerde solution hedder<br />
”Webtop.<strong>Google</strong>Map.Controls”. I denne solution ligger alle de C# klasser, som er webparts,<br />
usercontroller, datamapper, kontrolklasser og hjælpeklasser. Denne opdeling gør det nemt under<br />
udviklingen, da man kan arbejde i <strong>for</strong>skellige solutions alt efter om man udvikler ressourcer eller<br />
kontroller.<br />
Til dette projekt bliver værktøjet ”WSPBuilder” brugt til at danne WSP filer. Men WSPBuilder<br />
stiller store krav om at Visual Studio solutions skal have en helt bestemt struktur. På nedenstående<br />
billede kan man se et eksempel på strukturen i en solution, som skal kompileres til en WSP fil. For<br />
at se skærmbilleder af alle de solutions, som er brugt til projektet, henvises der til Appendiks<br />
ScreenShot11, ScreenShot12, ScreenShot13 og ScreenShot14. Men neden<strong>for</strong> kan der ses et<br />
eksempel på solution ”Webtop.<strong>Google</strong>Map.Controls”. Her kan der ses, hvordan ”hive” strukturen er<br />
opbygget med yderste mappe kaldet ”12”. Under ”12” befinder sig skabeloner, funktioner,<br />
stylesheet og alt andet som Sharepoint bruger til at skabe dets indhold. Skabeloner og funktioner<br />
skal ligge i mappen ”FEATURES”. Stylesheet og andet grafik skal ligge i ”LAYOUTS”.<br />
Kontrolskabeloner skal i ”CONTROLTEMPLATES”, men deres bagvedliggende filer kan placeres<br />
enten i en mappe kaldet ”80/bin”, eller bare uden <strong>for</strong> ”12”. Alt uden <strong>for</strong> mappen ”12” bliver<br />
kompileret til en assembly (.dll fil) og lagt i GAC. GAC står <strong>for</strong> ”Global Assembly Cache”. Filer i<br />
GAC’en kan tilgås af alle webapplikationer, hvor imod ”80/bin” refererer til applikationens<br />
ressourcekatalog. Altså filer tilgængelige <strong>for</strong> den enkelte webapplikation. Dette bliver ikke benyttet<br />
i dette projekt.<br />
38
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
På ovenstående billede kan man også se at strukturen i solutionen ikke matcher tre- lags modellen.<br />
Dette skyldes til dels de strenge krav om struktur <strong>for</strong> WSP filer, og dels at filerne i stedet er opdelt<br />
efter typer. I folderen ”WebpartCode” ligger de tre webparts, som kan sættes ind på hjemmesiden.<br />
Disse loader hver deres usercontrol. Disse usercontroller ligger i ”12” mappen, men deres<br />
bagvedliggende filer ligger i mappen ”UserControlCode”. Resten af kodefilerne ligger i mappen<br />
”Misc”. Disse kodefiler er blandt andet ”SPDataMapper” filen, som henter data fra Sharepoint, og<br />
”Controller”. ”Misc” indeholder også hjælpeklasser. Denne opdeling har gjort det mere<br />
overskueligt under udviklingen af applikationen. Hvis der skulle arbejdes på webdele kiggede man i<br />
en mappe, hvis der skulle arbejdes med layoutet kiggede man i en anden og hvis der skulle arbejdes<br />
med applikationens logik, kunne man kigge i en tredje. Hvis man skal dele det op efter tre- lags<br />
modellen, kan det se ud som nedenstående:<br />
39
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
View:<br />
WebpartCode<br />
o <strong>Google</strong>MapMap.cs<br />
o <strong>Google</strong>MapSearch.cs<br />
o <strong>Google</strong>MapTypeView.cs<br />
UserControlCode<br />
o MapContent.cs<br />
o Search.cs<br />
o TypeView.cs<br />
Misc<br />
o TextBoxEditor.cs<br />
o Helpers.cs<br />
Controller:<br />
Misc<br />
o Controller.cs<br />
Model:<br />
Misc<br />
o SPDataMapper.cs<br />
o SPListItemHierach<br />
yBuilder.cs<br />
Interfaces<br />
Interfaces er en <strong>for</strong>m <strong>for</strong> kommunikationskanal mellem et objekt og brugeren af objektet. I denne<br />
applikation er der <strong>for</strong> eksempel et interface kaldet ”IDataMapper”, som bruges ved kommunikation<br />
fra ”Controller” klassen til den klasse, som henter data fra datakilden. Et interface er en række<br />
metoder, som er defineret men ikke oprettet. Der er to interfaces i denne applikation. De to<br />
interfaces’ position kan ses på grafen i designafsnittet ”3-lags model (Model-View-Controller)”<br />
I denne applikation er der oprettet en klasse kaldet ”SPDataMapper”, som implementerer interfacet<br />
”IDataMapper”. Dette betyder at de metoder defineret i ”IDataMapper”, skal være oprettet i<br />
”SPDataMapper”. På den måde kan ”Controller” klassen være sikker på en fast kommunikation<br />
mellem den og data-laget. Hvis der ønskes en anden datakilde end Sharepoint, kunne dette nemt<br />
oprettes. Man kunne <strong>for</strong>estille sig, at data skulle opbevares i XML filer. Dette ville kræve en ny<br />
klasse i datalaget, som <strong>for</strong> eksempel kunne kaldes ”XMLDataMapper”. Hvis denne klasse<br />
implementerer interfacet ”IDataMapper”, vil den kunne indgå i kommunikation med resten af<br />
systemet uden at der skal ændres i andre filer. Dette kan lade sig gøre <strong>for</strong>di kommunikationen går<br />
gennem interfacet.<br />
I denne applikation er der som sagt oprettet to interfaces. Det ene er ”IDataMapper”, som kan ses<br />
på nedenstående billede. På billedet kan man se, at metoderne ”getPoints”, ”getRutes”,<br />
”getOmraade”, ”executeSearch”, ”getKmlFiles” og ”getTypes” alle er defineret i interfacet. Disse<br />
metoder er der<strong>for</strong> implementeret i datamapper-klassen ”SPDataMapper”.<br />
40
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Det andet interface i applikationen sikrer fast kommunikation mellem det grafiske lag og kontrol-<br />
laget. Dette interface hedder ”IController”. ”IController” sikrer kommunikation gennem de seks<br />
metoder ”search”, ”fillTypeView”, ”getRuter” , ”getOmraader” , ”getPunkter” og ”getKmlFiles”.<br />
Disse interfaces er sammen med applikationsdatatyperne en del af den solution, som hedder<br />
”Webtop.<strong>Google</strong>Map.DataLib”. Denne assembly bliver brugt som reference i de andre solutions, og<br />
binder applikationen sammen. For at se et overblik over alt indholdet i<br />
”Webtop.<strong>Google</strong>Map.DataLib” henvises til Appendiks ScreenShot14.<br />
Data<br />
I dette afsnit vil data blive beskrevet. Der er implementeret tre typer af data. Den ene er data i<br />
Sharepoint. Den anden er <strong>Google</strong> <strong>Maps</strong> data, som vises som markeringer på et kort. Den tredje er<br />
data specifikt <strong>for</strong> denne applikation til at binde Sharepoint og <strong>Google</strong> <strong>Maps</strong> sammen.<br />
SharePoint data<br />
Her beskrives hvordan Sharepoint opsættes til at opbevare data, som skal bruges af applikationen.<br />
SharePoint fungerer sådan, at der findes en række standardskabeloner <strong>for</strong> indholdstyper, lister,<br />
sider, websteder m.m. Ud fra disse standardskabeloner kan en administrator via den grafiske<br />
brugergrænseflade i Sharepoint oprette nye indholdstyper, lister m.m. og derefter konfigurere dem,<br />
så de er anvendelige <strong>for</strong> diverse Sharepoint applikationer. Men hvis man ønsker at lave en<br />
applikation, som kan flyttes til en hvilken som helst Sharepoint installation, uden manuelt at skulle<br />
41
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
oprette og konfigurer skabelonerne hver gang, kræver det en del udvikling i XML, <strong>for</strong> at skabe disse<br />
nye skabeloner. Disse er en del af løsningen ”Webtop.<strong>Google</strong>Map.Resources”.<br />
Til denne applikation kræves to lister, et billedbibliotek, en række indholdstyper og en række felter.<br />
En liste kan sammenlignes med en tabel i en database. I en liste kan der oprettes elementer ud fra<br />
<strong>for</strong>skellige indholdstyper. Disse indholdstyper knytter hver især en række felter til de oprettede<br />
elementer. Et bibliotek er i stil med en liste, men i stedet <strong>for</strong> at der opbevares elementer, så<br />
opbevares der filer. I dette tilfælde er det et billedbibliotek og der opbevares der<strong>for</strong> billeder eller<br />
ikoner.<br />
For at oprette en skabelon til den liste, hvor administratoren af slutsystemet kan oprette og<br />
vedligeholde markeringerne på kortet, er der oprettet følgende filer. En ”schema.xml” fil, hvori<br />
skabelonen til listen defineres. En ”ListTemplate.xml” fil hvor i skabelonerne knyttes op på et navn,<br />
id, beskrivelse af skabelonen osv. En ”ListInstances.xml” fil hvor de instanser af listen der skal<br />
oprettes ved installation af applikationen defineres. En installation består i, at en løsning rulles ud<br />
på en Sharepoint server, og derefter aktiveres én til flere ”webstedsfunktioner”, på engelsk kaldet<br />
features. Webstedsfunktionerne aktiveres på de websider eller det website, hvor løsningen skal<br />
køre. Sådan en webstedsfunktion skal blandt andet bruges <strong>for</strong> at aktivere listen til markeringerne.<br />
Der<strong>for</strong> er der oprettet en ”Feature.xml” fil. I sådan en fil kan man angive hvilken rækkefølge og<br />
hvor lister, felter, indholdstyper og eventuelt alt muligt andet skal aktiveres på Sharepoint<br />
installationen.<br />
Neden<strong>for</strong> kan ses et meget lille udsnit af den schema.xml fil, som definerer skabelonen til listen <strong>for</strong><br />
markeringerne. Øverst kan man se at titel og andre af listens indstillinger blive sat. For eksempel<br />
”EnableContentTypes=TRUE”, som gør at <strong>for</strong>skellige indholdstyper er tilgængelige i listen. Man<br />
kan også se, hvordan de indholdstyper der er specielt oprettet til denne applikation bliver knyttet til<br />
listen. Dette sker på deres ID’er i linjerne ”
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
For at ovenstående liste kan blive oprettet korrekt i systemet, er det nødvendigt at de indholdstyper<br />
og felter, som der refereres til, skal være oprettet i systemet. Dette gøres også gennem nogle XML<br />
filer. I SharePoint er der prædefineret nogle felttyper, som <strong>for</strong> eksempel ”titel”, ”oprettet af bruger”<br />
eller ”oprettelsesdato”. Disse bruges som in<strong>for</strong>mation omkring et element. Når der oprettes et nyt<br />
element i en liste, noterer Sharepoint selv hvem der har gjort det og hvornår. Men specielle felter<br />
som ”beskrivelse”, ”koordinat”, ”StartPunkt”, ”SlutPunkt” m.m. skal selv defineres. Dette er gjort i<br />
en fil kaldet ”<strong>Google</strong>MapColumns.xml”. Her i defineres alle de felter, som skal bruges i<br />
applikationen. Neden<strong>for</strong> er et eksempel på to felter. Her kan man se, at felterne defineres på samme<br />
måde som de felter der skulle være en del af listerne. Neden<strong>for</strong> er det ”StartPunkt” og ”SlutPunkt”<br />
<strong>for</strong> en rute, som defineres. Disse er begge af typen ”Text”. Dette giver en tekstboks med mulighed<br />
<strong>for</strong> at indtaste adresser, når en rute skal oprettes.<br />
Indholdstyperne <strong>for</strong> applikationen oprettes i filen kaldet ”<strong>Google</strong>MapContentTypes.xml”.<br />
Indholdstyper kan nedarve fra hinanden. Ved at gøre dette nedarves tilknyttede felter. Der er der<strong>for</strong><br />
oprettet en ”<strong>Google</strong>MapMarkerBase”, som refererer de felter, som alle indholdstyperne skal have.<br />
Der er to felter, som er fælles <strong>for</strong> alle indholdstyperne. Det ene er ”MarkerType”, hvor man kan<br />
angive markeringerne i en hierarkisk type struktur. Det andet er ”beskrivelse”, som er det felt, hvori<br />
en administrator kan give en beskrivende tekst til markeringen. Ud over ”<strong>Google</strong>MapMarkerBase”<br />
43
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
er der oprettet fire andre indholdstyper i applikationen. Den ene er ”MapLokation”, som bruges når<br />
markeringen på kortet skal vises med punktmarkering, eventuelt med brugerdefineret ikon. Den<br />
anden er ”MapOmraade”, som giver en markering på kortet i <strong>for</strong>m af et polygon. Den tredje<br />
indholdstype er ”MapRute”, som bruges til at definere en rute i systemet. Denne vil blive vist som<br />
en rute på kortet og eventuelt med en tilhørende rutevejledning. Den fjerde indholdstype er<br />
”MarkerType”, som er indholdstypen <strong>for</strong> det element, som bruges i listen<br />
”<strong>Google</strong>Map.MarkerTypes”, hvor hierarkiet <strong>for</strong> markeringernes typer oprettes.<br />
På billedet neden<strong>for</strong> kan man se, hvordan to af indholdstyperne defineres. Man kan også se hvordan<br />
indholdstyperne refererer til <strong>for</strong>skellige felter. Felterne fra ”<strong>Google</strong>MapMarkerBase” er ikke<br />
nødvendige i ”MapLokation”, da disse er nedarvet. Nedarvingen sker via indholdstypernes ID, som<br />
på billedet er markeret med de to røde pile (pilene er tegnet ind på billedet efterfølgende).<br />
Ved oprettelsen af felterne skal der skabes en <strong>for</strong>bindelse mellem feltet ”<strong>Google</strong>MapIcon” og det<br />
billedbibliotek, som holder ikonerne. Denne <strong>for</strong>bindelse skabes med et såkaldt lookup-felt. Et<br />
lookup-felt er et sharepoint-felt, som kigger ned i en liste og viser titlen på elementerne fra listen i<br />
en dropdown menu. Men sådanne en <strong>for</strong>bindelse skabes via listens GUID. GUID står <strong>for</strong> ”Globally<br />
Unique Identifier”. Et GUID er et 32 tegn langt id. Det er også GUID’s, som ligger til grund <strong>for</strong><br />
indholdstypernes og felternes ID. Ved nedarving splittes flere GUID’s af to nuller (”00”). Det er<br />
lige blevet <strong>for</strong>klaret at felter og indholdstyper skal oprettes før listerne. Mens det samtidig er<br />
nødvendigt at kende en listes GUID ved oprettelsen af felterne, altså før listen er oprettet. Dette er<br />
modstridende, og det har der<strong>for</strong> været nødvendigt at lave efterbehandling på felterne. Dertil er der<br />
udviklet en ”feature reciever”. Dette er en C# klasse, som lytter på om en webstedsfunktion bliver<br />
aktiveret. Da listerne og felterne alle oprettes ved aktivering af en webstedsfunktion, kan man lige<br />
efter aktiveringstidspunktet lave efterbehandling på feltet. På nedenstående billede kan man se, vist<br />
med den røde pil, at lookup-feltet har en liste variabel. Denne er sat til værdien ”{76690994-1699-<br />
4fb8-ba0d-1029be3d70da}”. Denne værdi er en midlertidig værdi, som skal bruges til at genkende<br />
liste variablen.<br />
44
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
På tidspunktet hvor webstedsfunktionen aktiveres fanges handlingen ”feature receiveren” i C#<br />
klassen ”FixLookupFields”. Denne kan ses på billedet neden<strong>for</strong>. Her bruges det midlertidige GUID,<br />
til at genkende listevariablen og sætte den til det korrekte GUID fra listen<br />
”<strong>Google</strong>Map.PictureLibrary”. Dette sættes på feltet ”<strong>Google</strong>MapIcon”, som er det samme felt der<br />
er vist på ovenstående billede. Når de korrekte GUID’s er sat, opdateres feltet og det websted, hvor<br />
feltet lever. For at se et bedre billede af nedenstående screenshot henvises til Appendiks<br />
ScreenShot5.<br />
<strong>Google</strong> <strong>Maps</strong> feltet<br />
Som beskrevet tidligere indeholder Sharepoint nogle standard felter og nogle standard felttyper,<br />
som tekst input, dato, bruger mfl. Men Sharepoint indeholder ikke en felttype til geografisk<br />
koordinatudvælgelse. Da denne applikation bygger på at administratorer skal kunne oprette og<br />
placere geografiske punkter ville det give stor brugervenlighed, hvis de kunne angive punkterne<br />
direkte på et kort frem <strong>for</strong> manuelt at skulle indtaste højde og breddegrader. Der<strong>for</strong> er der udviklet<br />
en felttype til netop dette.<br />
Felttypen hedder ”<strong>Google</strong>MapField” og bruges ved feltet ”Koordinat” i indholdstyperne<br />
”MapLokation” og ”MapOmraade”. Felttypen nedarver fra standard Sharepoint felttypen<br />
”SPTextField”. Men i stedet <strong>for</strong> at vise den almindelige tekstboks til at skrive input i, benytter<br />
felttypen den dertil udviklede felteditor, kaldet ”<strong>Google</strong>MapFieldEditor”. Dette er endnu en C#<br />
klasse, men som nedarver fra ”BaseFieldControl”. Af nedenstående kode kan man se, hvordan den<br />
dertil udviklede felteditor loades ind i den nye felttype ”<strong>Google</strong>MapField”.<br />
45
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Inde i ”<strong>Google</strong>MapFieldEditor” klassen styres de grafiske elementer og deres logik bag, som bliver<br />
brugt når et element med feltet tilknyttet bliver vist eller redigeret. Når feltet bliver vist eller<br />
værdien af feltet skal hentes, bliver en streng med de geografiske koordinater udskrevet. Men når<br />
feltet bruges under redigering, bliver der vist en hel del mere. Dette sker når administratorer af<br />
applikationen skal oprette eller ændre på markeringer i systemet. Det sker ved, at administratorerne<br />
går ind i Sharepoint listen ”<strong>Google</strong>Map.Markers” og trykker ”nyt element” eller ”rediger” på et<br />
tidligere oprettet element. I en felteditor er der to filer til rådighed. En ”.ascx” fil, hvori det primære<br />
layout styres med html og ASP, samt en ”.cs” fil, hvori den bagvedliggende logik styres. I<br />
Appendiks ScreenShot6 kan man se, hvordan disse filer ligger i projektstrukturen.<br />
I ASCX filen defineres html og ASP komponenterne som vist neden<strong>for</strong>. Dette giver to tekstbokse,<br />
to beskrivende tekster, en knap og et div-element til at vise et kort. Resultatet kan ses på Appendiks<br />
ScreenShot8. Neden<strong>for</strong> kan man se, hvordan komponenterne defineres i ASCX filen, som hedder<br />
”<strong>Google</strong>MapFieldEditor.ascx”. På billedet kan man også se at linie 7-55 er lukket sammen. Dette er<br />
javascript, som håndterer at en administrator kan sætte sin markering ved at indtaste en adresse. Et<br />
større billede af nedenstående kode kan ses i Appendiks ScreenShot7.<br />
Der er tre måder feltet ”Koordinat” kan få sat sin værdi. Med den ene måde kan administratorerne<br />
manuelt indtaste højde og breddegrader. Med den anden kan de indtaste en adresse og lade systemet<br />
finde højde og breddegader, som passer til adressen. Med den tredje måde kan administratorerne<br />
benytte kortet til at udpege koordinater. I denne funktion kan administratorerne holde ”CTRL” nede<br />
og trykke på kortet. Der vil derefter blive oprettet et punkt på det sted, hvor der blev trykket.<br />
Koordinatet til punktet vil automatisk blive skrevet ind i tekstboksen til koordinatstrengen. Punktet<br />
kan derefter flyttes rundt ved hjælp af ”drag and drop” princippet. Koordinatet vil automatisk ændre<br />
sig, så det passer til markeringen. En markering kan også slettes igen ved hjælp af kort-funktionen.<br />
Igen holdes ”CTRL” nede og denne gang trykkes der på en allerede oprettet markering.<br />
De <strong>for</strong>skellige måder at sætte koordinater på, er alle implementeret med JavaScript.<br />
Funktionaliteten til at indtaste adresser og få dem vist er implementeret i ovenstående billede, hvor<br />
46
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
JavaScriptet er lukket sammen (kodelinje 7-55). Funktionaliteten til at oprette koordinater ved at<br />
trykke på kortet, flytte dem rundt og slette dem igen, er implementeret i metoden ”addScripts()”.<br />
Denne metode bliver kaldt i den bagvedliggende ”.cs” fil, kaldet ”<strong>Google</strong>MapFieldEditor.cs”.<br />
Neden<strong>for</strong> kan man se, hvordan ”addScripts()” bliver kaldt som det sidste i ”CreateChildControls()”.<br />
Selve metoden ”addScripts()” er på nedenstående billede lukket sammen af hensyn til<br />
overskuelighed. Men den kan ses i kodelinje 57-159. Dele af denne metode bliver beskrevet om lidt.<br />
På skærmbilledet kan man også se, at der ud fra TemplateContaineren, som blev defineret i ASCX<br />
filen, findes TextBox kontrollen ”koordinattext”. Dette bliver gjort <strong>for</strong>di at kontrollens unikke id<br />
skal bruges i metoden ”addScripts()”.<br />
Som <strong>for</strong>klaret tidligere, kan man benytte kortet til at trykke på det og få et koordinat. Man kan også<br />
bruge kortet til at slette koordinater igen. Den del af metoden ”addScript()”, som håndterer dette<br />
kan ses neden<strong>for</strong>. Her oprettes det JavaScript, som binder et ”click event” op på kortet. Når<br />
administratoren trykker på kortet, vil denne metode aktiveres. Metoden modtager to parametre,<br />
”overlay” og ”point”. Hvis ”overlay” er sat, har administratoren trykket på et tidligere oprettet<br />
koordinat, og dette skal der<strong>for</strong> slettes. Hvis kun ”point” er sat, har administratoren trykket på et nyt<br />
sted på kortet, og der skal oprettes et koordinat <strong>for</strong> dette sted.<br />
Hvis en administrator ønsker at lave et helt område som en markering, kan dette lade sig gøre ved<br />
brug af polygoner. Et polygon oprettes ud fra en række af koordinater, som placeres som<br />
hjørnepunkter i polygonet. Til at angive en sådan række af koordinater bruges også felttypen<br />
47
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
”<strong>Google</strong>MapField”. I stedet <strong>for</strong> at sætte ét koordinat på kortet sættes en hel række, og disse<br />
koordinater danner hjørner <strong>for</strong> det endelige polygon. Der vil dog stadig kun blive vist et polygon,<br />
hvis markeringen er oprettet ud fra indholdstypen ”MapOmraade” eller en anden indholdstype, som<br />
nedarver fra ”MapOmraade”. Et eksempel på oprettelse af sådan et område kan ses på Appendiks<br />
ScreenShot9. Resultatet af et område kan ses på Appendiks ScreenShot1.<br />
Metoden ”addScripts()” tilføjer også JavaScripts til at lytte på ”CTRL” knappen. Denne knap bliver<br />
brugt til at oprette og slette koordinater, og det er der<strong>for</strong> nødvendigt at vide, om knappen er trykket<br />
ned, mens administratoren klikker på kortet. Det sørger nedenstående JavaScripts <strong>for</strong>. Disse lytter<br />
på ”onkeydown” og ”onkeyup” events på hjemmesiden, og kigger derefter på ”keyCode”, som er<br />
talværdien <strong>for</strong> den knap, som er trykket. Hvis denne værdi er lig med 17 registreres at ”CTRL” er<br />
trykket.<br />
Hvis en tidligere oprettet markering bliver redigeret af en administrator, vil koordinatfeltet allerede<br />
være sat. Der<strong>for</strong> har den bagvedliggende fil, ”<strong>Google</strong>MapFieldEditor.cs” også en metode til at vise<br />
koordinater på kortet ud fra de tidligere gemte værdier. I denne metode bruges regulære udtryk til at<br />
validere om de tidligere gemte værdier er på en <strong>for</strong>m, som kan blive vist på kortet. På billedet<br />
neden<strong>for</strong>, kan man i kodelinje 179 se, hvordan et regulært udtryk bliver oprettet. Dette udtryk<br />
bruges i kodelinje 187 til at lave en kontrol af den opsplittede ”value”. Der kaldes metoden<br />
”IsMatch()”, som <strong>for</strong>tæller om der overhovedet er en lighed. Derefter sammenlignes ”s” med den<br />
lighed der er, <strong>for</strong> at sikre at der ikke er andre tegn i ”s”, end dem det regulære udtryk fandt.<br />
48
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Type feltet<br />
Ligesom <strong>Google</strong> <strong>Maps</strong> felttypen er der implementeret en anden felttype. Felttypen hedder<br />
”Typestruktur”. Denne felttype bruges i feltet ”MarkerType”, som er en del af indholdstypen<br />
”<strong>Google</strong>MapMarkerBase”, og der<strong>for</strong> knyttes til alle markeringer i applikationen. Feltet bruges til at<br />
kategorisere markeringerne i en hierarkisk struktur. Denne struktur er særdeles anvendelig når<br />
brugerne skal udvælge og indsnævre de markeringer på kortet, som de ønsker at få vist.<br />
Typestruktur felttypen er opbygget af tre filer ligesom <strong>Google</strong> <strong>Maps</strong> felttypen. Men i stedet <strong>for</strong><br />
tekstbokse og et kort viser typestruktur felttypen et ”TreeView”. TreeView er en webkontrol til at<br />
vise hierarkisk data. Et TreeView kan se ud som nedenstående, hvor der er mulighed <strong>for</strong> at afmærke<br />
hvilke data i kontrollen, som skal gemmes i feltet.<br />
Hvis et punkt magen til ovenstående blev oprettet i systemet, ville en bruger fra <strong>for</strong>siden med kortet<br />
kunne navigere sig ned igennem strukturen og få vist lige præcis det eller de punkter, som hører<br />
under ”Hjemmehjælp og – pleje”.<br />
Applikationsdatatyper<br />
I applikationen er der tre <strong>for</strong>skellige datatyper. En som <strong>Google</strong> <strong>Maps</strong> API <strong>for</strong>står, en som opbevares<br />
i Sharepoint og en tredje, som bruges til at binde de to andre sammen. Disse datatyper bliver i resten<br />
af rapporten benævnt som applikationsdatatyper. Disse tredje datatyper lever kun i denne ene<br />
49
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
applikation. De benyttes til at give applikationen den nødvendige fleksibilitet, <strong>for</strong> at man eventuelt<br />
ville kunne udskifte View-laget eller Data-laget af systemet.<br />
Applikationsdatatyperne består af ”Koordinat”, ”Punkt”, ”Omraade”, ”Rute” og søgeresultat kaldet<br />
”SearchResult”. Disse bruges som beskrevet i designafsnittet, hvor et ”Punkt” består af et<br />
”Koordinat” plus nogle beskrivende variabler. Et ”Omraade” består af en række ”Koordinat” plus<br />
beskrivende variabler osv. I kommunikationsdiagrammet neden<strong>for</strong> kan der ses, hvordan<br />
applikationsdatatyperne bliver oprettet og brugt i systemet. Her ses hvordan brugeren <strong>for</strong>espørger<br />
en datatype, og hvordan kaldet bliver sendt ned igennem systemet. Det kan ses hvordan ”Model”<br />
laget oprettet applikationsdatatypen ”Punkt” og sender den retur igennem systemet. Det kan også<br />
ses hvordan ”View” laget kan oprette <strong>Google</strong> <strong>Maps</strong> data, som kan vises på kortet, ud fra<br />
applikationsdatatypen ”Punkt”.<br />
Bruger<br />
View: <strong>Google</strong><br />
Datatyper<br />
Controller<br />
Tryk på markeringstype GetPunkt GetPunkt<br />
Vis <strong>Google</strong> markering på kortet<br />
Opretter <strong>Google</strong><br />
markering ud fra Punktet<br />
Return Punkt<br />
Return Punkt<br />
Model:<br />
Sharepoint<br />
Datatyper<br />
Opret Punkt<br />
Return Punkt<br />
Opretter Punkt ud<br />
fra Sharepoint data<br />
<strong>Google</strong> <strong>Maps</strong> data<br />
<strong>Google</strong> <strong>Maps</strong> data er sidste datatype, som benyttes i applikationen. Disse datatyper er tilgængelige<br />
gennem <strong>Google</strong> <strong>Maps</strong> API, som udelukkende tilgås fra JavaScript. <strong>Google</strong> <strong>Maps</strong> API gør blandt<br />
andet rutemarkeringer, punktmarkeringer og polygonmarkeringer tilgængelige. En punktmarkering<br />
kaldes ”GMarker”. Oprettelsen af et ”GMarker” tager som minimum et koordinat som parameter.<br />
Koordinater i <strong>Google</strong> <strong>Maps</strong> API hedder ”GLatLng”, som er en <strong>for</strong>kortelse <strong>for</strong> ”latitude” og<br />
”longitude”, hvilket er længde- og breddegrader. Ud over et koordinat kan ”GMarker” tage en<br />
række parameter samlet i en hashtabel. Disse parametre kunne være ikonet på markeringen,<br />
muligheden <strong>for</strong> at flytte rundt på feltet og lign.<br />
Den simpleste måde at definere et punkt kan ses neden<strong>for</strong>. Her oprettes en variabel kaldet ”point”<br />
ud fra to koordinater. Derefter bruges dette ”point” til at oprette ”marker”, som er en <strong>Google</strong><br />
markør. Sidst tilføjes ”marker” til kortet.<br />
Punkt<br />
50
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Et andet sted i koden, faktisk der hvor markeringerne bliver oprettet ud fra brugernes <strong>for</strong>espørgsel,<br />
ser <strong>Google</strong> <strong>Maps</strong> API kaldet <strong>for</strong> en ny markering ud som nedenstående. Her angives både et punkt<br />
kaldet ”punkt” og en variabel kaldet ”markerOptions”. ”markerOptions” er en hashtabel, hvor<br />
nøglerne er ”draggable”, ”icon” og ”title”. De tilhørende værdier angiver henholdsvis om punktet<br />
må flyttes rundt på, udseendet af ikonet og den tekst der skal vises når musen holdes hen over en<br />
markering på kortet. Oprettelsen af sådan en markering ses neden<strong>for</strong>, hvor ”extension” er en<br />
variabel der bruges i denne applikation til at navngive dynamisk oprettede markeringer.<br />
Et polygon hedder i <strong>Google</strong> <strong>Maps</strong> API ”GPolygon” og oprettes og tilføjes til kortet på samme måde<br />
som ”GMarker”. I stedet <strong>for</strong> ét punkt tager et polygon adskillige punkter. Et polygon har heller ikke<br />
mulighed <strong>for</strong> at vise en beskrivelse, men dette er implementeret i applikationen ved, at der benyttes<br />
en usynlig ”GMarker”. Dette kan der læses mere om i implementeringsafsnittet ”Brugergrænseflade<br />
– <strong>Google</strong> <strong>Maps</strong>”.<br />
Ruter og deres beskrivelser fungerer lidt anderledes end standardmarkeringerne, som man tilføjer til<br />
kortet ved metoden ”addOverlay”. En rute i <strong>Google</strong> <strong>Maps</strong> API hedder ”GDirections”, og tager en<br />
reference til kortet som parameter til konstruktøren. Hvis der ønskes en rutevejledning og ikke kun<br />
en rute vist på kortet, skal en reference til en placeholder også gives med som parameter til<br />
konstruktøren. På ”GDirections” objektet kan metoden ”load” kaldes. Denne tager en streng, som er<br />
opdelt med ”from:” og ”to:”. Dette angiver, hvor ruten skal starte og slutte. Dette kan ses neden<strong>for</strong>.<br />
Dette var de tre typer af data fra <strong>Google</strong> <strong>Maps</strong> API, som bliver brugt i denne applikation. Andre<br />
typer, som andre ”korttyper” og hele ”lag”, er ikke brugt i applikationen. Dog bliver nogle af disse<br />
lag indirekte brugt, når der hentes dynamisk data. Dette kan der læses mere om i<br />
implementeringsafsnittet ”Dynamisk data”.<br />
Dynamisk data<br />
En del af problem<strong>for</strong>muleringen lød på at undersøge tilgængeligheden af dynamisk data, samt at<br />
undersøge hvordan geodata fra andre kilder kan blive vist på et <strong>Google</strong> kort.<br />
51
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Tilgængelighed<br />
Der er megen snak på internettet omkring geodata. Flere store sites, som ”twitter.com” og<br />
”wikipedia” arbejder med muligheden <strong>for</strong> at knytte et geografisk koordinat til en artikel eller en<br />
tweet. Neden<strong>for</strong> ses et lille skærmbillede af wikipedia artiklen ”Den Lille Havfrue”, som har fået<br />
tilknyttet et koordinat.<br />
Disse store sites har også implementeret muligheden <strong>for</strong>, at man kan hente deres geodata og få det<br />
vist på sit kort. Dette gøres ved at der bliver oprettet et ”overlay”, som er et lag der ligger hen over<br />
kortet. Dette er ikke enkelte markeringer som punkter og polygoner, men det er et helt lag, hvor i<br />
laget der kan ligge alt fra de almindelige <strong>Google</strong> <strong>Maps</strong> markeringer til billeder. Det fungerer på<br />
samme måde, som når man ser et <strong>Google</strong> kort i satellit funktion, og så har vejnettet liggende hen<br />
over.<br />
En anden måde at gøre geodata tilgængelige på, er gennem KML filer. KML står <strong>for</strong> ”Keyhole<br />
Markup Language”. KML filer er en XML standard udviklet til at beskrive geografisk data. I KML<br />
filer kan der defineres markeringer, polygoner, billeder m.m. Alt sammen med udgangspunkt i<br />
koordinater bestående af længdegrader og breddegrader. Neden<strong>for</strong> kan der ses et eksempel på,<br />
hvordan en KML fil kunne se ud med Frederiksberg Kommune som et polygon.<br />
Det er også populært på nettet, at lave såkaldte ”mashups”. Et ”mashup” er en samling af data fra<br />
<strong>for</strong>skellige steder, som tilsammen giver en ny <strong>for</strong>m <strong>for</strong> data. Et klassisk eksempel er hvor brugerne<br />
henter billeder af de kendte fra et sted, henter in<strong>for</strong>mation omkring de kendtes fødselsdage et andet<br />
sted og henter deres adresser et tredje sted. Ud fra disse data laver de en kalender, hvor man på et<br />
kort kan se hvor og hvornår de kendte har fødselsdag. Et andet klassisk eksempel, som man støder<br />
på, hvis man leder efter ”<strong>Google</strong> maps mashup” på nettet, er sportsbegivenheder koblet sammen<br />
med lokationer og dato. Man kan finde kort, hvor man kan se alle de amerikanske basketballkampe<br />
placeret på et kort, som markerer hallerne, samt en beskrivelse af hvilke kampe der spilles hvor og<br />
hvornår. Eller et tredje klassisk eksempel er ”Find den nærmeste Mc Donalds”. Disse mashups er<br />
stort set altid med amerikanske data.<br />
52
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Disse ”mashups” kan være ganske morsomme, men muligvis mindre relevante set med danske øjne.<br />
Hvis der stadig holdes fast i en kommune som eksempel <strong>for</strong> brugen af denne applikation, så kunne<br />
det være mere interessant med tilgængelige data der omhandler danske institutioner eller lign. Disse<br />
data er bare ikke offentligt tilgængelige på nuværende tidspunkt. Et af de steder hvor der er bedst<br />
tilgængelig dansk geodata er ”http://www.micro<strong>for</strong>mats.dk/”. Her er der eksempler på ”mashups” til<br />
flere <strong>for</strong>skellige teknologier, som <strong>for</strong> eksempel <strong>Google</strong> <strong>Maps</strong>, Bing <strong>Maps</strong> og <strong>Google</strong> Earth. Et<br />
eksempel kunne være kommunernes opdeling vist ved kommunegrænser i <strong>for</strong>skellige farver. Men<br />
internt kommunedata, som <strong>for</strong> eksempel hvor mange børn der er i en børnehave, er ikke offentligt<br />
tilgængeligt.<br />
En anden spiller på ”geodata-banen” er Geodata Danmark. De skriver som nyhed på deres<br />
hjemmeside.<br />
Geodata Danmark har blandet andet også arbejdet med et system, som ud fra beskrivelsen kan det<br />
samme, plus lidt mere, som dette projekts applikation. En beskrivelse af deres system kan læses på<br />
deres hjemmeside. 3 Billedet neden<strong>for</strong> er fra deres beskrivelse.<br />
De tilbyder blandt andet at hoste kommuners geodata, hvis de ikke selv vil have det liggende.<br />
Der er altså flere virksomheder, som arbejder på at gøre geodata mere almindeligt og mere<br />
tilgængeligt.<br />
Brug af data.<br />
Som beskrevet oven<strong>for</strong> er der ikke meget offentligt data, som virker brugbart <strong>for</strong> den applikation,<br />
som denne rapport omhandler. Dette skyldes manglende tilgængelighed. Men denne applikation er<br />
bygget til at være så fleksibel som muligt, så hvis der om et par år bliver mere tilgængeligt data, kan<br />
man uden problemer ændre datakilden til applikationen. Samtidig vil en applikation som denne<br />
være i stand til, at kunne hjælpe brugerne med at få oprettet geodata og få sat koordinater på deres<br />
data.<br />
Som beskrevet tidligere kan geodata gøres tilgængeligt som KML filer eller gennem andre sites<br />
API. Selvom de nedenstående aktuelle eksempler ikke giver meget værdi i <strong>for</strong>hold til rapportens<br />
applikation, så er der under projekt<strong>for</strong>løbet blevet lavet en række undersøgelser af, hvordan man<br />
kan få eksternt data på systemet. Det ene der blev undersøgt er ved at benytte <strong>Google</strong> <strong>Maps</strong> API<br />
3 <strong>Google</strong> <strong>Maps</strong> system fra Geodata Danmark ”http://www.geodata.dk/fileadmin/Dokumenter/Microsoft_Word_-<br />
_Arc2google-koncept1.pdf”<br />
53
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
sammen med flickr’s API. Den anden undersøgelse er ved at tilgå Wikipedia’s geotaggede data.<br />
Tredje undersøgelse er ved at tilgå en tilgængelig KML fil.<br />
Flickr<br />
For at vise et eksempel, bruges flickr’s API. Flickr er en Web2.0 hjemmeside og internettjeneste,<br />
hvor brugerne skaber indholdet af siden ved at dele billeder, og give dem ”tags” til at kategorisere<br />
billederne. Ved at bruge flickr’s API, som genererer en XML fil og ved at bruge <strong>Google</strong> <strong>Maps</strong> API<br />
til at omdanne indholdet af filen, inklusiv billeder og tags til geodata, kan vi få vist en række<br />
markeringer på kortet, som er tagget med ”denmark”. Neden<strong>for</strong> kan der ses, hvordan sådan et kald<br />
ser ud. Til at vise hvordan dette ser ud, benyttes applikationens konfigurationsvariabel ”Costum<br />
Script”, som blev udviklet netop til at give administratorerne mulighed <strong>for</strong> at tilføje indhold som<br />
dette.<br />
Neden<strong>for</strong> kan man se, hvordan resultatet ser ud. Der vises indhold fra flickr med tagget “denmark”.<br />
Det er alle de blå markeringer.<br />
Wikipedia<br />
Et andet eksempel, som ikke bruger geoxml, men hvor tjenesten selv har stillet et geografisk lag til<br />
rådighed er Wikipedia. Neden<strong>for</strong> vises et kald til wikipedia, som viser engelske artikler, med<br />
geografiske koordinater. Der er desværre ingen danske artikler, som kan blive lagt på kortet på<br />
følgende måde, men <strong>for</strong> eksemplets skyld bruges de engelske.<br />
Dette giver følgende visning på kortet.<br />
54
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
KML fil<br />
For at en KML fil kan blive vist på kortet skal den ligge på en server, hvor den kan tilgås udefra.<br />
Det er altså ikke nok at have sin KML fil liggende på en server på det lokale netværk. Til dette<br />
eksempel er der fundet en KML fil med dansk data. Dataet viser retskredse i Danmark. Lige som<br />
med flickr benyttes her ”GGeoXml”.<br />
Dette giver et resultat som kan ses neden<strong>for</strong>.<br />
55
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Et andet eksempel med online tilgængelig KML fil, er Frederiksberg kommune. Denne fil er også<br />
tilgængelig på micro<strong>for</strong>mats.dk. Neden <strong>for</strong> ses koden.<br />
Dette giver følgende på kortet:<br />
Delkonklusion – Implementering<br />
Implementeringen er nu beskrevet uden at gå helt i dybden med hver eneste detalje. Der er blevet<br />
gennemgået implementeringen af system arkitekturen, de <strong>for</strong>skellige lag i applikationen og hvordan<br />
de håndterer deres ansvarsområder. Der er blevet beskrevet hvordan de <strong>for</strong>skellige typer af data og<br />
interfaces fungerer. Der er blevet beskrevet hvordan specielt udviklede Sharepoint lister,<br />
indholdstyper og felter giver den ønskede funktionalitet til oprettelse og administrering af systemet.<br />
56
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Der er også blevet set på eksternt data, eller mangel på samme, og muligheden <strong>for</strong> at benytte sig af<br />
dette på en dynamisk måde.<br />
57
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Test<br />
I dette afsnit vil der blive opstillet en blackbox test <strong>for</strong> systemet. Dette vil være en test, hvor<br />
funktionaliteten testes i <strong>for</strong>hold til de krav, der blev stillet til applikationen under analysen. Disse<br />
kan der læses om i afsnittene ”Problem<strong>for</strong>mulering” og ”Usecase”.<br />
Nedenstående skema viser en kort gennemgang af den test, der er blevet udført. For at læse hele<br />
testen, herunder de <strong>for</strong>ventede resultater og de faktiske resultater henvises der til Appendiks<br />
afsnittet ”Test”.<br />
Metode/krav Hvordan det blev testet Resultat<br />
Visning af punkt Et punkt er oprettet i systemet med typen ”punkt<br />
test”. Denne type vælges, <strong>for</strong> at teste om punktet<br />
bliver korrekt vist på kortet.<br />
Visning af område Et område er oprettet i systemet et område er angivet<br />
med tilfældige farver. Områdets type vælges i listen<br />
af markeringstyper på <strong>for</strong>siden. Der kigges på kortet,<br />
<strong>for</strong> at se om områdemarkeringen bliver vist. Der<br />
klikkes på området, <strong>for</strong> at se om beskrivelsen bliver<br />
vist. Hvis dette er tilfældet, er testen lykkedes.<br />
Visning af rute En rute er oprettet i systemet angivet som to adresser.<br />
Adresserne er ”Smedeholm 10, Herlev” og<br />
”Øresundsvej 24, København”. Rutens type vælges<br />
fra listen af markeringstyper på <strong>for</strong>siden. Der kigges<br />
på kortet, <strong>for</strong> at se om ruten bliver vist. Der kigges<br />
om ruten starter og slutter i de to korrekte adresser.<br />
Hvis rutebeskrivelsen ikke bliver vist, prøves der at<br />
sætte konfigurationsvariablen og udvælge ruten igen.<br />
Der ses om beskrivelsen bliver vist.<br />
Udvælgelse af data En række typer og undertyper er oprettet i systemet,<br />
og minimum 2 punkter er oprettet, som er knyttet til<br />
<strong>for</strong>skellige undertyper, som ligger under samme<br />
overordnet type. En overordnet type vælges i type<br />
listen på <strong>for</strong>siden. Typen der vælges hed ”Ældre og<br />
Pension”. Der kigge på kortet <strong>for</strong> at se om alle<br />
markeringerne <strong>for</strong> den enkelte type vises. Derefter<br />
vælges en undertype til den først valgte overordnede<br />
type. Undertypen der blev valgt hed ”Handicap- og<br />
ældreboliger”. Der <strong>for</strong>ventes nu, at kun markeringer<br />
Succes<br />
Succes<br />
Succes<br />
Succes<br />
58
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
under denne undertype vil blive vist på kortet.<br />
Søgning på data Flere markeringer er oprettet i systemet. Fra <strong>for</strong>siden<br />
indtastes et søgeord i tekstboksen i søgeinterfacet.<br />
Der blev i testen søgt på ”have”. Der <strong>for</strong>ventes at en<br />
række resultater bliver vist på skærmen, og ved at<br />
klikke på disse resultater, skal det valgte resultat<br />
blive vist på kortet.<br />
Oprettelse af punkt Sharepoint åbnes op, og listen <strong>for</strong> markeringer findes.<br />
Der trykkes på ”new” og der vælges indholdstypen<br />
kaldet ”MapLokation”. Titel og beskrivelse udfyldes.<br />
Ikonet vælges i bunden. Koordinatet sættes ved at<br />
indtaste adressen ”Øresundsvej 24, København” og<br />
der trykkes ”Tilføj”. Punktets type sættes. Der<br />
trykkes nu ”OK” nederst på siden. Der kontrolleres<br />
på kortet om punktet er korrekt oprettet i systemet.<br />
Oprettelse af område Sharepoint åbnes op, og listen <strong>for</strong> markeringer findes.<br />
Der trykkes på ”new” og der vælges indholdstypen<br />
kaldet ”MapOmraade”. Titel og beskrivelse udfyldes.<br />
Farven sættes til ”333333” på både områdets kanter<br />
og det areal i mellem kanterne. Koordinaterne sættes<br />
ved at holde ”CTRL” nede og trykke med musen på<br />
kortet. Områdets type sættes. Der trykkes nu ”OK”<br />
nederst på siden. Der kontrolleres på kortet om<br />
punktet er korrekt oprettet i systemet.<br />
Oprettelse af rute Sharepoint åbnes op, og listen <strong>for</strong> markeringer findes.<br />
Der trykkes på ”new” og der vælges indholdstypen<br />
kaldet ”MapRute”. Titel og beskrivelse udfyldes.<br />
Titel sættes til ”Til arbejde”. Start adressen sættes til<br />
”Øresundsvej 24, København” og slut adressen<br />
sættes til ”Smedeholm 10, Herlev”. Rutens type<br />
sættes Der trykkes nu ”OK” nederst på siden. Der<br />
kontrolleres på kortet om ruten er korrekt oprettet i<br />
systemet.<br />
Oprettelse af nyt ikon og<br />
valg af nyt ikon til punkt<br />
Sharepoint åbnes op, og biblioteket<br />
”<strong>Google</strong>Map.PictureLibrary” findes. Der tilføjes et<br />
nyt ikon til dette bibliotek og ikonet angives med en<br />
titel. Listen <strong>for</strong> markeringer findes herefter. Der<br />
trykkes på ”new” og der vælges indholdstypen kaldet<br />
Succes<br />
Succes<br />
Succes<br />
Succes<br />
Succes<br />
59
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
”MapLokation”. Titel og beskrivelse udfyldes. Det<br />
nye ikon vælges i bunden i dropdown menuen.<br />
Koordinatet sættes ved at indtaste en adresse og der<br />
trykkes ”Tilføj”. Punktets type sættes. Der trykkes nu<br />
”OK” nederst på siden. Der kontrolleres på kortet om<br />
punktet er korrekt oprettet i systemet.<br />
Oprettelse af type Sharepoint åbnes op, og listen<br />
”<strong>Google</strong>Map.MarkerTypes” findes. Der trykkes på<br />
”new” og der vælges indholdstypen kaldet<br />
”MarkerType”. Typen udfyldes med navn. Herefter<br />
findes listen ”<strong>Google</strong>Map.Markers”, som og trykkes<br />
”New” og vælges en indholdstype. I testen blev der<br />
valgt ”MapLokation”. Ved oprettelse af det nye<br />
punkt kan den nye markeringstype vælges. Punktet<br />
oprettes. Forsiden findes og her ses om den nye type<br />
bliver vist i listen af markeringstyper. Den nye type<br />
vælges og der ses om det nye punkt med den nye<br />
type bliver vist korrekt på kortet.<br />
Succes<br />
Delkonklusion – Test<br />
Ud fra testen kan vi se at de krav til funktionaliteten af applikationen, som blev beskrevet i analyse<br />
afsnittet, er implementeret og virker efter hensigten.<br />
60
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Konklusion<br />
Ud fra rapporten og dens testafsnit kan der konkluderes, at applikationen virker efter hensigten.<br />
Applikationen er i stand til at skabe et brugervenligt interface til administratorer, så de kan oprette<br />
og vedligeholde geografisk data. Samtidig er applikationen i stand til at præsentere dette data<br />
visuelt på et kort ved hjælp af <strong>Google</strong> <strong>Maps</strong> API. Hvis billederne i rapporten ikke har været<br />
dækkende, kan yderligere tre billeder af applikationen ses på Appendiks ScreenShot16,<br />
ScreenShot17 og ScreenShot18.<br />
Det kan konkluderes at det er lykkedes at lave applikationen så fleksibel, at den kan installeres på<br />
flere Sharepoint installationer, og endda på <strong>for</strong>skellige sider i samme installation og være<br />
konfigureret <strong>for</strong>skelligt hvert sted. Applikationen er blevet udviklet, så den kan benytte sig af nogle<br />
af de funktioner som Sharepoint stiller til rådighed. Som <strong>for</strong> eksempel når applikationen kan tage<br />
højde <strong>for</strong>, at en administrator direkte i Sharepoint vil være i stand til at oprette nye indholdstyper og<br />
felter.<br />
Systemarkitekturen har medvirket til, at applikationen nemt vil kunne genbruges med andre<br />
datakilder eller andet præsentations-lag. Arkitekturen gør også vedligeholdelsen nemmere, ved at<br />
applikationens ansvarsområder opdeles på en overskuelig måde.<br />
Der var desværre ikke så meget geografisk data offentligt tilgængeligt, som man kunne have håbet<br />
på. Det tyder dog på, at geodata er kommet <strong>for</strong> at blive og at det anses som en brugervenlig og<br />
intuitiv måde at se data på.<br />
Projektet har givet stor indsigt i Sharepoint og hvordan der udvikles op i mod en så stor og<br />
kompliceret portal som denne. Det har givet en stor indsigt i hvad <strong>Google</strong> <strong>Maps</strong> er, og hvordan det<br />
kan bruges i sammenhæng med data af <strong>for</strong>skellige typer. Det har samtidig givet et indblik i hvad det<br />
vil sige, at noget er ”Web 2.0”, og hvordan denne type online websteder og tjenester fungerer og<br />
stilles til rådighed.<br />
61
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Perspektivering<br />
Vi er ikke alene om at udvikle løsninger til præsentation af geografisk data. Vi er heller ikke de<br />
eneste, som har kommuner i tankerne. Et godt eksempel kan være løsningen fra Geodata Danmark,<br />
som blev beskrevet i implementeringsafsnittet Dynamisk Data.<br />
Et andet eksempel, hvor en løsning er taget i brug er Haderslev Kommune. De har implementeret et<br />
kort, som giver brugerne mulighed <strong>for</strong> at få vist in<strong>for</strong>mationer omkring ”skoler, børnehaver,<br />
luftfotos og meget mere” (citat fra deres hjemmeside adresse:<br />
”http://www.haderslev.dk/index.asp?id=5359”). Dette kan også ses neden<strong>for</strong>.<br />
Hvis man tager deres applikation i brug bliver man præsenteret <strong>for</strong> et kort som nedenstående. Denne<br />
kan tilgås på linket ”http://kort.haderslev.dk/”. På deres applikation er der mulighed <strong>for</strong> at få vist<br />
<strong>for</strong>skellige korttyper og udvælge nogle data, som man ønsker vist på kortet. Dataet er grupperet i en<br />
hierarkisk struktur, hvor man sætter flueben <strong>for</strong> at få det vist.<br />
62
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Ovenstående eksempel minder utroligt meget om den løsning, som dette projekt omhandler. Dog<br />
benytter ovenstående eksempel ikke <strong>Google</strong> <strong>Maps</strong>, og de har ikke mulighed <strong>for</strong> at få vist en<br />
beskrivelse af de viste punkter, andet end den der ses øverst i billedet, som <strong>for</strong>klarer farven og<br />
ikonet. Haderslev Kommunes applikation har en meget interessant søgefunktion, hvor man kan søge<br />
ved at markere et område, og kun søge inden <strong>for</strong> det område. De har også implementeret<br />
muligheden <strong>for</strong> at tegne direkte oven på kortet. Dette kunne være smart, hvis applikationen bliver<br />
brugt af en sagsbehandler i en sag, hvor det er vigtigt at blive enige om en geografisk destination<br />
eller område.<br />
En anden kommune, som også har kortservice på deres hjemmeside er Odense Kommune. Deres<br />
kortservice kan ses på ”http://drift.kortinfo.net/Map.aspx?Site=Odense&Page=Kortopslag”. Her er<br />
data igen struktureret hierarkisk, hvor man kan udvælge <strong>for</strong>skellige institutioner, grønne områder<br />
osv. Et billede af deres kort kan ses neden<strong>for</strong>.<br />
63
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Udvidelses ideer<br />
Ingen af disse løsninger er blevet undersøgt før projektet næsten var færdigt, men det er interessant<br />
at se, hvor meget ideerne bag minder om dem, som der er blevet analyseret frem under dette<br />
eksamensprojekt.<br />
Dog havde Haderslev Kommunes applikation nogle rigtig smarte funktioner med søgning i et<br />
område og muligheden <strong>for</strong> at tegne direkte på kortet. Muligheden <strong>for</strong> at vælge markeringer med<br />
checkbokse kan også være interessant, da man derved kan få vist markeringer fra <strong>for</strong>skellige<br />
kategorier samtidig. Dette ville ikke være en stor ændring fra projektets applikations nuværende<br />
udvælgelse, da strukturen er den samme. Ændringen vil være en lille variabel ”showCheckBoxes”,<br />
som skal sættes på det nuværende system. Dette kunne alt sammen være udvidelses ideer til<br />
projektets applikation.<br />
Underskrift<br />
Dato: Underskrift:<br />
64
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Appendiks<br />
Test<br />
I dette afsnit beskrives den test der er udført på applikationen. Der er kun udført en såkaldt<br />
”blackbox test”. En sådan test består i, at testpersonen benytter systemet på samme måde, som en<br />
slutbruger vil gøre. Der opstilles en række scenarier, som testpersonen skal gennemgå, samt nogle<br />
<strong>for</strong>ventede resultater. Løbende sammenholdes de aktuelle resultater og de <strong>for</strong>ventede resultater.<br />
Denne sammenligning giver det endelige testresultat, som enten kan være ”Succes” eller ”Fejl”.<br />
Visning af punkt<br />
Forventet resultat:<br />
Der <strong>for</strong>ventes at markøren vises på kortet. Der <strong>for</strong>ventes at titlen bliver vist når musen holder over<br />
markøren. Der <strong>for</strong>ventes at beskrivelsen af punktet vises i en ”taleboble” når der trykkes med musen<br />
på markøren.<br />
Metode:<br />
Et punkt er oprettet i systemet. Punktets type vælges i listen af markeringstyper på <strong>for</strong>siden. Der<br />
kigges på kortet, <strong>for</strong> at se om markeringen bliver vist. Musen holdes over markøren <strong>for</strong> at se om det<br />
er den rigtige, og der klikkes på markøren, <strong>for</strong> at se om beskrivelsen af punktet bliver vist. Hvis<br />
dette er tilfældet, er testen lykkedes.<br />
Resultat:<br />
Resultatet af testen blev som <strong>for</strong>ventet. Et punkt kan blive vist i applikationen.<br />
Visning af område<br />
Forventet resultat:<br />
Der <strong>for</strong>ventes at område markøren vises på kortet. Der <strong>for</strong>ventes at beskrivelsen af området vises i<br />
en ”taleboble” når der trykkes med musen på området.<br />
Metode:<br />
Et område er oprettet i systemet et område er angivet med tilfældige farver. Områdets type vælges i<br />
listen af markeringstyper på <strong>for</strong>siden. Der kigges på kortet, <strong>for</strong> at se om områdemarkeringen bliver<br />
vist. Der klikkes på området, <strong>for</strong> at se om beskrivelsen bliver vist. Hvis dette er tilfældet, er testen<br />
lykkedes.<br />
Resultat:<br />
Resultatet af testen blev som <strong>for</strong>ventet. Et område kan blive vist i applikationen.<br />
Visning af rute<br />
Forventet resultat:<br />
Der <strong>for</strong>ventes at ruten vises på kortet. Hvis konfigurationsvariablen ”Vis rutebeskrivelse” er sat,<br />
<strong>for</strong>ventes, at det vises en rute på kortet og en beskrivelse ved siden af kortet. Ellers <strong>for</strong>ventes kun at<br />
blive vist en rute.<br />
65
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Metode:<br />
En rute er oprettet i systemet angivet som to adresser. Adresserne er ”Smedeholm 10, Herlev” og<br />
”Øresundsvej 24, København”. Rutens type vælges fra listen af markeringstyper på <strong>for</strong>siden. Der<br />
kigges på kortet, <strong>for</strong> at se om ruten bliver vist. Der kigges om ruten starter og slutter i de to korrekte<br />
adresser. Hvis rutebeskrivelsen ikke bliver vist, prøves der at sætte konfigurationsvariablen og<br />
udvælge ruten igen. Der ses om beskrivelsen bliver vist.<br />
Resultat:<br />
Resultatet af testen blev som <strong>for</strong>ventet. En rute kan blive vist på kortet og dens beskrivelse kan<br />
vælges til eller fra.<br />
Udvælgelse af data<br />
Forventet resultat:<br />
Der <strong>for</strong>ventes at ud valg af data, vil mere eller mindre blive vist på kortet. Der <strong>for</strong>ventes at hvis en<br />
overordnet type vælges, vil undertyper også blive valgt. Men typer på samme niveau i strukturen vil<br />
ikke blive vist.<br />
Metode:<br />
En række typer og undertyper er oprettet i systemet, og minimum 2 punkter er oprettet, som er<br />
knyttet til <strong>for</strong>skellige undertyper, som ligger under samme overordnet type. En overordnet type<br />
vælges i type listen på <strong>for</strong>siden. Typen der vælges hed ”Ældre og Pension”. Der kigge på kortet <strong>for</strong><br />
at se om alle markeringerne <strong>for</strong> den enkelte type vises. Derefter vælges en undertype til den først<br />
valgte overordnede type. Undertypen der blev valgt hed ”Handicap- og ældreboliger”. Der <strong>for</strong>ventes<br />
nu, at kun markeringer under denne undertype vil blive vist på kortet.<br />
Resultat:<br />
Resultatet af testen blev som <strong>for</strong>ventet. Ved overordnet type vises to punkter under testen. Ved valg<br />
af en undertype, som kun det ene punkt tilhørte, blev kun dette punkt vist.<br />
Søgning på data<br />
Forventet resultat:<br />
Der <strong>for</strong>ventes at kunne søge på geodata fra systemet ved hjælp af et søge interface fra <strong>for</strong>siden. Der<br />
<strong>for</strong>ventes at det fremsøgte resultat kan blive vist på kortet.<br />
Metode:<br />
Flere markeringer er oprettet i systemet. Fra <strong>for</strong>siden indtastes et søgeord i tekstboksen i<br />
søgeinterfacet. Der blev i testen søgt på ”have”. Der <strong>for</strong>ventes at en række resultater bliver vist på<br />
skærmen, og ved at klikke på disse resultater, skal det valgte resultat blive vist på kortet.<br />
Resultat:<br />
Resultatet af testen blev som <strong>for</strong>ventet. Der blev fundet 2 resultater. I systemet var der ”Finsens<br />
Have”, som er en bolig<strong>for</strong>ening og ”Søndermarken”, som har beskrivelsen ”Haven er …”. Det er<br />
muligt at trykke på overskrifterne på de to resultater. Der blev trykket på ”Finsens Have”. Kortet<br />
udvalgte den type, som ”Finsens Have” tilhørte og derved blev ”Finsens Have” vist.<br />
66
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Oprettelse af punkt<br />
Forventet resultat:<br />
Der <strong>for</strong>ventes at et punkt kan blive oprettet i systemet. Der <strong>for</strong>ventes at punktet kan oprettes med en<br />
titel, beskrivelse, et ikon og et koordinat som minimum..<br />
Metode:<br />
Sharepoint åbnes op, og listen <strong>for</strong> markeringer findes. Der trykkes på ”new” og der vælges<br />
indholdstypen kaldet ”MapLokation”. Titel og beskrivelse udfyldes. Ikonet vælges i bunden.<br />
Koordinatet sættes ved at indtaste adressen ”Øresundsvej 24, København” og der trykkes ”Tilføj”.<br />
Punktets type sættes. Der trykkes nu ”OK” nederst på siden. Der kontrolleres på kortet om punktet<br />
er korrekt oprettet i systemet.<br />
Resultat:<br />
Resultatet af testen blev som <strong>for</strong>ventet. Der blev oprettet et punkt i systemet. Punktet blev vist på<br />
den korrekte adresse og med den titel og beskrivelse, som blev angivet under testen.<br />
Oprettelse af område<br />
Forventet resultat:<br />
Der <strong>for</strong>ventes at et område kan blive oprettet i systemet. Der <strong>for</strong>ventes at området kan oprettes med<br />
en titel, beskrivelse, en række koordinater og en farve. Der <strong>for</strong>ventes at farvernes fylde også kan<br />
sættes<br />
Metode:<br />
Sharepoint åbnes op, og listen <strong>for</strong> markeringer findes. Der trykkes på ”new” og der vælges<br />
indholdstypen kaldet ”MapOmraade”. Titel og beskrivelse udfyldes. Farven sættes til ”333333” på<br />
både områdets kanter og det areal i mellem kanterne. Koordinaterne sættes ved at holde ”CTRL”<br />
nede og trykke med musen på kortet. Områdets type sættes. Der trykkes nu ”OK” nederst på siden.<br />
Der kontrolleres på kortet om punktet er korrekt oprettet i systemet.<br />
Resultat:<br />
Resultatet af testen blev som <strong>for</strong>ventet. Der blev oprettet et område i systemet. Området blev vist på<br />
den korrekte adresse og med den titel og beskrivelse, som blev angivet under testen.<br />
Oprettelse af rute<br />
Forventet resultat:<br />
Der <strong>for</strong>ventes at en rute kan blive oprettet i systemet. Der <strong>for</strong>ventes at ruten kan oprettes med en<br />
titel, beskrivelse, et start koordinat eller adresse og et slut koordinat eller adresse.<br />
Metode:<br />
Sharepoint åbnes op, og listen <strong>for</strong> markeringer findes. Der trykkes på ”new” og der vælges<br />
indholdstypen kaldet ”MapRute”. Titel og beskrivelse udfyldes. Titel sættes til ”Til arbejde”. Start<br />
adressen sættes til ”Øresundsvej 24, København” og slut adressen sættes til ”Smedeholm 10,<br />
Herlev”. Rutens type sættes Der trykkes nu ”OK” nederst på siden. Der kontrolleres på kortet om<br />
ruten er korrekt oprettet i systemet.<br />
67
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Resultat:<br />
Resultatet af testen blev som <strong>for</strong>ventet. Der blev oprettet en rute i systemet. Ruten blev vist med den<br />
rigtige start og slut adresse.<br />
Oprettelse af nyt ikon og valg af nyt ikon til punkt<br />
Forventet resultat:<br />
Der <strong>for</strong>ventes at et nyt ikon kan tilføjes til billede biblioteket ”<strong>Google</strong>Map.PictureLibrary”. Der<br />
<strong>for</strong>ventes at det ikon, som bliver tilføjet kan angives med en titel. Der <strong>for</strong>ventes at det er muligt at<br />
udvælge denne titel ved oprettelse af nyt punkt. Det <strong>for</strong>ventes derefter at det nye ikon vil blive vist<br />
på kortet, når punktet er udvalgt.<br />
Metode:<br />
Sharepoint åbnes op, og biblioteket ”<strong>Google</strong>Map.PictureLibrary” findes. Der tilføjes et nyt ikon til<br />
dette bibliotek og ikonet angives med en titel. Listen <strong>for</strong> markeringer findes herefter. Der trykkes på<br />
”new” og der vælges indholdstypen kaldet ”MapLokation”. Titel og beskrivelse udfyldes. Det nye<br />
ikon vælges i bunden i dropdown menuen. Koordinatet sættes ved at indtaste en adresse og der<br />
trykkes ”Tilføj”. Punktets type sættes. Der trykkes nu ”OK” nederst på siden. Der kontrolleres på<br />
kortet om punktet er korrekt oprettet i systemet.<br />
Resultat:<br />
Resultatet af testen blev som <strong>for</strong>ventet. Der blev oprettet et nyt punkt i systemet. Punktet blev vist<br />
med det rigtige ikon på kortet.<br />
Oprettelse af type<br />
Forventet resultat:<br />
Der <strong>for</strong>ventes at en ny markeringstype kan blive oprettet i systemet. Der <strong>for</strong>ventes at den nye type<br />
er tilgængelig under oprettelse eller redigering af markeringer og at disse markeringer kan blive<br />
tilknyttet typen. Der <strong>for</strong>ventes også at typen bliver vist på <strong>for</strong>siden i listen af markeringstyper, og<br />
den kan vælges og derved få vist tilhørende markeringer på kortet.<br />
Metode:<br />
Sharepoint åbnes op, og listen ”<strong>Google</strong>Map.MarkerTypes” findes. Der trykkes på ”new” og der<br />
vælges indholdstypen kaldet ”MarkerType”. Typen udfyldes med navn. Herefter findes listen<br />
”<strong>Google</strong>Map.Markers”, som og trykkes ”New” og vælges en indholdstype. I testen blev der valgt<br />
”MapLokation”. Ved oprettelse af det nye punkt kan den nye markeringstype vælges. Punktet<br />
oprettes. Forsiden findes og her ses om den nye type bliver vist i listen af markeringstyper. Den nye<br />
type vælges og der ses om det nye punkt med den nye type bliver vist korrekt på kortet.<br />
Resultat:<br />
Resultatet af testen blev som <strong>for</strong>ventet. Der blev oprettet en ny markeringstype og et nyt punkt i<br />
systemet. Punktet blev vist korrekt, når den nye type blev valgt.<br />
68
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
ScreenShot<br />
ScreenShot1<br />
ScreenShot2<br />
ScreenShot 1: Beskrivelse på et område<br />
ScreenShot 2: Punkt på koret, med brugerdefineret beskrivelse og ikon<br />
69
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
ScreenShot3<br />
ScreenShot 3: Begivenhed oprettet med speciel beskrivelse.<br />
70
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
ScreenShot4<br />
ScreenShot 4: Metode til at få feltværdier med i beskrivelsen.<br />
71
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
ScreenShot5<br />
ScreenShot 5: FeatureReceiver til efterbehandling af<br />
felter.<br />
72
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
ScreenShot6<br />
ScreenShot 6: Webtop.<strong>Google</strong>Map.CustomFields' struktur og filer til oprettelse af specialfelt<br />
73
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
ScreenShot7<br />
ScreenShot 7: ASCX fil til specialfeltet <strong>Google</strong>MapField<br />
74
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
ScreenShot8<br />
ScreenShot 8: Specialfeltet <strong>Google</strong>MapField ved redigering og oprettelse af punkt markering.<br />
75
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
ScreenShot9<br />
ScreenShot 9: Specialfeltet <strong>Google</strong>MapField ved redigering og oprettelse af område markering (polygon).<br />
ScreenShot10<br />
ScreenShot 10: Brug af interface.<br />
76
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
ScreenShot11<br />
ScreenShot 11: Solution <strong>Google</strong>Map.Resources.<br />
77
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
ScreenShot12<br />
ScreenShot 12: Solution Webtop.<strong>Google</strong>Map.Controls.<br />
78
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
ScreenShot13<br />
ScreenShot14<br />
ScreenShot 13: Solution Webtop.<strong>Google</strong>Map.CustomFields.<br />
ScreenShot 14: Solution Webtop.<strong>Google</strong>Map.DataLib.<br />
79
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
ScreenShot15<br />
ScreenShot 15: Interfacet IController, som sikre kommunikation mellem View og Controller.<br />
80
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
ScreenShot16<br />
ScreenShot 16: Billede af applikationen.<br />
81
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
ScreenShot17<br />
ScreenShot18<br />
ScreenShot 17: Lister og biblioteker i Sharepoint.<br />
ScreenShot 18: Oprettelse af nyt element i listen <strong>Google</strong>Map.Markers.<br />
82
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
ScreenShot19<br />
ScreenShot 19: Oprettelse af nyt element.<br />
83
David Sørensen <strong>Google</strong> <strong>Maps</strong> <strong>application</strong> <strong>for</strong> Microsoft Sharepoint 22/01-2010<br />
S062599<br />
Kildekode<br />
Kildekoden er lagt på den vedlagte CD.<br />
84
Change language