Postadress: Besöksadress: Telefon:

Box 1026 Gjuterigatan 5 036-10 10 00 (vx)

551 11 Jönköping

Bordsbokningssystem i HTML 5 Table reservation system in HTML 5

Mikael Borg-Rosén

David Rasmussen

EXAMENSARBETE 2012

Datateknik med inriktning Webbutveckling

Postadress: Besöksadress: Telefon:

Box 1026 Gjuterigatan 5 036-10 10 00 (vx)

551 11 Jönköping

Detta examensarbete är utfört vid Tekniska Högskolan i Jönköping inom

ämnesområdet Datateknik med inriktning Webbutveckling. Arbetet är

ett led i den treåriga högskoleingenjörsutbildningen.

Författarna svarar själva för framförda åsikter, slutsatser och resultat.

Examinator: Inger Palmgren

Handledare: Bengt Ekeberg

Omfattning: 15 hp (grundnivå)

Datum: 2012-05-28

Abstract

1

Abstract

Today there are few systems that provides a good overview of a restaurant's reservations and table arrangements. Most often a pen and paper is used which poses problems when customers cancel, change their reservations or simply doesn’t arrive to the restaurant. It is also difficult to determine whether the restaurant is fully booked or not.

This report discusses the development of a web based table reservation system for restaurants on behalf of a restaurant owner in Jönköping. The system will provide a graphic overview of a restaurant's reservations and how all the tables should be placed in one evening. As the system will have multiple users using different devices, it requires the system to be platform independent.

Using HTML5 it will be examined whether it is possible to make this system offline compatible, because the employer wishes that the system is accessible even when the Internet connection is lost. It also explores how an application is user friendly and easy to operate and how the communication between client and server is done most effectively.

The project is divided into four parts: graphical user interface, web application, data management and server communication, which in turn are divided into two categories: client and server. The two categories were used as a base for the entire project, from literature review and research to implementation.

The final web application was a cross-platform and offline compatible table reservation system, where the user gets a graphical overview of a selected day's appointments and table arrangements.

Sammanfattning

2

Sammanfattning

Det finns idag få system som ger en god överblick av en restaurangs bokningar och bordsplaceringar. Oftast används papper och penna som ställer till med problem när kunder avbokar, ändrar deras bokning eller helt enkelt inte kommer till restaurangen. Det är även svårt att avgöra huruvida restaurangen är fullbokad eller ej.

Denna rapport behandlar utvecklingen av ett webbaserat bordsbokningssystem för restauranger på uppdrag av en restaurangägare i Jönköping. Systemet ska ge en grafisk överblick av en restaurangs bokningar och hur alla bord ska stå placerade under en kväll. Då systemet webbapplikationen ska ha flera användare, som använder olika enheter, krävs det att systemet ska vara plattformsoberoende.

Med hjälp av HTML5 undersöks det huruvida det går att göra detta system offlinekompatibelt, då uppdragsgivaren önskar att systemet är åtkomligt då Internetuppkopplingen försvinner. Det undersöks även hur en applikation görs användarvänlig och lättmanövrerad samt hur kommunikationen mellan klient och server görs mest effektivt.

Projektet är uppdelat i fyra delar; grafiskt användargränssnitt, webbapplikation, datahantering och serverkommunikation, som i sin tur är indelade i två kategorier; klient och server. De två kategorierna användes som en bas för hela projektets gång, från litteraturgenomgång och forskning till implementation.

Den slutliga webbapplikationen blev ett plattformsoberoende och offlinekompatibelt bordsbokningssystem, där användaren får en grafisk överblick av en vald dags bokningar samt bordsplaceringar.

Nyckelord

Webbutveckling, HTML5, CSS3, JavaScript, Offlinekompabilitet, Webbaserat

bordsbokningssystem

Innehållsförteckning

3

Innehållsförteckning

Figurlista ......................................................................................... 5

1 Inledning................................................................................... 6

1.1 BAKGRUND OCH PROBLEMBESKRIVNING .................................................................................... 6 1.2 SYFTE OCH FRÅGESTÄLLNINGAR ................................................................................................ 6 1.3 AVGRÄNSNINGAR ....................................................................................................................... 7 1.4 DISPOSITION ............................................................................................................................... 7

2 Teoretisk bakgrund ................................................................. 8

2.1 GRAFISKT ANVÄNDARGRÄNSSNITT (GUI) .................................................................................. 8 2.1.1 Människa-datorinteraktion ............................................................................................... 8 2.1.2 Grafisk formgivning .......................................................................................................... 9

2.2 WEBBAPPLIKATION ................................................................................................................... 10 2.2.1 HTML5 ........................................................................................................................... 10 2.2.2 CSS3 ............................................................................................................................... 12 2.2.3 Objektorienterad JavaScript ........................................................................................... 13

2.3 SERVERKOMMUNIKATION ......................................................................................................... 13 2.3.1 Introduktion till serverkommunikation ........................................................................... 13 2.3.2 Programmeringsspråk .................................................................................................... 13

2.4 DATAHANTERING ...................................................................................................................... 15 2.4.1 Offlineåtkomst ................................................................................................................. 15 2.4.2 DBMS ............................................................................................................................. 17 2.4.3 JSON och XML ............................................................................................................... 18

3 Metod och genomförande .................................................... 19

3.1 ARBETSPROCESS ....................................................................................................................... 19 3.1.1 Kravmodell ..................................................................................................................... 19 3.1.2 Analys & Design ............................................................................................................. 19 3.1.3 Litteraturgenomgång och forskning ............................................................................... 20 3.1.4 Implementation ............................................................................................................... 22 3.1.5 Testning .......................................................................................................................... 22

4 Designprocessen .................................................................... 23

4.1 KRAVMODELL ........................................................................................................................... 23 4.2 ANALYS & DESIGN ................................................................................................................... 23

4.2.1 Kravanalys ...................................................................................................................... 23 4.2.2 Djupare analys ............................................................................................................... 24 4.2.3 Klass- och systemdesign ................................................................................................. 25 4.2.4 Databasanalys och design .............................................................................................. 27 4.2.5 Skisser och prototyper .................................................................................................... 27

4.3 LITTERATURGENOMGÅNG OCH FORSKNING .............................................................................. 28 4.3.1 Förstudier ....................................................................................................................... 28 4.3.2 Klient .............................................................................................................................. 29 4.3.3 Server .............................................................................................................................. 36

4.4 IMPLEMENTATION ..................................................................................................................... 37 4.4.1 Systemets moduler .......................................................................................................... 38

4.5 TESTNING .................................................................................................................................. 44

5 Diskussion och slutsatser ...................................................... 45

5.1 DISKUSSION AV DESIGNPROCESSEN .......................................................................................... 45 5.1.1 Gränssnittsutveckling ..................................................................................................... 45

Innehållsförteckning

4

5.1.2 Offlinekompabilitet ......................................................................................................... 45 5.1.3 Effektiv serverkommunikationen ..................................................................................... 46 5.1.4 Slutprodukten .................................................................................................................. 46

5.2 METODDISKUSSION ................................................................................................................... 47 5.2.1 Val av metod ................................................................................................................... 47 5.2.2 Reflektioner kring metodval ............................................................................................ 48

5.3 SLUTSATSER OCH REKOMMENDATIONER .................................................................................. 49 5.3.1 Slutsatser ........................................................................................................................ 49 5.3.2 Rekommendationer och förbättringar............................................................................. 49

6 Referenser .............................................................................. 50

7 Sökord ..................................................................................... 52

8 Bilagor ..................................................................................... 53

8.1 BILAGA 1 .................................................................................................................................. 53

Figurlista

5

Figurlista FIGUR 1 DIAGRAM ÖVER WEBBLÄSARSTÖD FÖR HTML5 OCH CSS3[9] 10 FIGUR 2 KODEXEMPEL: CANVAS-TAG [7] 11 FIGUR 3 KODEXEMPEL: CONTEXT HÄMTAS [7] 11 FIGUR 4 KODEXEMPEL: RITAR EN REKTANGEL MED KANTLINJER SAMT VISAR

KODSTYCKETS RESULTAT.[7] 11 FIGUR 5 KODEXEMPEL: CACHE MANIFEST [7] 12 FIGUR 6 KODEXEMPEL: CSS3 MEDIA QUERIES 12 FIGUR 7 KODEXEMPEL: INSTANSIERING AV JAVASCRIPT- KLASS MED METOD. 13 FIGUR 8 ÖVERBLICK ÖVER HUR ASP.NET FUNGERAR [16] 14 FIGUR 9 KODEXEMPEL: LOCALSTORAGE 15 FIGUR 10 KODEXEMPEL: WEBSQL 15 FIGUR 11 KODEXEMPEL: INDEXEDDB, DATABAS SKAPAS.[21] 16 FIGUR 12 KODEXEMPEL: INDEXEDDB, DATA LÄGGS TILL.[21] 17 FIGUR 13 KODEXEMPEL: XML. 18 FIGUR 14 KODEXEMPEL: JSON, SAMMA INNEHÅLL SOM FIGUR 13. 18 FIGUR 15 PROJEKTETS ARBETSPROCESS 19 FIGUR 16 ÖVERSKÅDLIG TIDSDISPONERING 19 FIGUR 17 UPPLÄGG AV LITTERATURGENOMGÅNG OCH FORSKNING 21 FIGUR 18 ARBETSPROCESS I LITTERATURGENOMGÅNG OCH FORSKNING. 21 FIGUR 19 ARBETSPROCESS AV MODULER. 22 FIGUR 20 ANVÄNDNINGSFALLSDIAGRAM, BOKNINGSHANTERING. 23 FIGUR 21 ANVÄNDNINGSFALLSDIAGRAM, BORDSHANTERING. 24 FIGUR 22 INITIALT KLASSDIAGRAM. 24 FIGUR 23 KOMMUNIKATIONSDIAGRAM, LÄGGA TILL BOKNING. 25 FIGUR 24 KOMMUNIKATIONSDIAGRAM, LÄGGA TILL BORD. 25 FIGUR 25 DEL AV KLASSMODELL MED ATTRIBUTER OCH METODER. 26 FIGUR 26 ÖVERBLICK ÖVER SYSTEMETS KOMMUNIKATION. 26 FIGUR 27 OBJEKT-RELATIONSDIAGRAM FÖR DATABAS. 27 FIGUR 28 HIERARKI ÖVER ANVÄNDNINGSFALL. 29 FIGUR 29 URSPRUNGLIG DESIGN-SKISS. 30 FIGUR 30 SYSTEMETS FÄRGSKALA. 31 FIGUR 31 SLUTGILTIG DESIGN MED RESERVATIONSLISTAN UTFÄLLD. 32 FIGUR 32 DE OLIKA STEGEN I RESERVATIONSPROCESSEN. 33 FIGUR 33 HUR ETT DIV-ELEMENT DRAS TILL EN CANVAS OCH BLIR ETT

CANVAS OBJEKT. 34 FIGUR 34 TILLSTÅNDSDIAGRAM, EN GHOST BLIR ETT BORD. 35 FIGUR 35 TILLSTÅNDSDIAGRAM, HUR ETT BORD MARKERAS. 35 FIGUR 36 HUR ETT KLICK IDENTIFIERAS. 35 FIGUR 37 KODEXEMPEL: SKAPA JSON-STRÄNGAR MED JAVASCRIPT. 36 FIGUR 38 KODEXEMPEL: JSON_DECODE I PHP. 37 FIGUR 39 RESULTAT AV MEDIA QUERIES, PÅ PC OCH PÅ SURFPLATTA. 38 FIGUR 40 CANVAS MED UTPLACERADE BORD. 39 FIGUR 41 "FLYTTA BORD" MENYVAL 39 FIGUR 42 SAMMANFOGNING AV BORD. 40 FIGUR 43 SEPARERING AV BORDSGRUPPERING. 40 FIGUR 44 KALENDER SOM ANVÄNDES FÖR ATT BYTA DAG. 41 FIGUR 45 TIDSLINJE SOM ANVÄNDES FÖR ATT PÅVERKA DEN GRAFISKA

BILDEN AV RESTAURANGEN. 41 FIGUR 46 ÖVERBLICK HUR TIDSLINJEN FUNGERADE, DÄR VÄNSTRA BILDEN

VISAR RESTAURANGEN KLOCKAN 19 OCH HÖGRA BILDEN KLOCKAN 21. 42 FIGUR 47 MENY-VAL, NY RESERVATION 42 FIGUR 48 DEL AV RESERVATIONSLISTA 43 FIGUR 49 VY- LISTA OCH ÖVERBLICK AV VYERNA. 43

Inledning

6

1 Inledning

1.1 Bakgrund och problembeskrivning

I restaurangbranschen finns det idag få system som ger en god överblick över de bokningar som finns inför kvällens sittningar. Oftast används papper och penna som ställer till med problem när kunder avbokar, ändrar deras bokning eller helt enkelt inte kommer till restaurangen.

Det är också svårt att få en överblick ifall restaurangen är fullbokad eller inte, var och när det finns plats och hur restaurangens bord kommer stå placerade vid en viss tidpunkt under kvällen. De få system som finns inom området är oftast bristande vad gäller funktionalitet, flexibilitet, användarvänlighet och åtkomst.

Uppdragsgivaren driver en restaurang i Jönköping och menar att det saknas ett funktionellt system som löser ovanstående problem på ett enkelt och smidigt sätt. Det saknas ett system som kan koppla ihop flera av önskemålen; bordsplacering, bokning, anteckningar och kundregister. Detta skulle underlätta för personalen på restaurangerna samt förbättra kundernas upplevelse.

1.2 Syfte och frågeställningar

Syftet med examensarbetet är att skapa ett webbaserat bordbokningssystem för restaurangbranschen. Användarna av systemet ska vara personalen själva och tanken är att de ska få ut en grafisk bild över hur restaurangens bokningar och bordsplaceringar kommer att se ut under en vald kväll.

För att få ut en optimal överblick av en restaurangs bordsplaceringar, önskar uppdragsgivaren att systemet ska göra det möjligt att se och påverka dessa rent grafiskt. Studenterna ska därför arbeta fram en lösning som gör att användaren kan placera ut, flytta eller ta bort bord på en angiven yta i applikationen.

Anledningen till att systemet ska vara webbaserat är för att användarna ska få åtkomst ifrån vilken enhet som helst, förutsatt att den har en Internetuppkoppling och en modern webbläsare. Uppdragsgivaren önskar dessutom att användarna, vid de tillfällen som Internetuppkopplingen försvinner, ändå kan använda systemet.

Då den färdiga webbapplikation en är tänkt att användas på en restaurang, där stress är en känd faktor, krävs det hög prestanda och effektivitet samtidigt som det krävs att systemet är lätthanterligt och användarvänligt.

Baserat på den kända bakgrunden och kraven som ställts utav uppdragsgivaren, vill studenterna under examensarbetets gång ta reda på följande:

Hur skapas ett lätthanterligt och effektivt gränssnitt?

Hur görs en webbapplikation offlinekompatibel?

Hur sköts kommunikationen mellan server och klient effektivast?

Gruppen tror att det färdiga systemet har en stor nytta i restaurangbranschen. Personalen får en bättre och mer precis överblick av kvällens alla bokningar och bordsplaceringar, något som tidigare skötts med hjälp av ett anteckningsblock.

Inledning

7

1.3 Avgränsningar

Studenterna har valt att avgränsa projektet kring just bordsbokning och bordsplacering, dels på grund av tidsbrist och dels på grund av att dessa områden anses vara mer tekniskt utmanande. Denna avgränsning medför att det inte finns någon administrationspanel som hanterar antalet bord som finns, golvytornas utformning eller avgränsningar av systemet inom personalen.

Projektet är även avgränsat på så vis att endast moderna webbläsare testas, där HTML5 stöds.

1.4 Disposition

Rapporten inleds med en teoretisk bakgrund, som ska ge en djupare förståelse av ämnesområdet samt vilken typ av teori som studenterna behövt ta del av för att slutföra projektet.

I delen Metod och genomförande beskrivs kort de arbetsmetoder som har använts genom projektets gång och hur gruppen har gått tillväga. I avsnittet Designprocessen finns en mer utförlig redovisning av vad studenterna har kommit fram till, vilka val som gjorts och grunden till dessa.

Rapporten avslutas med Diskussion och slutsatser där det diskuteras om för- och nackdelar med resultatet, hur det kan förbättras och de metoder som användes för att slutföra projektet. I slutet av rapporten finns det en referenslista, sökord och bilagor.

Teoretisk bakgrund

8

2 Teoretisk bakgrund

2.1 Grafiskt användargränssnitt (GUI)

2.1.1 Människa-datorinteraktion

Användargränssnittet kan vara en viktig del i utvecklingen av ett datorsystem. Det är gränssnittet som användaren ser och hela upplevelsen av systemet kan styras av detta.

Människa-datorinteraktion (MDI) är läran om hur effektiva interaktioner skapas mellan människa och system. MDI är ett forskningsområde som kombinerar datavetenskap med diverse andra ämnen, så som psykologi och ergonomi, för att kunna skapa välanpassade och trivsamma användargränssnitt.[1]

Kännetecken för god interaktionsdesign

Oavsett om gränssnittet är textbaserat eller grafiskt, finns det några grundläggande drag som kännetecknar en god dialogdesign mellan användaren och systemet:

Konsekvens Design och funktionalitet är konsekvent genom hela systemet.

Relevant användarstöd Användaren vägleds genom relevant information när det behövs.

Lämplig feedback ifrån systemet Systemet är alltid närvarande och svarar på användarens kommandon.

Minimera antalet inmatningsfält Tid och risk för fel reduceras genom att ansvar avlastas ifrån användaren.[1]

Utveckla ett användargränssnitt

Det finns många olika sätt att designa och implementera ett gränssnitt som stödjer interaktionen med användarna[1]. Men det finns några grundprinciper som kan vara bra att följa vid utvecklingen av ett användarvänligt gränssnitt.[2]

Fokus på användarna och deras uppgifter

Detta är en huvudprincip och innefattar bland annat; vilka typer av människor som kommer använda systemet, vad de förväntas kunna göra, vilka problem de har just nu, i vilken miljö systemet kommer användas, vilka förkunskaper de har och hur de vill utföra sina uppgifter.[2]

Funktion först – designa därefter

Innan en design kan utvecklas måste det stå klart vilken funktionalitet systemet ska kunna erbjuda. Det är därför viktigt att se till användarens behov och vad den verkligen kräver utav systemet för att kunna utföra sina uppgifter. På så vis går det att undvika onödig funktionalitet som tar upp plats i gränssnittet.[2]

Teoretisk bakgrund

9

De mest förekommande uppgifterna närmst

För att uppnå en högre tillfredställelse hos användaren, krävs det att han/hon kan utföra sina uppgifter snabbt och smärtfritt. Detta uppnås genom att placera vanligt förekommande uppgifter så få knapptryck bort som möjligt.[2]

Designa för mottaglighet

Ett systems mottaglighet – förmågan att inte låta användaren vänta – är den absolut viktigaste faktorn för en hög tillfredställelse hos användaren. Användaren vill ha feedback ifrån systemet när den gör någonting, som en bekräftelse på att kommunikationen lever.[2]

2.1.2 Grafisk formgivning

Användandet av färger, typsnitt, logotyper, m.m. på saker och ting, exempelvis trycksaker, digitala medier eller system, kallas grafisk design eller grafisk formgivning. Detta område har mycket gemensamt med andra designområden, bland annat människa-datorinteraktion.[3]

Den grafiska, visuella designen handlar inte bara om estetik. Alla har olika uppfattningar om vad som är estetiskt tilltalande men det betyder inte att designvalen ska baseras på vad samtliga inblandade tycker ser bra ut. Fokus bör istället läggas på att designen ska passa ihop med systemets syften och klargöra vilka möjligheter systemet erbjuder.[4]

Ögats upplevelse

Ett sätt att vägleda användaren till de mest väsentliga funktionerna är att placera dessa där användaren tittar först. Det finns dock ingen exakt bild över våra ögons beteendemönster när det kommer till layout av en hemsida eller system, då det dels beror på vad som söks och dels vad som attraherar ögonen[5]. Gällande det senare så finns det ett några generella metoder för att vägleda och locka ögat.[4]

Kontraster och färger

Den huvudsakliga metoden för att attrahera ögat är genom kontraster. Utan dessa upplevs designen som matt och enformig, vilket medför att användaren inte kan fokusera på något specifikt.[4]

Färger är viktiga på så vis att de både attraherar och vägleder ögat. En designs färgpalett bör innehålla färger som fungerar bra tillsammans, där de kompletterar och lyfter fram istället för att ta ut varandra.[4]

Det är även av vikt att färgerna kan användas i olika syften. Starka och vågade färger används normalt som förgrundsfärger, för att kontrastera sig mot bakgrunden och på så vis attrahera ögat, medan mer matta färger lämpar sig bättre som bakgrundsfärg.[4] Färgblindas hämningar är också något som vid behov kan övervägas, där bland annat kombinationerna röd-grön och blå-gul kan vara svåra att särskilja[6].

Teoretisk bakgrund

10

2.2 Webbapplikation

2.2.1 HTML5

Det dominerande märkspråket för att beskriva innehåll och data på webben kallas HTML (Hypertext Markup Language), där den senaste versionen heter HTML5, vilken i skrivande stund är under utveckling. Denna version innehåller många nya funktioner, förbättringar av existerande funktioner samt skriptbaserade JavaScrip- API:er1 och ses som en utmanare till Adobe Flash.

HTML5 är inte helt nytt i grunden, utan innehåller även alla tillåtna element hos sina föregångare. Men det finns också nya teknologier och API:er i HTML5 som öppnar upp möjligheterna för att rita direkt i webbläsaren, lagra data och filer offline samt spela upp ljud och bild.[7]

Då HTML5 i skrivande stund inte är en standard, är stödet hos webbläsarna begränsat[8], vilket illustreras i Figur 1.

Figur 1 Diagram över webbläsarstöd för HTML5 och CSS3[9]

1 Application Programming Interface, regeluppsättning för kommunikation mellan olika

programvaror.

Teoretisk bakgrund

11

Canvas

Med hjälp av Canvas API går det att rita ut både två- och tredimensionella figurer i webbläsaren. Linjer, former, bågar, text, mönster och gradienter kan alla ritas ut i ett s.k. canvas- element genom JavaScript- kommandon till API:et. Detta element definieras som en HTML- tagg, med start- och slutnotation.[7]

Figur 2 visar ett kodexempel för hur en canvas- tagg definieras.

Figur 2 Kodexempel: Canvas-tag [7]

Rita med canvas

I Figur 3 visas det första steget som görs för att kunna rita med canvas, dvs. hämta och spara canvas- elementet i en JavaScript- variabel. Därefter hämtas dess rityta, context, där alla ritningar kommer renderas.

Figur 3 Kodexempel: Context hämtas [7]

För att rita ut en rektangel används funktionen fillRect(), vars färg och kantlinje definieras med hjälp av strokeStyle och fillStyle, enligt Figur 4.[7]

Figur 4 Kodexempel: Ritar en rektangel med kantlinjer samt visar kodstyckets resultat.[7]

Offlinekompabilitet

HTML5 erbjuder möjligheten att komma åt hemsidor och data offline då det saknas Internetuppkoppling. Genom Offline Web Applications tillåts användaren att spara ner en kopia av hemsidan, medan tillgången av data stöds med hjälp av teknikerna localStorage, WebSQL eller Indexed Database. Då de sistnämnda metoderna berör just datahantering, framläggs de lite längre fram i detta teoriavsnitt, under avsnittet med samma namn.[7]

Teoretisk bakgrund

12

Offline Web Applications

För att låta användaren interagera med hemsidan även när Internetuppkoppling saknas, används Offline Web Applications. Denna metod använder sig av ett s.k. cache manifest – ett textdokument som anger de filer som ska sparas ner lokalt hos användaren. Filerna används sedan vid de tillfällen uppkopplingen försvinner, vilket gör hemsidan offlinekompatibel. Om originalfilerna vid någon tidpunkt ändras, sparas en ny kopia ner hos användaren, förutsatt att Internetanslutning finns.

I Figur 5 redogörs hur ett cache manifest definieras, där CACHE innehåller alla de filer som ska sparas ned och vara tillgängliga offline.[7]

Figur 5 Kodexempel: Cache manifest [7]

2.2.2 CSS3

CSS (Cascading Style Sheets) är ett språk som beskriver hur en hemsida ska presenteras vad gäller färg, storlek och form. CSS3 är den senaste versionen och innehåller allt som innefattas hos sin föregångare, CSS2.1. Men det finns även nyheter så som skuggor, runda hörn, multipla bakgrunder, animationer och transparens för att nämna några.[10]

En annan nyhet i CSS3 är det utökade stödet för anpassade layouter, vilket innebär att hemsidan anpassar sitt utseende beroende på typ av media, upplösning eller färg. Denna funktionalitet kallas Media Queries och tillåter presentationer att anpassas efter specifika medier, utan att ändra på innehållet, genom att ange vissa parametrar.

I Figur 6 visas det hur en layout anpassas efter en skärm, där upplösningen är minst 500 pixlar bred.[11]

Figur 6 Kodexempel: CSS3 Media Queries

CSS3 är i skrivande stund under utveckling och är alltså inte en standard ännu. Det finns därför ett begränsat webbläsarstöd, som framgår av Figur 1.[11]

Teoretisk bakgrund

13

2.2.3 Objektorienterad JavaScript

JavaScript är ett objektorienterat programmeringsspråk som kan användas för att skapa interaktiva webbsidor. En av de stora skillnaderna mellan JavaScript och vanliga objektorienterade programmeringsspråk är att JavaScript inte har några klasser, utan klassfunktionaliteten utgörs av ett fördefinierat objekt som det sedan skapas instanser av. En annan skillnad är att funktioner behandlas som objekt, vars innehåll består av exekverbar kod.[12]

I Figur 7 illustreras det hur en ”klass” kan se ut och hur ett objekt skapas av denna.

Figur 7 Kodexempel: Instansiering av JavaScript- klass med metod.

2.3 Serverkommunikation

2.3.1 Introduktion till serverkommunikation

I serverskriptprogrammering exekveras koden på servern istället för i klientens webbläsare, förutsatt att servern har stöd för det valda språket. Detta kan göras av flera olika skäl, t.ex. att det inte finns något motsvarande som kan lösa problemet i ett språk som körs i webbläsaren eller för att belasta klientens dator mindre. Koden som körs på servern är även dold från klienten.

Exempel på användningsområden är bland annat:

Dynamiska hemsidor Databashantering Skicka och validera formulärdata Anpassa sidan för en individuell användare[13]

2.3.2 Programmeringsspråk

Det finns ett flertal språk som används när det kommer till programmering på serversidan, där två av de vanligaste är PHP och ASP.NET[13].

Teoretisk bakgrund

14

PHP

Skriptspråket PHP är ett open source- projekt som, i skrivande stund, fortfarande är under utveckling. Den nuvarande versionen, PHP5, är den senaste och denna version inkluderade diverse nyheter så som hantering av undantag (exceptions) med hjälp av try/catch, förbättrade möjligheter för objektorienterad programmering samt bättre stöd för XML och WebServices2.[14]

För att PHP- kod ska kunna exekveras på en server krävs en installation av språket. Denna installation kan genomföras på alla typer av servrar, vilket i sin tur gör PHP plattformsoberoende.[15]

ASP.NET

ASP.NET (Active Server Pages Dotnet) är egentligen inte ett programmeringsspråk, utan ett ramverk som tillåter programmerarna att skapa dynamiska hemsidor med ett av de så kallade Dotnet- språken, exempelvis C#.NET och VB.NET.[16]

ASP.NET kräver Microsoft IIS (Internet Information Services), vilket är en serverprogramvara för Windows- servrar[16]. Det finns dock open source- projekt, t.ex. Mono, som gör det möjligt att använda ASP.NET på andra typer av servrar och på så vis göra ramverket plattformsoberoende[17].

I Figur 8 illustreras det hur kommunikationen fungerar vid användandet av ASP.NET.

Figur 8 Överblick över hur ASP.NET fungerar [16]

I ovanstående figur så ber klienten om en sida ifrån servern. Denna ser att den valda sidan inte är statisk, utan en så kallad Webform, och skickar då en begäran till ASP.NET, som granskar hur filen ska hanteras. Denna fil exekveras och genererar då endast HTML, som i sin tur skickas tillbaka till klienten.[16]

2 Webbaserade datorprogram som kommunicerar och samarbetar dynamiskt med andra webbtjänster.

Teoretisk bakgrund

15

2.4 Datahantering

2.4.1 Offlineåtkomst

LocalStorage

LocalStorage är en av många nyheter i HTML5 och är ett sätt att lagra data på klientsidan, som finns kvar efter att en sida har stängts ned.

Precis som cookies, lagras informationen i en associativ array, där en nyckel pekar på ett värde. Men till skillnad från cookies skickas inte informationen fram och tillbaka i http-headers, vilket gör applikationen långsammare, utan hämtas direkt hos klienten.

Den maximala storleken på den data som kan sparas med localStorage skiljer sig från webbläsare till webbläsare men är betydligt större än den begränsade storleken som cookies har.[7]

Figur 9 visar hur data sparas och tas bort med hjälp av localStorage.

Figur 9 Kodexempel: localStorage

WebSQL

WebSQL är ett API som sedan november 2010 har blivit övergivet av W3C3. Det fungerar precis som en vanlig databas men istället för att ligga på en server ligger databasen i klientens webbläsare. Det går alltså även att hämta, redigera och ta bort data via SQL- kommandon.

På grund av att W3C har lämnat standarden finns den inte implementerad i alla webbläsare. Bland annat så har en av de större aktörerna, Mozilla Firefox, inte stöd för WebSQL.[18][19]

I Figur 10 illustreras det hur en databas skapas samt hur data sparas i denna.

Figur 10 Kodexempel: WebSQL

3 World Wide Web Consortium, arbetar med att utveckla tekniska protokoll och standarder.

Teoretisk bakgrund

16

IndexedDB

IndexedDB är ännu inte en standard för att lagra data på klientsidan. Trots att detta är tekniken som W3C nu fokuserar på, är den inte särskilt utspridd bland webbläsarna. IndexedDB är en blandning mellan localStorage och WebSQL, där hela JavaScript- objekt lagras kopplas till ett index i databasen. På detta vis kan stora mängder objekt sökas igenom och skrivas ut.[20]

Figur 11 och 12 består av ett kodexempel där en databas skapas och hur data läggs till i denna med hjälp av IndexedDB.

Figur 11 Kodexempel: IndexedDB, databas skapas.[21]

Teoretisk bakgrund

17

Figur 12 Kodexempel: IndexedDB, data läggs till.[21]

2.4.2 DBMS

DBMS är en akronym för Database Manager System, som på svenska kallas databashanteringssystem. Ett DBMS är en programvara som används för att hantera data i en databas genom att t.ex. lägga till nya rader, manipulera befintlig data och kontrollera så att databasen är uppdaterad och trovärdig. DBMS är oftast serverbaserade.[22]

MySQL

MySQL är ett RDBMS (Relational DBMS) som tillåter flera användare. Detta DBMS är gratis och ligger publicerat under GNU General Public License4 (GNU GPL), vilket gör det vanligt förekommande i open source- projekt som behöver en databashanterare.

MySQL finns för många olika serverplattformar, bland annat Windows och Linux.[23]

MS SQL

Microsofts databashanterare, MS SQL, är precis som MySQL ett RDBMS. Det finns många olika versioner som anpassar sig till allt från stora till små företag, varav vissa av dessa är gratisversioner. MS SQL fungerar däremot enbart på servrar med operativsystemet Windows installerat.[24]

4 GNU GPL - Upphovsrättslicens för fri programvara.

Teoretisk bakgrund

18

2.4.3 JSON och XML

XML

XML (eXtensible Markup Language) är ett märkspråk med syfte att utbyta information mellan olika informationssystem. Det två viktigaste syntaxdelarna i XML är element och attribut, varav attribut är skiftlägeskänsliga.[25]

Figur 13 illustrerar ett kodexempel i XML.

Figur 13 Kodexempel: XML.

JSON

JSON (JavaScript Object Notation) är en kompakt, textbaserad, öppen standard som är lätt att läsa för människor och även lätt att generera och tolka för datorer. JSON används för att skicka information mellan olika informationssystem.[26]

Ovanstående figur tolkas i Figur 14 som JSON.

Figur 14 Kodexempel: JSON, samma innehåll som figur 13.

Metod och genomförande

19

3 Metod och genomförande

3.1 Arbetsprocess

Studenterna tog inledningsvis fram en arbetsprocess som visade hur de skulle arbeta under projektets gång. Då projektet skulle göras objektorienterat blev arbetsprocessen enligt Figur 15.

Figur 15 Projektets arbetsprocess

Baserat på arbetsprocessen togs även en tidsplan fram, som visade hur mycket tid studenterna skulle disponera på varje delmoment under projektet.

Figur 16 Överskådlig tidsdisponering

3.1.1 Kravmodell

För att få en inblick i vilka krav och behov användarna hade av systemet så utfördes en rad intervjuer med uppdragsgivaren. Resultatet av dessa intervjuer formade en kravspecifikation, som i sin tur utgjorde en stor del av den kravmodell som togs fram.

3.1.2 Analys & Design

Denna fas innebar att skapa en grundlig analys och design av systemet, baserat på den framtagna kravmodellen. Detta genererade diverse diagram och modeller, gjorda i Unified Modeling Language (UML), som senare användes vid implementationsfasen. Även initiala skisser och prototyper togs fram under denna fas.

Analys

Projektets analysdel bestod utav en kravanalys, djupgående analys och databasanalys, som tillsammans gav en grundläggande överblick av systemet och dess beståndsdelar.

Metod och genomförande

20

I kravanalysen tog studenterna fram användningsfallsdiagram, som i sin tur lade grunden för de mer detaljerade diagrammen i den djupgående analysen. Dessa två analyser genererade huvudsakliga klasser och metoder för systemet.

Databasanalysen resulterade i ett objekt-relation- diagram, som gav studenterna en överblick av databasens tabeller och relationer.

Design

En klassdesign och databasdesign skapades genom att utveckla analysens diagram och modeller ytterligare. Klassdesignen resulterade i en total överblick av systemets klasser och deras attribut, metoder och relationer till varandra. Under databasdesignen framställde studenterna en modell där databasens tabeller, attribut och nycklar gick att utläsa.

Skisser och prototyper

I slutet av analysen respektive designen skapades och presenterades designförslag med motsvarande abstraktionsnivå för uppdragsgivaren. Till dessa byggdes även prototyper för att beskriva den funktionalitet systemet skulle erbjuda. Tillsammans med uppdragsgivaren utvärderades materialet, där styrkor respektive svagheter lades fram.

3.1.3 Litteraturgenomgång och forskning

Parallellt med analys- och designfasen, utförde studenterna diverse studier och tester inom relevanta områden för projektet, där potentiella metoder och tekniker kartlades.

Baserat på studenternas frågeställningar, delades projektet in i fyra huvudområden:

Grafiskt användargränssnitt

Webbapplikation

Serverkommunikation

Datahantering

Till dessa områden gjordes en förstudie, där projektet avgränsades kring några utvalda metoder och tekniker som ansågs främja det syfte och de frågeställningar som angivits. Det beslutades bland annat vilket programmeringsspråk som lämpade sig bäst, vilken datalagringsmetod som skulle användas samt hur webbapplikationen skulle byggas upp.

Efter avslutad förstudie, delades huvudområdena in i två kategorier, Klient och Server, där varje kategori bearbetades under en period på två veckor (se Figur 17). Bearbetningen innebar att studera förstudiens resultat ännu närmare och på så vis få fram möjligheter och begränsningar med respektive metod och teknik.

Metod och genomförande

21

Figur 17 Upplägg av Litteraturgenomgång och forskning

I Figur 18 illustreras upplägget för varje period, som gick ut på att först gå igenom aktuell litteratur, sedan utföra diverse försök och slutligen utvärdera resultatet. Försöksfallen valdes ut på så vis att de skulle komma till användning senare i projektets implementationsfas, med förhoppningen att tidigt upptäcka vad som var möjligt med de tekniker som studerades.

Figur 18 Arbetsprocess i litteraturgenomgång och forskning.

När studierna och testerna genomförts för respektive område gjordes en utvärdering, där det beslutades vilka metoder och tekniker som skulle användas, respektive undvikas.

Metod och genomförande

22

3.1.4 Implementation

Det beslutades i startskedet av fasen att implementationen skulle delas upp bland studenterna, för att underlätta och påskynda processen. Här utnyttjades även den klient- och serveruppdelning som gjordes i fasen litteraturgenomgång och forskning, där klientdelen behandlade front-end5- programmeringen medan server tog hand om back-end6- programmeringen.

Studenterna delade upp systemets funktioner och rangordnade dessa med hjälp av de angivna kravens prioriteringar och hur dessa var beroende av varandra. Med hjälp av denna uppdelning kunde systemet byggas i moduler, där varje modul blev en egen process som utvecklades inkrementellt och iterativt (se Figur 19).

Figur 19 Arbetsprocess av moduler.

3.1.5 Testning

Denna fas användes i arbetsprocessen för att kontrollera helheten i systemet, då varje modul redan testats vid dess implementering. Systemet testades med olika scenarion, baserade på de användningsfall som tagits fram under Design och Analys- fasen.

5 Utveckling av användargränssnittet och dess funktionalitet. Ofta HTML/CSS och JavaScript baserad.

6 Utveckling bakom, som bearbetar informationen som skickas från frontend.

Designprocessen

23

4 Designprocessen

4.1 Kravmodell

För att studenterna skulle kunna få en förståelse av behoven och kraven på systemet togs en kravmodell fram. Genom flertalet intervjuer med uppdragsgivaren fick studenterna ihop nödvändig information, som utmynnade i ett utkast av en kravspecifikation. Denna verifierades av uppdragsgivaren och finns att skåda i Bilaga 1, vilken är en sammanfattning av de krav som framkom under intervjuerna.

4.2 Analys & Design

4.2.1 Kravanalys

Utifrån den kravmodell som framfördes skapades användningsfallsdiagram, som tillsammans speglade hur användaren skulle uppnå sina krav i systemet. Varje huvudkrav motsvarade ett paket, subsystem, och varje delkrav motsvarade ett användningsfall.

Ett utdrag av dessa användningsfall redovisas i Figur 20 och 21.

Figur 20 Användningsfallsdiagram, Bokningshantering.

Designprocessen

24

Figur 21 Användningsfallsdiagram, Bordshantering.

4.2.2 Djupare analys

Användningsfallen som skapades blev sedan utgångspunkten för den mer djupgående analysen, där de första metoderna och klasserna togs fram.

De grundläggande klasserna togs fram genom att finna potentiella objekt i kravanalysen. Dessa klasser utgjorde grunden för resterande analys och de framgår enligt Figur 22 nedan.

Figur 22 Initialt klassdiagram.

Designprocessen

25

Varje användningsfall bearbetades och bildade motsvarande kommunikationsdiagram. Dessa diagram tydliggjorde hur klasserna skulle interagera med varandra och användaren för att främja de krav som ställts upp, i form av grundläggande metoder och nya klasser.

Ett utdrag av dessa kommunikationsdiagram redovisas i Figur 23 och 24.

Figur 23 Kommunikationsdiagram, lägga till bokning.

Figur 24 Kommunikationsdiagram, lägga till bord.

4.2.3 Klass- och systemdesign

De diagram och modeller som skapades i tidigare avsnitt utvecklades här ytterligare för att bestämma hur systemet skulle implementeras. Genom att framställa en klass- och systemdesign fick studenterna en fullständig bild över hur systemet skulle byggas upp rent teoretiskt. Hur det skulle byggas upp ur en teknisk synvinkel framgick av den förstudie som genomfördes parallellt i fasen Litteraturgenomgång och forskning, där resultatet av denna återfinns under rubriken med samma namn.

Under klassdesignen gjordes ytterligare studier av systemet, i form av diverse sekvensdiagram. Det beslutades sedan vilka attribut och relationer alla klasser hade, som tillsammans summerades i en klassmodell, enligt Figur 25.

Designprocessen

26

Figur 25 Del av klassmodell med attributer och metoder.

I Figur 26 visas systemdesignen, som skapades för att ge studenterna en översiktlig bild över hur systemets olika delar kommunicerade med varandra. Då offlinekompabilitet och plattformsoberoende var några av syftena för projektet, låg det i åtanke när designen togs fram.

Figur 26 Överblick över systemets kommunikation.

Designprocessen

27

4.2.4 Databasanalys och design

Vid denna fas gjordes en analys av systemets databas, där dess tabeller och relationer togs fram. Denna analys utarbetades sedan i databasdesignen för att identifiera attribut och nycklar.

Analysen bestod av att studenterna försökte bestämma vilka objekt som behövde spara data samt vilken typ av data som skulle sparas. Genom att utgå ifrån den systemanalys som genomfördes tidigare, kunde ett objekt-relation- diagram tas fram, enligt Figur 27.

Figur 27 Objekt-relationsdiagram för databas.

Utifrån detta diagram kunde en databasdesign skapas, där nödvändiga attribut togs fram och nycklar identifierades. Attributen hämtades ifrån systemanalysen medan nycklarna erhölls ifrån tabellernas multipliciteter.

4.2.5 Skisser och prototyper

I slutet av analysen respektive designen utformades designförslag, med tillhörande prototyp, för att ge både studenterna och uppdragsgivaren en bekräftelse på att de uppställda kraven uppfylldes. Dessa förslag baserades på den systemanalys och design som gjordes samt den studie som genomfördes under forskningsfasen.

Resultatet av det grafiska designarbetet finns dokumenterat under avsnittet Litteraturgenomgång och forskning, lite längre fram i denna rapport.

Designprocessen

28

4.3 Litteraturgenomgång och forskning

4.3.1 Förstudier

Val av språk

Det var okänt vilken typ av serverplattform systemet skulle komma att vistas i. Detta medförde att det valda programmeringsspråket var tvunget att fungera åtminstone på de vanligaste typerna av servrar. Med detta i åtanke valde studenterna PHP som språk, då det fungerar både på Linux- och Windows- servrar.

Val av databashanterare

Studenterna var även vid detta val tvungna att ta hänsyn till möjligheten att systemet skulle fungera på de vanligaste servertyperna. Men då MySQL fungerar på både Linux- och Windows- servrar, föll valet på denna databashanterare.

Val av dataöverföring

Studenterna valde att använda sig av JSON när data skulle överföras mellan server och klientens webbläsare. Anledningen till detta var att JSON tog upp mindre data än XML när det skickades och då det var okänt hur begränsad Internetuppkoppling användarna hade, ville studenterna minska så mycket som möjligt på de data som skickades.

Val av offlinelagring

För att göra webbapplikationen offlinekompatibel valde studenterna att använda sig av ett cache manifest, då det med denna teknik var möjligt att spara webbapplikationens funktioner och utseende lokalt.

Vad gäller offlinelagring av data, fanns det ett flertal möjligheter, i form av WebSQL, IndexedDB och LocalStorage.

Studenterna insåg att WebSQL inte var en hållbar lösning, då denna teknik inte var implementerad i alla webbläsare samt med det faktum att standarden var avskaffad. Det vaga webbläsarstödet gjorde att IndexedDB föll bort, även om det var något för framtiden.

Det slutliga valet blev localStorage, där JSON- strängar kunde lagras samt konverteras från och till JavaScript- objekt.

Designprocessen

29

4.3.2 Klient

Grafiskt användargränssnitt

Här utarbetades den grafiska layouten, där vikt lades på färger och placeringar av element, i syfte att främja systemets användbarhet.

Studenterna valde att basera designen på systemanalysens användningsfall. På detta vis garanterades det att den grafiska layouten fokuserade på användarnas behov och att deras arbete kunde utföras så effektivt som möjligt.

Designutkast 1

Det första utkastet levererades i slutet av systemets analys, då det stod klart vilken funktionalitet designen skulle främja. Studenterna ville att de mest nödvändiga funktionerna skulle finnas nära till hands. För att få en god överblick av detta listades samtliga användningsfall i en hierarki, där de viktigaste funktionerna låg högst upp (se Figur 28). Denna hierarki utgjorde grunden för hur systemets funktionalitet skulle presenteras i layouten.

Figur 28 Hierarki över användningsfall.

Gruppen gjorde sedan en bedömning av vilka som var de bästa platserna på layoutens yta och kom då fram till följande:

Den centrala funktionen av systemet borde ha störst plats och få mest uppmärksamhet.

De mest väsentliga funktionerna borde max vara ett klick bort.

Utifrån dessa riktlinjer skapades det första designutkastet, vilket visas i Figur 29.

Designprocessen

30

Figur 29 Ursprunglig design-skiss.

Studenterna ville att den centrala funktionen av systemet, den grafiska bilden av restaurangen, skulle få mest uppmärksamhet i designen, då denna skulle användas mest. Övrig funktionalitet placerades utmed sidorna för att inte dra uppmärksamhet ifrån huvudfunktionen, samtidigt som den ändå skulle vara lättillgänglig vid behov.

Reservationslistan ansågs vara viktig men endast under de perioder då kunder anlände till restaurangen. Därför beslutade gruppen att denna funktion skulle vara möjlig att dölja vid behov, då den behövde mycket plats på skärmen för att ge god läsbarhet.

Bordens olika funktioner ansågs lämpa sig bäst i form av en meny som visades vid behov.

Tidslinjen sågs som en viktig del då hela systemet kretsade kring denna, på så vis att den kunde ge en grafisk bild av restaurangen vid en viss tidpunkt. Dess placering motiverades med att det för gruppen föreföll sig naturligt att en tidslinje låg horisontellt. Då tidslinjen samtidigt var en av de viktigare funktionerna, ville studenterna särskilja denna ifrån resterande delar av designen och på så vis göra användaren mer uppmärksam på denna funktion.

Designprocessen

31

Designutkast 2

Detta utkast skapades i samband med slutförandet av systemets designfas och var tänkt att ge en komplett grafisk bild av det tänkta systemet.

Studenterna inledde med att studera vilken färgskala som skulle användas. Några riktlinjer för detta val gjordes och såg ut enligt följande:

Systemet borde kunna användas av färgblinda.

Systemet får inte inneha för skarpa grundfärger, då det ska användas i arbete.

Positiva och negativa färger ska ha samma betydelse genom hela designen.

Då färgblinda hämmas främst av kombinationerna grön-röd och blå-gul, valde studenterna att undvika dessa kombinationer. Då dessutom starka grundfärger skulle undvikas, tog gruppen fram en färgkombination som de tyckte passade bra in enligt riktlinjerna som sattes upp (se Figur 30).

Figur 30 Systemets färgskala.

Utifrån denna färgskala formades det andra designutkastet, som dessutom blev det slutgiltiga grafiska användargränssnittet (se Figur 31).

Designprocessen

32

Figur 31 Slutgiltig design med reservationslistan utfälld.

Bokade bord markerades med en röd färg för att symbolisera något upptaget, medan en blå färg indikerade på ett ledigt bord. Dessa färger skulle vara möjliga att särskilja även för en färgblind. Studenterna ville även att det skulle framgå huruvida vissa bord satt ihop eller inte, på vis att deras kanter visades.

Reservationsprocessen delades upp i fyra steg för att begränsa antalet inmatningsfält och för att göra processen mer lättmanövrerad. Genom att ha en sammanfattning av bokningen i steg fyra, ansågs användaren få en bättre överblick. Reservationsprocessen illustreras i Figur 32.

Designprocessen

33

Figur 32 De olika stegen i reservationsprocessen.

Webbapplikation

I detta avsnitt utforskades det hur webbapplikationen skulle byggas upp, med fokus på klienten. Då det redan på förhand var bestämt att HTML5 skulle användas, studerades det hur denna teknik skulle främja systemets tänkta funktionalitet, där fokus låg på canvas- elementet.

Även CSS3 studerades för att kunna uppfylla syftet med att applikationen skulle se likadan ut på alla plattformar. Dock så var denna studie av en mindre omfattning och resultatet av denna framgår i den teoretiska bakgrunden.

Designprocessen

34

Inför starten av den studie som gjordes av webbapplikationen sattes några frågeställningar upp, baserade på den systemanalys som togs fram i fasen Analys och design.

Hur placerar man ut och sparar objekt på en canvas?

Hur hanteras flera olika objekt?

Hur markerar man ett objekt på en canvas?

Hur flyttar man ett valt objekt?

Hur identifierar man kollisioner mellan objekt?

Studien gav studenterna en grund i hur canvas fungerade och med denna kunskap utfördes olika testfall, i syfte att finna svar på de frågeställningar som gjordes. De resultat som testfallen frambringade låg sedan till grund för implementationen av systemet.

Men även om studien visade att det fanns JavaScript- bibliotek som kunde utföra en del av det som söktes i frågeställningarna, valde gruppen att forma en egen lösning. Den främsta anledningen till detta beslut var just osäkerheten ifall de bibliotek som fanns kunde utföra allt som eftersöktes. Det bedömdes ta lika lång tid att komplettera de befintliga biblioteken som det skulle ta att bygga ett eget, där det senare alternativet dessutom var mer attraktivt i inlärningssyfte.

Placera ut och spara objekt

Grunderna för detta testfall bestod av att dra och släppa ett div- element på en canvas- yta, spara elementets positioner och sedan rita ut detta objekt på canvasen, i form av ett bord. Denna process illustreras i Figur 33.

Figur 33 Hur ett div-element dras till en canvas och blir ett canvas objekt.

Det div- element som placerades ut var en s.k. ghost – en visuell kopia av det bord den representerade, som existerade under tiden bordet förflyttades. När en ghost släpptes på en canvas- yta så skapades ett JavaScript- objekt, där bl.a. ghostens positioner sparades. Detta objekt ritades sedan ut på canvasen för att representera ett bord. I Figur 34 visas ett tillståndsdiagram som illustrerar ovanstående process.

Designprocessen

35

Figur 34 Tillståndsdiagram, en ghost blir ett bord.

Hantera flera olika objekt

Då det skapades ett nytt objekt för varje bord som placerades ut, krävdes det något som kunde indexera alla dessa, för att på så vis göra dem enklare att komma åt. Lösningen på detta problem blev en array där samtliga objekt sparades.

Markera objekt

Detta testfall gick ut på att kunna markera bordsobjekt på canvasen genom att klicka på dem. Det krävdes att systemet identifierade vilket bord användaren valde för att sedan markera detta, eller avmarkera ett redan valt bord ifall klicket inte träffade någonting (se Figur 35).

Utifrån användarens klick- event hämtades x- och y- värden som sedan fick jämföras med samtliga bords positioner. Om klicket låg innanför något bords area, räknades detta som en träff och bordet markerades (se Figur 36).

Figur 35 Tillståndsdiagram, hur ett bord markeras.

Figur 36 Hur ett klick identifieras.

Designprocessen

36

Flytta ett objekt

I detta test utarbetades en lösning för att kunna flytta objekt på canvasen. För att åstadkomma detta behövde användaren först markera vilket bord som skulle flyttas och sedan dra det till önskad position.

Då ett bord markerades, doldes detta ifrån canvasen och byttes istället ut mot en ghost, som användaren kunde flytta enligt samma princip som testfallet, placera ut och spara objekt. Dock så skapades här inga nya JavaScript- objekt när placeringen var utförd, utan istället uppdaterades det flyttade bordets positioner i sitt egna objekt.

Identifiera kollisioner

Då en ghost placerades på canvasen, krävdes det att systemet kontrollerade ifall det skedde en kollision med några andra bord, för att förhindra att borden placerades ovanpå varandra. Ghostens position och yta var därför tvungen att jämföras med alla andra bordsobjekt.

4.3.3 Server

Serverkommunikation och datahantering

Eftersom studenterna i förstudierna kom fram till att de skulle använda sig av PHP som serverskriptspråk, JSON som språk vid dataöverföring och MySQL som databashanterare, skulle de i denna fas sätta sig in i hur de kunde utnyttja dessa på bästa sätt för systemet.

Studenterna hade under försöken för området webbapplikation testat att flytta, slå ihop och separera objekt. Det var därför intressant att se hur bordens positioner kunde sparas och hämtas, genom att skicka informationen ifrån webbläsaren till servern till databasen.

Genom att använda AJAX slapp sidan laddas om varje gång ett nytt anrop mot servern gjordes, vilket gjorde att systemet upplevdes mer som ett riktigt program än en hemsida.

Klientsidan

För att kommunicera med webbservern skapades en JSON-sträng med bordets olika värden, som sedan skickades som post till det berörda PHP- skriptet med hjälp av AJAX (se Figur 37).

Figur 37 Kodexempel: Skapa JSON-strängar med JavaScript.

Designprocessen

37

Serversidan

När PHP-skriptet tog emot den post som skickats från JavaScriptets AJAX-funktion, omvandlades JSON-strängen till ett objekt med hjälp av PHP:s inbyggda metod, json_decode. Med hjälp av detta objekt kunde de nya värdena uppdateras i databasen. Omvänt fungerade det då alla borden skulle skickas till klienten.

Ovanstående illustreras med ett kodexempel i Figur 38.

Figur 38 Kodexempel: JSON_decode i PHP.

4.4 Implementation

Det första studenterna gjorde i implementationsfasen var att ännu en gång använda sig utav den klient- och serveruppdelning som använts tidigare under projektet. Detta gjordes så att studenterna var mindre beroende av varandras arbeten och på så vis fick tid att fokusera på sina egna ansvarområden.

Systemets funktioner delades sedan upp i olika moduler, som alla fick olika prioriteringar. Detta gjordes för att få flera delprocesser som kunde utvecklas och testas avskilt från varandra.

De huvudmoduler som lades fram var:

1. Det grafiska användargränssnittet. 2. Hantering och manipulering av bord. 3. Hantering av datum och tid. 4. Hantering av bokningar. 5. Hantering av vyer 6. Offlinekompabilitet

Designprocessen

38

4.4.1 Systemets moduler

Det grafiska användargränssnittet

Det var denna modul som studenterna inledde hela arbetet med, som då la grunden för utseendet och vilka visuella effekter som skulle användas.

Med hjälp av CSS3 Media Queries såg layouten likadan ut på alla skärmar, så länge det fanns möjlighet att få plats med alla funktioner utan att gränssnittet såg besvärat ut (se Figur 39).

Figur 39 Resultat av Media Queries, på PC och på surfplatta.

Hantering och manipulering av bord

Denna modul var uppdelad i flera delmoduler, där huvudsyftet var att kunna placera, flytta, separera, slå ihop och ta bort bord rent grafiskt.

Rita ut bord

En av delmodulerna var att studenterna skulle göra det möjligt att rita ut de existerande borden på canvasen (se Figur 40). Position och storlek på de befintliga borden hämtades från databasen och skickades som JSON- strängar till klienten med hjälp av AJAX.

Designprocessen

39

Figur 40 Canvas med utplacerade bord.

Dra in bord

De bord som vid en tidpunkt inte var utplacerade i restaurangen, skulle kunna dras in vid behov för att skapa fler sittplatser. Detta löstes med hjälp av den studie som gjordes om utplacering utav objekt på canvas, i stycket Klient i Litteraturgenomgång och forskning.

Flytta bord

Systemet var tänkt att ge en överblick av en restaurangs bordsplaceringar vid en viss tidspunkt och det var därför nödvändigt att kunna flytta de olika borden. Detta implementerades med hjälp av den studie som gjordes om hur objekt kunde flyttas, i stycket Klient under avsnittet Litteraturgenomgång och forskning.

I Figur 41 visas den meny som dök upp då man klickade på ett bord och där valet Move Table kunde göras.

Figur 41 "Flytta bord" menyval

Designprocessen

40

Sammanfogning av bord

Bland de krav som ställdes på systemet, fanns ett krav om möjlighet att skapa grupperingar av bord. Detta innebar att två bord à två personer skulle kunna slås ihop och bilda en självständig grupp bord för fyra personer.

En sammanslagning av tre individuella bord, som bildar en egen grupp, illustreras i Figur 42.

Figur 42 Sammanfogning av bord.

Separera bord

Precis som där fanns krav om sammanslagning av bord, fanns där krav om att kunna separera bord. Det fanns tillfällen då bordsgrupperingar inte behövdes och studenterna var då tvungna att finna en lösning där de individuella borden kunde brytas ut ifrån en gruppering. Problemet löstes med hjälp av samma meny som vid flytt av bord, där användaren istället använde sig utav Split Table. Det valda bordet blev då en ghost som kunde flyttas (se Figur 43).

Studenterna valde att inte möjliggöra flytt av en bordsgruppering, utan att användarna istället fick separera gruppen och placera ut bord för bord på den önskade platsen. Det hade blivit allt för krävande för webbläsaren vid uträkningen av kollisioner för gruppens alla bord.

Figur 43 Separering av bordsgruppering.

Designprocessen

41

Hantering av datum och tid

Denna modul var uppdelad i två delmoduler, som tillsammans möjliggjorde att en grafisk bild kunde ritas ut för en begärd tidpunkt. De båda modulerna bestod av kalender och tidslinje.

Kalender

Studenterna utvecklade en delmodul som gjorde det möjligt för användaren att se en viss dags grafiska bild och hur bokningarna såg ut under denna dag. Till detta ansåg gruppen att det var optimalt att använda sig av en kalender för att enkelt kunna bläddra mellan olika dagar, veckor och månader (se Figur 44).

Figur 44 Kalender som användes för att byta dag.

Tidslinje

Studenterna utvecklade denna delmodul för att göra det möjligt att få en grafisk bild av restaurangen vid en vald tidpunkt. Genom att ändra tid i tidslinjen, anpassades restaurangens utseende, vilket illustreras i Figur 45 och 46.

Figur 45 Tidslinje som användes för att påverka den grafiska bilden av restaurangen.

Designprocessen

42

Figur 46 Överblick hur tidslinjen fungerade, där vänstra bilden visar restaurangen klockan 19

och högra bilden klockan 21.

Hantering av bokningar

Denna modul var uppdelad i två mindre moduler som gjorde det möjligt att boka bord vid en specifik tidspunkt och även visa alla bokningar för den valda dagen med hjälp av en reservationslista.

Skapa bokning

När en ny reservation av ett bord gjordes, användes samma meny som nämnts tidigare. Menyvalet var i detta användningsfall New Reservation och detta inledde den reservationsprocess som illustreras i Figur 32.

Vid slutförd reservation ändrades det valda bordets eller gruppens färg från blå till röd.

Figur 47 Meny-val, Ny reservation

Designprocessen

43

Visa bokningar

En reservationslista skapades för att ge användaren en mer detaljerad överblick av dagens bokningar. Listan bestod av flera mindre funktioner; söka bland dagens bokningar och lägga till en ny bokning utan koppling till bordsgrupp eller bord.

För att göra listan mer överskådlig valde studenterna att den i sin grundutformning endast visade vem som bokat, vilket bord de skulle sitta vid och hur många gäster sällskapet innefattade. Listan visas i Figur 48.

Figur 48 Del av reservationslista

Hantering av vyer

Denna modul gjorde det möjligt för användarna att byta vy och även påverka respektive vys bord.

För att minska väntetiden när en användare bytte vy valde studenterna att placera övriga vyer utanför skärmen, så att de laddades in från början men inte syntes till. När sedan användaren ville byta vy klickade de på den önskade vyn i vy- listan, som då åkte in i synfältet samtidigt som den gamla åkte ur (se Figur 49).

Figur 49 Vy- lista och överblick av vyerna.

Designprocessen

44

Offlinekompabilitet

Denna modul gjorde att systemet fungerade även om Internetuppkopplingen försvann, med begränsningen att endast kunna se dagens bokningar och placeringar.

Datalagring

För att användarna skulle ha någon nytta av systemet när de var offline krävdes det att data lagrades hos klienten. Vid dagens första anrop till systemet skickades en stor JSON- sträng med dagens alla bordsplaceringar och bokningar, som sedan lagrades med hjälp av localStorage hos klienten. Detta gjorde att användarna kunde fortfarande kunde se dagens bokningar ifall uppkopplingen försvann.

Den stora JSON-strängen gjorde även att systemet inte behövde skicka anrop varenda gång användarna kände för att byta tid på dygnet med hjälp av tidslinjen.

Offlineåtkomst

Eftersom sidan skulle vara åtkomlig när användarna saknade Internetuppkoppling, var det inte bara data som behövde vara åtkomligt. Även utseendet och systemets funktioner behövde vara tillgängligt. Detta gjorde att cache manifest kom till användning, då CSS-, HTML- och JavaScript- filer kunde sparas ned hos klienten.

4.5 Testning

De användningsfall som togs fram under Analys- och Design-fasen testades i varje iteration av utvecklingen. Dessa test dokumenterades av studenterna, där de inträffade felen noterades och hur dessa skulle kunna lösas i kommande iterationer.

När systemet stod klart var det tänkt att ett slutgiltigt test skulle ske på en riktig restaurang med verkliga händelser. Detta sluttest uteblev dock på grund av tidsbrist.

Diskussion och slutsatser

45

5 Diskussion och slutsatser

5.1 Diskussion av designprocessen

5.1.1 Gränssnittsutveckling

Genom att studera vilka behov användaren hade och i vilken prioritetsordning dessa ställdes, kunde ett effektivt och lätthanterligt gränssnitt skapas och därmed besvara denna frågeställning.

För att främja effektiviteten i gränssnittet, placerades de mest väsentliga funktionerna så få klick bort som möjligt. Detta gjorde att användaren snabbt och lätt kunde utföra dessa uppgifter vid behov.

Då alla element placerades på så vis att de viktigaste funktionerna fick mest plats och uppmärksamhet, blev gränssnittet lätthanterligt. Användaren kunde ta del av huvudfunktionen direkt, i form av den grafiska bilden av restaurangen. De andra funktionerna fanns också nära till hands och kunde plockas fram då de behövdes, istället för att alltid synas.

Vi anser att designprocessen gav oss ett bra svar på hur ett lätthanterligt och effektivt gränssnitt byggs. De behov och prioriteringarna som krävdes hämtades ifrån den kravmodell och analys som gjordes av systemet och gav därför en pålitlig bild över hur användaren ville ha systemet uppbyggt rent grafiskt.

Det som hade kunnat göras annorlunda i designprocessen var att intervjua och testa designen på fler människor. Detta skulle ge en ännu bättre inblick i hur pass lätthanterlig och effektiv designen var.

5.1.2 Offlinekompabilitet

HTML5 erbjuder möjligheten att spara filer och data offline, vilket hjälpte oss att besvara frågeställningen om hur en webbapplikation görs offlinekompatibel.

I vår förstudie beslutade vi att använda oss utav ett cache manifest, vilket gjorde det möjligt för oss att spara systemets utseende och funktionalitet lokalt på användarens enhet. På detta vis kunde all HTML, CSS och JavaScript användas trots utebliven Internetanslutning.

Alla bordsplaceringar och reservationer styrdes av den data som kom ifrån databasen, vilket gjorde att det krävdes åtkomst av dess data offline. Genom att testa samtliga alternativ i HTML5 blev svaret localStorage, där den aktuella dagens data sparades för att kunna användas när uppkopplingen försvann.

Då det på förhand var bestämt att HTML5 skulle användas, fanns det inga andra alternativ att undersöka vad gäller offlinekompabilitet. Vi anser dock att designprocessen gav oss en bra bild över hur data kunde hanteras offline, då vi fick undersöka alla de alternativ som HTML5 erbjuder. LocalStorage lämpade sig bäst för just det här projektet, med tanke på de andra alternativens begränsade webbläsarstöd. Men vi tror dock att IndexedDB kommer vara det mest

Diskussion och slutsatser

46

användbara alternativet i framtiden, då det erbjuder möjligheten att spara hela objekt istället för rader med data.

5.1.3 Effektiv serverkommunikationen

I frågeställningen hur sköts kommunikationen mellan server och klient effektivast krävdes en undersökning av serverskriptspråk, datahantering och hur data skulle överföras.

I designprocessens förstudie beslutade vi att använda oss av PHP före ASP.NET, med avseende på det bredare plattformsstödet. Med samma motivering föll valet på MySQL istället för MS SQL, där det senare endast kunde köras på Windows- servrar.

När det gällde hur data skulle överföras stod valet mellan JSON och XML, där JSON vägde tyngre med tanke på dess kompaktare utformning. Det var nämligen okänt vilken typ av uppkoppling systemet skulle användas med och därför satsade vi på alternativet som krävde minst data.

Med hjälp av AJAX föll den sista pusselbiten på plats för att göra serverkommunikationen effektiv, då användaren slapp ladda om sidan varje gång ett anrop mot servern gjordes. Systemet upplevdes även mer som ett program än en hemsida.

För att få ett mer ackurat svar på denna frågeställning kunde mer utförliga tester ha gjorts. Exempelvis hade vi kunnat utföra undersökningar för att se vilken serverplattform som var vanligast hos restaurangerna eller om de ens har en server. Hastighetstester med fokus på prestanda hade också kunnat utföras både vad gäller programmeringsspråk, datahantering och dataöverföringstekniker.

Vi är ändå nöjda med den designprocess som togs fram, då det gav oss en helhetsbild och resultat ur ett plattformsoberoende perspektiv.

5.1.4 Slutprodukten

Den slutgiltiga produkten utav designprocessen blev ett halvfärdigt system. Systemet i sig levde upp till syftena och svarade på de frågor som ställdes i början av projektet men uppfyllde inte alla de krav som vi tillsammans med uppdragsgivaren satte upp. Anledningen till detta var först och främst tidsbrist.

Det vi skulle kunna ha gjort för att hinna med flera av dessa krav var att redan från början avgränsa systemet så att det skulle möjliggöra mer fokus på de väsentliga delarna. Designprocessen påverkade alltså inte resultaten i någon vidare utsträckning.

Diskussion och slutsatser

47

5.2 Metoddiskussion

5.2.1 Val av metod

Grunden till vårt metodval var att systemet skulle utvecklas objektorienterat. Anledningen till detta berodde främst på att vi ville utvidga våra kunskaper inom området, samt att det var ett ämne som förespråkats i många kurser under vår utbildning.

Arbetsprocessen togs fram av oss själva, där våra beslut baserades på vad tidigare kurser lärt ut inom ämnet Objektorienterad Analys och Design, i kombination med egna erfarenheter.

Då vi skulle arbeta objektorienterat var det nödvändigt att göra en analys och design av systemet. För att få en stabil grund till denna fas krävdes en utförlig kravmodell, i syfte att få en helhetsbild av de problem som fanns och vad som krävdes av det nya systemet.

Vid fasen Litteraturgenomgång och forskning delades arbetet in i fyra huvudområden, samtliga baserade på de frågeställningar som ställdes. Vi ansåg att det skulle bli enklare att fokusera på vad som söktes och därmed få ett mer ackurat svar till dessa frågor.

En förstudie gjordes för att avgränsa projektet, då det ansågs bli alldeles för omfattande att grundligt jämföra alla områdens metoder och tekniker med varandra. Vi valde därför att fokusera på de metoder som ansågs främja syftet och frågeställningarna mest.

Beslutet att dela in huvudområdena i två kategorier, Klient och Server, gjordes för att särskilja interaktion och funktionalitet med prestanda och effektivitet. Det ansågs underlätta den forskning som gjordes, då de båda kategoriernas områden skiljde sig till både syfte och programmering. Dessutom fanns det viss funktionalitet hos några områden som var beroende av varandra.

Under två perioder à två veckor utfördes studier och tester för vardera kategori, där deras områden utforskades. Först genomfördes en studie i form av aktuell litteraturgenomgång, i hopp om att skaffa sig väsentlig kunskap inom den teknik som tagits fram i förstudien. Tillsammans med denna kunskap utformades relevanta testfall, baserade på den funktionalitet systemet skulle ha. Tanken med dessa tester var att kartlägga de möjligheter och begränsningar som fanns inom varje område och därmed styra vilka metoder och tekniker som skulle användas vid implementationen.

Litteraturgenomgång och forskning genomfördes parallellt med fasen Analys och design p.g.a. tidsbrist. Vi ville gå igenom båda faserna före implementationen för att exakt veta hur denna skulle utföras och då fanns det inte mycket val än att genomföra dem parallellt.

Kategorierna Klient och Server användes även under implementationsfasen, då vi ansåg att detta skulle göra oss mindre beroende av varandras arbeten, på så vis att vi kunde fokusera och ansvara för vår egen del. Vi valde även att rangordna

Diskussion och slutsatser

48

systemets funktioner för att kunna bygga moduler av de mest relaterade funktionerna. Detta gjordes för att färdigställa den mest väsentliga funktionaliteten först och sedan, i mån av tid, bygga ut systemet ytterligare.

5.2.2 Reflektioner kring metodval

Vårt val att arbeta objektorienterat lämpade sig väl för projektets genomförande, främst p.g.a. dess stora omfattning. Den objektorienterade arbetsprocessen gav framförallt struktur men även en betydelsefull och heltäckande bild av systemet.

Just kravmodellen var en av de mest väsentliga delarna av projektet, då den styrde precis alla beslut som togs. Samtidigt gav kravmodellen en förståelse och inblick i hur restaurangbranschen fungerade och vilken problematik det fanns vid administrationen av borden och dess bokningar. Men även om kravmodellen var utförlig, hade det varit önskvärt att intervjua fler människor och på så vis få en bredare inblick i användarnas behov och önskemål.

Systemets analys och design gav en bra grund för implementationen. Men i takt med att abstraktionsnivån sjönk blev det problematiskt, då det var osäkert exakt vilka möjligheter och begränsningar som fanns inom HTML5. Detta gjorde att mycket av den klassdesign som togs fram fick kompletteras under implementationsfasen.

Trots att de aldrig blev komplett utförda, anser vi att analysen och designen var direkt nödvändiga. De gav en gemensam bild av systemets funktionalitet som vi ändå hade stor nytta av under implementationen.

Beslutet att dela in projektet i fyra huvudområden gjordes under fasen Litteraturgenomgång och forskning. Detta beslut underlättade de studier och tester som gjordes, då vi helt kunde koncentrera oss på en del i taget och då även besvara de frågeställningar som ställts med mer precision och noggrannhet.

Tack vare den förstudie som gjordes, kunde vi koncentrera våra studier och tester kring vissa metoder och tekniker. Denna gav kanske inte det mest ackurata svaret för projektet som helhet men det ansågs nödvändigt för att kunna svara så utförligt som möjligt på varje enskild.

Genom att dela upp de olika huvudområdena i två kategorier, Klient och Server, kunde vi fokusera på en viss typ av utveckling i taget. De områden som innefattades i respektive kategori hade liknande funktion och var ibland i behov av varandra för att kunna utföra en specifik uppgift.

Bearbetningen av varje kategori gav oss svar på vilka funktioner som lämpade sig bäst för projektet. Upplägget att först studera och sedan testa fungerade väl, på så vis att det var enklare att komma på relevanta testfall som kunde komma till användning senare i projektet. Det fanns dock en problematik, i form av att vi inte visste systemets exakta funktionalitet vid denna tidpunkt.

Under implementationen tilldelade vi oss ett ansvarsområde var, i form av de kategorier som skapades i fasen innan. Detta medförde bl.a. att vi blev experter inom vårt egna område, samt att vi kunde arbeta mer oberoende av varandra.

Diskussion och slutsatser

49

Denna uppdelning gynnade även arbetet med att bygga moduler, på så vis att varje modul kunde slutföras helt och hållet innan nästa del påbörjades.

Men det inträffade också tillfällen i implementationsfasen där de testfall som genomförts under litteraturgenomgången inte stämde överens med systemets funktionalitet. Detta gjorde att begränsningar upptäcktes och på så vis påverkade det även vår klassdesign, i form av att vi fick komplettera under fasens genomförande.

Beslutet att genomföra faserna, Litteraturgenomgång och forskning och Analys och Design, parallellt var nödvändigt för att överhuvudtaget hinna med de båda. Men som redan nämnt, uppstod det problematik i de båda faserna där de ibland blev beroende av varandras resultat. Det resulterade i att implementationsfasen blev lidande och därigenom fick vi komplettera. Dock anser vi att p.g.a. den tidsbrist som fanns så kunde vi inte lagt upp vår arbetsprocess på något annat vis. Problemet var en form av kombination där vi dels visste för lite om den teknik som skulle krävas, dels att vi inte visste exakt hur en sådan här typ av system skulle byggas, då det inte fanns några befintliga exempel att ta efter.

5.3 Slutsatser och rekommendationer

5.3.1 Slutsatser

Arbetet utmynnade i ett fungerande bordbokningssystem i HTML5, där en grafisk bild av restaurangen och dess bokningar kunde ges.

Genom att studera vilka behov användaren hade och i vilken prioritetsordning dessa ställdes, kunde ett effektivt och lätthanterligt gränssnitt skapas.

De nya teknikerna i HTML5, cache manifest och localStorage, gjorde det möjligt att bygga en webbapplikation som kunde användas vid de tillfällen det saknades Internetuppkoppling.

Med hjälp av PHP, MySQL men framför allt AJAX skapades en effektiv serverkommunikation, då dataöverföringar kunde ske utan att störa användarens interaktion med systemet. För att reducera tiden för dessa dataöverföringar användes JSON, då denna standard var mer kompakt än XML och därmed minskade datamängden som skickades, vilket i sin tur också gjorde kommunikationen mer effektiv.

5.3.2 Rekommendationer och förbättringar

Då detta system endast riktar sig mot en restaurangs bordsbokningar, skulle en vidareutveckling kunna ske i form av att ta emot beställningar för respektive bord. Detta system skulle då även kunna användas av kök- och barpersonal för att se vilka beställningar som tagits emot. Ytterligare utveckling skulle kunna te sig i form av betalningsmöjligheter för det som beställts.

Referenser

50

6 Referenser

[1] Simon Bennett, Steve McRobb, Ray Farmer. (2010) Object-Oriented Systems Analysis and Design, McGraw Hill Higher Education; 4th edition (31st March 2010), ISBN-13: 978-007712536-3

[2] Jeff Johnson. (2007) GUI Bloopers 2.0, Second Edition: Common User Interface Design Don'ts and Dos (Interactive Technologies), Morgan Kaufmann, ISBN 0123706432

[3] Wikipedia – Grafisk formgivning http://sv.wikipedia.org/wiki/Grafisk_formgivning Acc (2012-05-28)

[4] Jesse James Garrett. (2010) The elements of user experience: User-centered design for the Web and beyond (2nd edition) (Voices That Matter), New Riders Press, ISBN 0321683684

[5] Jakob Nielsen, Kara Pernice. (2010) Eyetracking web usability, New Riders, ISBN 0321498364

[6] Wikipedia – Färgblindhet http://sv.wikipedia.org/wiki/F%C3%A4rgblindhet Acc (2012-05-28)

[7] Alexis Goldstein, Louis Lazaris, Estelle Weyl. (2011) HTML5 & CSS3 for the real world, SitePoint, ISBN 0980846900

[8] World Wide Web Consortium – HTML5 http://www.w3.org/TR/2012/WD-html5-diff-20120329 Acc (2012-05-28)

[9] HTML5 Readiness http://html5readiness.com Acc (2012-05-28)

[10] Jason Cranford Teague. (2010) CSS3, Peachpit press, ISBN 0321719638

[11] World Wide Web Consortium – CSS3 Media Queries http://www.w3.org/TR/css3-mediaqueries/ Acc (2012-05-28)

[12] Mozilla.org – Object Orientated JavaScript https://developer.mozilla.org/en/Introduction_to_Object-Oriented_JavaScript Acc (2012-05-28)

[13] Server-side Scripting Primer http://www.w3schools.com/web/web_scripting.asp Acc (2012-05-28)

Referenser

51

[14] PHP.net http://www.php.net Acc (2012-05-28)

[15] Gilmore, W. J. (2008) Beginning PHP and MySQL : from novice to professional / 3. ed. Berkeley, Calif. : Apress ; New York, ISBN 1590598628

[16] Murach Joel, Boehm Anne (2006) Murach’s ASP.NET 2.0 Web Programmering with C# 2005 Mike Murach & Associates, ISBN 1890774316

[17] Mono www.mono-project.com Acc (2012-05-28)

[18] World Wide Web Consortium - Webdatabase http://www.w3.org/TR/webdatabase/ Acc (2012-05-28)

[19] HTML5 – WebSQL http://html5doctor.com/introducing-web-sql-databases/

Acc (2012-05-28)

[20] World Wide Web Consortium – IndexedDB http://www.w3.org/TR/IndexedDB/ Acc (2012-05-28)

[21] An early walk-through of IndexedDB http://hacks.mozilla.org/2010/06/comparing-indexeddb-and-webdatabase/ Acc (2012-05-28)

[22] Allen G. Taylor (2010) SQL for dummies, Hoboken, N.J. : Wiley Pub., 2010, 7th ed., ISBN 0470557419

[23] MySQL.com http://www.mysql.com Acc (2012-05-28)

[24] Microsoft SQL Server http://www.microsoft.com/sqlserver/en/us/default.aspx Acc (2012-05-28)

[25] Wikipedia - XML http://en.wikipedia.org/wiki/XML Acc (2012-05-28)

[26] JSON RFC (RFC 4627) http://tools.ietf.org/html/rfc4627 Acc (2012-05-28)

Sökord

52

7 Sökord API ..................................................... 10 Canvas ................................................ 11 CSS3 ................................................... 12 DBMS ................................................ 17 Grafisk formgivning..................... 9, 28 HTML5 .............................................. 10 IndexedDB ........................................ 16 JavaScript ........................................... 13 JSON .................................................. 18

LocalStorage ...................................... 15 MDI ...................................................... 8 MS SQL .............................................. 17 MySQL ............................................... 17 Offlinekompabilitet ....... 11, 15, 28, 44 Serverkommunikation ......... 13, 36, 46 WebSQL............................................. 15 XML ................................................... 18

Bilagor

53

8 Bilagor

8.1 Bilaga 1

Sammanfattning av krav

1. Att kunna hantera bokningar av bord a. Att kunna hantera en bokning, vid en viss tid och för ett angivet antal

personer, kopplat till en specifik kund. b. Att kunna hantera övrig information om en bokning, så som allergier

eller speciella önskemål. c. Att kunna skicka en bokningsbekräftelse via sms eller mail. d. Att kunna hantera status på en bokning. e. Att kunna flytta en bokning från ett bord till ett annat. f. Att kunna se alla bokningar för en specifik dag.

2. Att kunna hantera kunduppgifter a. Att kunna hantera namn, telefon och övrig information om en kund.

3. Att kunna begränsa systemet inom personalen a. Att kunna dela in personalen i grupper med olika rättigheter i systemet. b. Att kunna administrera de olika gruppernas rättigheter.

4. Att kunna hantera vyer av restaurangens olika ytor a. Att kunna hantera vyer av restaurangens olika ytor. b. Att kunna hantera bordsuppställningen för de olika vyerna genom att

flytta, separera och slå ihop bord. c. Att kunna få en grafiska bild av restaurangens bokningar vid en specifik

tidpunkt och dag. 5. Att kunna hantera flera olika restauranger

a. Att kunna lägga till flera restauranger med egna bokningar och vyer. 6. Att kunna hantera statistik för restaurangens bokningar

a. Att kunna se en logg över alla ändringar som görs i systemet. b. Att kunna se ex. antalet allergiker, vegetarianer etc. för en specifik

dag/vecka. c. Att kunna lagra kommentarer för en specifik dag/vecka. d. Att kunna se statistik över restaurangens bokningar för en specifik

vecka, månad, år. e. Att kunna se statistik över en specifik kund.

7. Icke-funktionella krav a. Att systemet ska vara på engelska. b. Att kunna använda systemet även utan Internet- uppkoppling. c. Att systemet ska vara användarvänligt. d. Att kunna komma åt systemet var som helst via Internet. e. Att systemet ska vara plattformsoberoende. f. Att systemet ska vara snabbt och stabilt.