Upload
others
View
1
Download
0
Embed Size (px)
Citation preview
Furnie ToolsArbetsverktyg för hantering av data
pÄ Horreds Möbel AB
Furnie ToolsTool for handling data at Horreds Möbel AB
Mathias Nilsson
Simon Ăsterholm
Examensarbetet omfattar 15 högskolepoÀng och ingÄr som ett obligatoriskt moment iHögskoleingenjörsexamen i Datateknik, 180p
Nr 1/2009
Arbetsverktyg för hantering av data pÄ Horreds Möbel AB
Tool for handling data at Horreds Möbel AB
Mathias Nilsson [email protected]
Simon Ăsterholm [email protected]
Kandidatuppsats examensarbete
Ămneskategori: Teknik
Serie och nummer: Datateknik 1/2009
Högskolan i BorÄsInstitutionen Ingenjörshögskolan501 90 BORà STelefon 033-435 4640
Examinator: Magnus Lundin
Handledare: Ă sa Johansson
Uppdragsgivare: Horreds Möbel AB
Datum: 2009-04-27
Nyckelord: Databas, database, UML, UP, program, verktyg
ii
Abstract
This report describes the creation of a software program and a database for handling differentkinds of data at Horreds Möbel AB, a furniture manufacturing company. Based on therequired specifications and by using a development tool UML (Unified Modelling Language),we created a template for how the software should operate. The template was used to form therequired functions which were needed by the software. The template was also used to formthe needed objects, classes and other important components that appear in the software.
A database and the software that it communicates with were created by using two softwaretools MS SQL 2000 and Jbuilder2005 as well as the data generated from UML. This softwaremakes it possible to handle the databaseÂŽs different kinds of data. Through Jbuilder2005, agraphical user interface was developed and the corresponding code was automaticallygenerated. To complete this process, all functions needed in the software had to be createdmanually.
In order to form a comprehensive graphical user interface we drew on our own insights andideas in addition to the knowledge gained in the course Mjukvarudesign (translation: SoftwareDesign) Microsoft Office was used as template for the user interface.
The code was formed in different classes and structured in a way that a main class handles thegraphics and creation of new objects. The database was structured in tables where therelationships are based on the company's product catalogue.
Sammanfattning
I denna rapport beskrivs utvecklingen av ett program och en databas för hantering av datatĂ€nkt att anvĂ€ndas pĂ„ ett möbelföretag, Horreds Möbel AB. Med en kravspecifikation somutgĂ„ngspunkt och med hjĂ€lp av ett utvecklingsverktyg, UML (Unified Modeling Language)har en mall för programmets utseende arbetats fram. Ur denna mall formas de funktionerprogrammet behöver och hur de rent teoretiskt ser ut. Ăven vilka objekt, klasser och andraviktiga komponenter som programmet kommer att ha, formas pĂ„ samma sĂ€tt.
Med hjÀlp av tvÄ program, MS SQL 2000 och JBuilder2005, och det UML genererat, har endatabas och ett program formats. Dessa kommunicerar med varandra för att hantera data förolika syften. Genom JBuilder2005 skapades ett grafiskt grÀnssnitt som automatisktgenererade koden för detta. Sedan formades funktionerna manuellt till de olikakomponenterna i programmet.
För skapandet av ett anvÀndarvÀnligt grÀnssnitt tillÀmpades kunskapen given genom kursenMjukvarudesign pÄ BorÄs högskola, samt egna tankar och idéer pÄ hur man formararbetsfönstret pÄ ett sÄ tillfredsstÀllande sÀtt som möjligt för anvÀndaren. Som underlag förgrÀnssnittet anvÀndes programmen i Microsoft Office.
Koden formades klassvis och strukturerades sÄ att en huvudklass ansvarar för grafiken ochskapandet av instanser av de andra klasserna. Databasen formades med tabeller och dessastrukturerades med relationer tagna frÄn företagets produktkatalog.
iii
InnehÄll
Abstract.....................................................................................................................................3Sammanfattning.......................................................................................................................3
1.1 Syfte.................................................................................................................................62. Principer för val av metod och verktyg.............................................................................6
2.1 Litteratur..........................................................................................................................72.2 Programvara.....................................................................................................................7
2.2.1 Utvecklingsmiljö.......................................................................................................72.2.2 Databas......................................................................................................................7
2.3 ModelleringssprÄk: UML (Unified Modeling Language)...............................................72.3.1 Kravspecifikation och Begreppslista........................................................................82.3.2 Use Case ...................................................................................................................82.3.3 Interaktionsdiagram..................................................................................................82.3.4 Kontrakt....................................................................................................................92.3.5 Klassdiagram.............................................................................................................92.3.6 Validering, Testning och Integrering .......................................................................9
3. Objektorienterad Analys och Design av systemet.............................................................93.1 Idépresentation...............................................................................................................103.2 Identifikation av begrepp...............................................................................................103.3 Use Case.........................................................................................................................103.4 Interaktionsdiagram.......................................................................................................113.5 Kontrakt.........................................................................................................................113.6 Klassdiagram..................................................................................................................113.7 Utvecklingen av databasen............................................................................................123.8 Implementeringen..........................................................................................................123.9 Programmets funktioner.................................................................................................12
3.9.1 Skapande funktioner ..............................................................................................123.9.2 Ăndrande funktioner mot databasen.......................................................................133.9.3 Ăndrande funktioner i programmet.........................................................................13
4. Implementation..................................................................................................................134.1 AnvÀndargrÀnssnitt........................................................................................................13
4.1.1 Grundfönstret..........................................................................................................144.1.2 Menyn & verktygsfÀlt.............................................................................................154.1.3 VÀnster sida.............................................................................................................174.1.4 Höger sida...............................................................................................................19
4.2 Databas...........................................................................................................................204.2.1 Databastabellerna....................................................................................................20
4.3 Kodstruktur....................................................................................................................214.3.1 LĂ€gg till ny produkt (addProduct)...........................................................................224.3.2 Skapa tabellen materialgrupp..................................................................................23
5. Applikationens felhantering och hjÀlpinstruktioner......................................................235.1 Manualen........................................................................................................................235.1 Felhanteringsfunktion....................................................................................................23
6. Problem...............................................................................................................................246.1 Tidsaspekten..................................................................................................................24
7. Diskussion...........................................................................................................................257.1 Applikationens utformning och design..........................................................................257.2 Applikationens programmeringsstruktur.......................................................................25
iv
7.3 Databasens struktur........................................................................................................267.4 Applikationens felhantering...........................................................................................267.5 Applikationens hjÀlpinstruktioner..................................................................................267.6 Tidsaspekten..................................................................................................................26
8. Slutsats................................................................................................................................27Referenslista...........................................................................................................................28
Bilaga 1 KravspecifikationBilaga 2 BegreppslistaBilaga 3 Use Case DiagramBilaga 4 Use CaseBilaga 5 SystemsekvensdiagramBilaga 6 KontraktBilaga 7 Klassdiagram/systemarkitekturBilaga 8 Databasstruktur
v
InledningDetta arbete baseras pÄ en förfrÄgan frÄn företaget Horreds Möbel AB, dÀr de efterfrÄgar ettprogram som kan hjÀlpa dem för att digitalt hantera deras produktsortiment och hjÀlpa demvid framstÀllningen av nya produktkataloger. Företaget Horreds Möbel AB grundades 1936och har sitt huvudsÀte i Horred i VÀstra Götaland. Deras affÀrsidé Àr frÀmst kontorsmöbleringmed inriktning pÄ design och kvalitet dÀr de har skapat ett antal olika produktgrupper för attskapa attraktiva lösningar för olika typer av kunder.
Uppgiften för att tillmötesgÄ företagets önskemÄl blev att finna en lösning som stÀmde braihop med deras kravspecifikation. Och denna blev att bygga upp en databas för hantering avföretagets artiklar samt att skapa ett program som kan kommunicera med databasen för attredigera dess innehÄll. Programmet skulle Àven innehÄlla en funktion dÀr en nyproduktkatalog kan genereras frÄn de mest aktuella data som lagrats i databasen. Programmetskulle vara enkelt och lÀtt att lÀra sig dÄ datorkunskapen hos anvÀndarna Àr blandad ochdÀrför Àr ett tydligt anvÀndargrÀnssnitt med hög igenkÀnningsfaktor viktigt.
Metoden som var underlag för arbetet heter UP (Unified Process) och som verktyg för attskapa detta program anvÀndes UML (Unified Modeling Language).
1.1 Syfte
Detta arbetes syfte var att leverera en lösning till Horreds Möbel AB som bestÄr i enstrukturerad databas med ett tillhörande program för redigering av dess data. Denna rapportingÄr som en del i arbetet och beskriver hur utvecklingen av programmet och databasen gÄtttill och varför grÀnssnittet formats som det gjort.
2. Principer för val av metod och verktyg
För att skapa ett program och en databas som Horreds Möbel AB efterfrÄgar krÀvs kunskapom hur man programmerar och utformar ett program samt hur man bygger en databas. NÀrman startar ett projekt gÀller det att vÀlja bra verktyg och modeller för att nÄ bÀsta möjligaresultat. Problem uppstÄr alltid och genom att finna nya lösningar möjliggör man vidareutveckling och dÄ genereras ny kunskap som Àr till nytta för utvecklingen av programmet. Iprogramutveckling Àr det liksom i sÄ mÄnga andra sammanhang vÀldigt viktigt att lÀgga enstabil grund som man kan stÄ stadigt pÄ genom hela utvecklingsarbetet.
I början av ett projekt Àr det svÄrt att vÀlja vilket programsprÄk och vilken databas man skaanvÀnda dÄ valet av dessa bör baseras pÄ programmets utseende och funktionalitet. Det manförst bör vÀlja Àr med vilken utvecklingsmodell man vill forma sitt program. Valet blevmetoden UP och utvecklingsverktyget UML som passade bra för detta arbete. Med UP ochUML formas programmet, hur det teoretiskt kan fungera och dÀrefter blir det lÀttare attbesluta om vilket programmeringssprÄk som bÀst passar in.
Valet av sprÄk Àr viktigt, och dÄ Àr det bra att vÀga fördelar och nackdelar mot varandra. Idetta projekt var det viktigt att vÀlja ett sprÄk som var lÀtt att implementera med en databas.Valet blev sprÄket Java dÄ detta Àr relativt enkelt att jobba med och uppfyller stÀllda kriterier.
2.1 Litteratur
UP och UML Ă€r stora Ă€mnen som tillĂ€mpas pĂ„ olika omrĂ„den och dĂ€rför finns det mycketlitteratur att tillgĂ„. TvĂ„ bra böcker Ă€r âThe unified software development processâ och âTheunified modeling language user guideâ som strukturerat tar upp dessa Ă€mnen.
Programmering Ă€r ett stort omrĂ„de och det finns mycket litteratur, bĂ„de i bokform och pĂ„Internet. Java Ă€r ett relativt nytt sprĂ„k som blivit populĂ€rt vilket gör det lĂ€tt att finnainformation. En bra bok Ă€r âJava Direkt med Swingâ som grundlĂ€ggande beskriver sprĂ„ketJava. Den Ă€r tydlig och innehĂ„ller mĂ„nga exempel av kodstrukturer och fyller mĂ„nga behovför att klara av olika programmeringsuppgifter.
Koden i Java baseras pÄ klasser och pÄ Internet finns det mÄnga fÀrdiga att ta del av gratis.Framför allt hemsidan http://java.sun.com/javase/6/docs/api/ innehÄller mÄnga bra ochanvÀndbara klasser som kommer till hjÀlp vid programmering.
2.2 Programvara
2.2.1 UtvecklingsmiljöNÀr man bestÀmt sig för ett sprÄk behövs ett program dÀr man skapar grÀnssnitt och skriverkod. Det finns olika tillvÀgagÄngssÀtt, ett Àr att man skriver all sin kod sjÀlv i enklare programsom t.ex. en texteditor, ett annat att man vÀljer ett program dÀr man bygger uppanvÀndargrÀnssnittet och fÄr koden för grafiken genererad som i t.ex. Jbuilder2005. Generelltfungerar det sÄ att grÀnssnittet byggs upp med fÀrdiga komponenter t.ex. knappar ochrullgardiner och sedan skapar programvaran den kod som motsvarar dessa vilket sparar tid förutvecklaren och gör det trevligt och smidigt att jobba med.
2.2.2 DatabasDe flesta applikationer som hanterar mycket data anvÀnder sig av nÄgon form av databas dÀrall information sparas. I detta arbete blev valet att anvÀnda Microsoft SQL 2000 pÄoperativsystemet Windows Server 2003 dÄ Horreds Möbel AB sedan innan anvÀnder sig avMicrosoft SQL 2000.
2.3 ModelleringssprÄk: UML (Unified Modeling Language)
Vid programutveckling och mjukvarudesign finns det olika metoder för hur man gÄr till vÀga.En metod Àr UP(Unified Process) dÀr man utifrÄn en kravspecifikation jobbar med ett sprÄkUML, som innehÄller verktyg för att beskriva olika typer av system. I detta fall anvÀndes detför konstruktion av mjukvara och objektorienterad programmering som Àr ett vanligtanvÀndningsomrÄde för UML. Idén med det hela Àr att man först analyserar vad som skagöras, sedan designar hur det ska göras för att i slutÀndan genomföras. UML omfattar etttillvÀgagÄngssÀtt med olika diagram och modeller för att göra analyser och fÄ designtips.Följer man dessa mallar och anvÀnder verktygen rÀtt sÄ fÄr man i slutÀndan fram delar avimplementeringen, detta tack vare att man med UML byggt upp de logiska relationerna sombehövs, vilka aktörer som gör vad och hur de gör det.
2.3.1 Kravspecifikation och BegreppslistaProjektet börjar med en kravspecifikation dÀr bestÀllarens krav finns nedskrivna, t.ex. vadprogrammet ska göra, vilka funktioner som ska finnas med och olika systemattribut mm.FrÄgan man stÀller sig Àr alltsÄ vad som ska göras. Ur denna kravspecifikation identifierasolika objekt, metoder, attribut mm som programmet ska bestÄ av och dÄ har grunden börjatformas. I detta skede ska man börja skriva en begreppslista, som ska innehÄlla allt som kanuppfattas som objekt, metod, attribut mm. Denna lista underhÄller man genom hela arbetetvilket Àr viktig för att fÄ med alla egenskaper i programmet.
NĂ€r man fĂ„tt fram vad som ska finnas med fĂ„r man stĂ€lla sig frĂ„gan vem som ska pĂ„verkaprogrammet, alltsĂ„ aktörer. Ăr det en person som ska sitta vid en dator och jobba eller Ă€r detflera anvĂ€ndare vid olika datorer. Detta Ă€r ett steg som bör tĂ€nkas igenom vĂ€l dĂ„ det Ă€r hĂ€rgrunden lĂ€ggs för hur programmet ska formas. Det Ă€r viktigt att anvĂ€ndaren/anvĂ€ndarnadirekt kĂ€nner att de kommer in pĂ„ vĂ€sentliga delar i programmet och inte behöver klickaigenom saker som de inte har nĂ„gon som helst nytta av.
2.3.2 Use CaseUse Case Àr ett verktyg för att illustrera hur en aktör utför ett moment i programmet ochenkelt visar vad som sker, frÄn en utgÄngspunkt till en slutpunkt. Detta Àr ett bra sÀtt för att fÄen bild av hur man kan strukturera programmet, vilka steg som ska finnas för att utföra nÄgotmm. Med dessa som underlag utvecklas Use Case diagram dÀr man förtydligar saker ochslutligen organiserar dem till ett enkelt flödesdiagram för att fÄ en bild av hur programmet kanse ut. Förhoppningsvis har man identifierat vilka aktörer som finns, vad de gör och hur de kanrelateras till varandra, men ocksÄ har man möjligen identifierat objekt som ska bli grunden förprogrammet.
Efter de första stegen gÀller det att granska dokumentationen och se vad för begrepp mansamlat pÄ sig och analysera vad man fÄtt fram. Identifiering av begreppen görs för att byggaupp objekt med olika egenskaper eller attribut och bygga upp relationer mellan dem. FrÄndessa objekt och deras relationer formas senare klasser.
2.3.3 InteraktionsdiagramInteraktionsdiagram anvÀnder man för att mer detaljerat beskriva systemet och hjÀlpa till attfinna olika mönster i det. Ur dessa ska man förhoppningsvis fÄ ihop tillrÀckligt medinformation för att gÄ vidare med systemdesignen. Dessa diagram Àr en bild av hÀndelser isystemet mellan olika element som aktörer, objekt eller komponenter.
Det finns olika interaktionsdiagram t.ex. sekvensdiagram, systemsekvensdiagram ochsamarbetsdiagram. Sekvensdiagram och systemsekvensdiagram beskriver hÀndelser mellanobjekt utmed en tidsaxel medan samarbetsdiagram beskriver de naturliga lÀnkarna mellanolika objekt och vad som sker mellan dem.
HĂ€r utgĂ„r man frĂ„n sina tidigare utvecklade Use Case dĂ€r man beskrev ett hĂ€ndelseförlopp,med en startpunkt och slutpunkt. Nu kan man utifrĂ„n Use Case skapa sinainteraktionsdiagram som beskriver hĂ€ndelserna. Dessa hĂ€ndelser döper man till passandenamn som ganska specifikt beskriver vad som hĂ€nder i systemen, t.ex. âAngeBelopp(Num)â.Inom parenteser i namnet anges ocksĂ„ vad för typ av vĂ€rde som funktionen handhĂ„ller, i dettafall ett numeriskt vĂ€rde.
NÀr man skrivit sina interaktionsdiagram har man förhoppningsvis fÄtt en bÀttre bild av vadsom hÀnder i systemet.
2.3.4 KontraktI interaktionsdiagrammen har en hel del systemhÀndelser identifierats och redovisats, mendessa Àr inte speciellt tydliga. DÀrför skriver man kontrakt som beskriver detta. VarjesystemhÀndelse eller operation beskrivs med ett kontrakt för att förtydliga dess syfte. Manbeskriver vad operationen gör eller uppfyller, vad för typ av funktion det Àr, var den finns(referenser), undantagshÀndelser, utgÄngslÀge och slutlÀge.
2.3.5 KlassdiagramGenom tidigare steg i utvecklingen som t.ex. Use Case, interaktionsdiagram ochbegreppslista har man funnit begrepp och identifierat objekt som bildar olika klasser. En klassÀr en beskrivning av ett antal objekt som delar samma attribut, funktioner och relationer. Föratt skapa sig en visuell bild över programmets struktur och för att ha ett underlag vidimplementeringen skapar man klassdiagram. HÀr stÀller man sig frÄgor som hjÀlper till attfinna relationer mellan de klasser man format. Relationerna visar hur kommunikationen ochsamarbetet mellan klasserna fungerar.
2.3.6 Validering, Testning och IntegreringNÀr man skapat de olika diagrammen och begreppslistan ÄterstÄr det att granska dem ochjÀmföra och se sÄ att allt stÀmmer. Att alla funktioner och objekt Àr korrekt redovisade ellerom det finns nÄgot som kan betraktas som överflödigt, t.ex. att man kanske kan ersÀtta tvÄsaker med en. Allt detta Àr viktigt att göra innan man börjar med implementeringen, attupptÀcka olika problem hÀr sparar tid och pengar.
NÀr man sedan har börjat med implementeringen Àr det viktigt att testa sÄ att allt fungerar somdet ska, bÄde under tiden man programmerar och nÀr man tror sig Àr fÀrdig med programmet.Att skicka en felaktig produkt Àr kostsamt och skapar dÄligt förtroende frÄn kunder.
Det som sedan ÄterstÄr Àr att integrera produkten med kundens system och se till sÄ att alltfungerar och att rÀtt saker Àr levererade. NÀr man uppfyllt alla punkter som efterfrÄgats avkunden sÄ kan man verifiera detta och se projektet avslutat.
3. Objektorienterad Analys och Design av systemet
Detta arbete lade sin grund efter en förfrÄgan frÄn Horreds Möbel AB om ett program somkunde hjÀlpa dem vid framtagning av nya produktkataloger. Programmet som efterfrÄgadesska jobba mot en databas med information om deras produkter och dÀr de ska kunna redigeradata, lÀgga till ny data och i slutÀndan generera en ny produktkatalog av befintlig data.Intressant uppgift och dÀrför, för att följa tanken med UP, skickades en förfrÄgan om en tydligoch genomtÀnkt kravspecifikation som visade vad företaget hade för mÄl med projektet ochsamtidigt möjliggöra ett stÀllningstagande till om man var rÀtt personer för dem att genomförauppgiften.
3.1 Idépresentation
Kravspecifikationen (se bilaga 1) Àr kort men relativt tydlig. Det framgÄr tydligt vilkafunktioner de vill ha i programmet samt vad databasen ska innehÄlla. Som det beskrivstidigare i rapporten Àr UP en bra metod vid utveckling av nya program och dÀrför tillÀmpasdessa idéer i detta arbete för dess utformning.
NÀr man nu hade en kravspecifikation var det dags att sÀtta sig ner och lÀsa igenom den ochbedöma vilka möjligheter som fanns för att kunna tillmötesgÄ deras önskemÄl. Genom attsÀtta sig in i problematiken över vad som begÀrdes och sedan överlÀgga med handledaren tillexamensarbetet om möjligheterna att skapa ett program som uppfyller deras krav, gjordes enbedömning att alla punkter i kravspecifikationen inte gick att fullfölja. Skapandet av vissafunktioner som Horreds Möbler AB efterfrÄgade var enligt handledaren för svÄra ochtidskrÀvande, framför allt önskemÄlet med att pÄ nÄgot sÀtt generera en produktkatalog pÄdata som lagras i databasen.
Ăvriga punkter i deras kravspecifikation var helt rimliga att fullfölja sĂ„ nu var en grundplanatt arbeta efter lagd och utvecklingen av programmet startade.
3.2 Identifikation av begrepp
UtifrÄn den fÀrdiga kravspecifikationen lades en grund för programmet genom skapandet avbegreppslistan (se Bilaga 2). Denna följde med under projektet och uppdateradeskontinuerligt. Genom kravspecifikationen och en produktkatalog frÄn Horreds Möbel ABurskildes de grundlÀggande funktioner och begrepp som senare anvÀndes i dokumentationen iUML.
Begrepp som framkom var framför allt olika egenskaper pÄ produkter som ska lagras idatabasen och som företaget senare ska ha möjlighet att kunna Àndra, som t.ex. pris, namn,beskrivning mm. Det samma gÀller de funktioner som identifierades i kravspecifikationensom t.ex. funktioner för att lÀgga till en artikel, göra prisÀndringar pÄ artiklar och möjlighetenatt handskas med olika valutor. En anmÀrkning hÀr var att de flesta funktioner med störstasannolikhet skulle bli vÀldigt lika, detta underlÀttar vid implementeringen dÄ man kanÄteranvÀnda kod.
3.3 Use Case
Med en fÀrdig kravspecifikation och den pÄbörjade begreppslistan fanns grunden för att kunnagÄ vidare i utvecklingsarbetet. Genom att börja utforma olika Use Case, bÄde enklare ochutvecklade, sÄ tydliggjordes illustrativt vad som hÀnder i programmet. Dessa sammanstÀlldessedan till ett Use Case diagram (se Bilaga 3).
Huvudfunktionen med programmet som visas i Use Case diagrammet Àr att genom ett antalfunktioner kunna fylla en databas med information som ska anvÀndas för skapandet av enproduktkatalog. Diagrammet visar de underliggande enkla Use Case som identifierades ikravspecifikationen som t.ex. att lÀgga till en ny produkt eller lÀgga till en ny materialgrupp,alltsÄ alla de funktioner som krÀvs för att skapa den data en produkt bestÄr av i en katalog.
Att alla enkla Use Case pekar pÄ ett huvudprogram visade att denna fick bli programmetshuvudklass genom utvecklingsarbetet. Diagrammet visar att aktören jobbar mothuvudklassen.
Sammanfattat visar de enkla Use Case och diagrammet illustrativt hur en aktör interagerarmed systemet. De utvecklade Use Case (se Bilaga 4) beskriver de enklare Use Case, t.ex. nÀren aktör lÀgger till en ny produkt, de tydliggör flödet. Ur dessa framgick det att mÄnga UseCase hade en liknande uppbyggnad vilket grundlade tanken för en enklare utformning vidimplementationen dÀr samma struktur pÄ koden kunde ÄteranvÀndas. De gav ocksÄ en bild avhur grÀnssnittet skulle kunna formas dÄ de beskriver hur en anvÀndare jobbar i programmet.
3.4 Interaktionsdiagram
För att utveckla och fÄ en bÀttre bild över systemet skapades interaktionsdiagram, i detta fallsystemsekvensdiagram (se Bilaga 5). Diagrammen visar generellt att det Àr en kontinuerligkommunikation mellan databasen och programmet dÀr anvÀndaren genom funktioner styr ochsÀtter vÀrden pÄ data som lagras i databasen. Den tÀnkta huvudklassen (system i diagrammet)skapar instanser som anvÀndaren utnyttjar för att kommunicera med databasen.
I de olika Use Case som formades skapades mÄnga hÀndelser för att kunna fullfölja flödett.ex. nÀr anvÀndaren vill skapa en ny produkt eller en post i databasen. Detta visas idiagrammet och betyder att det behövs funktioner för dessa hÀndelser. SÄ med hjÀlp avsystemsekvensdiagram grundlades funktionerna genom identifiering av hÀndelser.
I begreppslistan fanns alla dittills identifierade variabler som nu kunde placeras i hÀndelsernaoch sÄledes bli variabler i funktionerna som formades i diagrammen. Detta bekrÀftar hurvariabler, funktioner och objekt kan relateras och organiseras gentemot varandra.
3.5 Kontrakt
HÀndelserna i interaktionsdiagrammen gav flertalet funktioner som dokumenterades medkontrakt (se Bilaga 6). Med dessa tydliggörs mer specifikt hur funktionerna ser ut medvariabler och returvÀrden. HÀr preciseras Àven vilket ansvar funktionerna har. Dessa varunderlag nÀr funktionerna implementerades.
3.6 Klassdiagram
Med det underlag som skapats med verktygen i UML formadesklassdiagram/systemarkitektur (se Bilaga 7) för att illustrera programmets uppbyggnad.Diagrammet visar att huvudklassen âArbetsfönstretâ innehĂ„ller en allmĂ€n funktionâNyttObjektâ som anvĂ€nds för att skapa nya objekt som t.ex. en produkt, en ny materialgruppeller en ny valuta. Dessa i sin tur har en koppling till en databasadapter som ser till attdatabasen uppdateras. I âArbetsfönstretâ finns Ă€ven en funktion âĂndraobjektâ som genomdatabasadaptern hĂ€mtar data sĂ„ att anvĂ€ndaren kan redigera den och sedan uppdateradatabasen med nya vĂ€rden. Diagrammet visar Ă€ven att det inte behövdes nĂ„gra kopplingarmellan klasserna dĂ„ all hantering av dessa sker mellan klasserna och databasen.
3.7 Utvecklingen av databasen
En bra databas behöver en bra grund, man mÄste faststÀlla alla attribut som ska finnas medoch strukturera en relation mellan dem och finna nycklar. Genom UML finns det bra mallarför hur man formar en bra databas. Genom att bestÀmma rubriker efter attribut som tas framför databasens kolumner placeras och organiseras rubrikerna i ett antal tabeller.
Varje databas behöver nycklar för att skapa unika poster, dessa knyter ihop databasen ochsedan skapas funktioner som kan kommunicera med databasen för att fÄ programmet attfungera.
Ur begreppslistan sÄ identifierades alla objekt som blev rubriker i databasen och dÄ blev Àvende tillhörande attributen till dessa kolumner. I detta fall blev det naturligt att anvÀndaprodukternas artikelnummer som nyckel dÄ dessa frÄn början var unika. Andra nycklar somanvÀnds i databasen Àr t.ex. materialgruppernas och produktgruppernas id-nummer.
3.8 Implementeringen
Med hjÀlp av resultatet frÄn UML sÄ gick utvecklingsprocessen vidare och underlag förimplementeringen fanns fÀrdig. I samband med detta sÄ upptÀcks saker som gör att man delvisavviker frÄn den strukturerade plan som UML gav, verktyget ger en möjlig bild avprogrammet men ingen slutgiltig. Genom JBuilder sÄ genereras kod i samband med att manformar anvÀndargrÀnssnittet. Koden kan uppfattas som obekvÀm och ostrukturerad ochbehöver dÀrför en del redigering.
3.9 Programmets funktioner
NÀr programmet byggdes och formades i JBuilder2005 till det utseendet som önskades sÄgenererades ocksÄ den kod som behövs för att skapa detta grÀnssnitt. Det som saknas Àr kodentill alla de tÀnkta funktioner som ska finnas i programmet vilket Àr upp till programmerarnasjÀlva att skapa. En annan sak som programmet inte hade hjÀlpt till med var att skapakommunikationen med databasen.
Genom kravspecifikation, Use Case och systemsekvensdiagram har det lagts en grund för enmÀngd funktioner som programmet behöver för att uppfylla kraven frÄn Horreds Möbel AB.Programmet innehÄller ett par grundlÀggande funktionsgrupper, alltsÄ grupper med liknandefunktionalitet. En grupp med funktioner dÀr man skapar nÄgot och lÀgger in det i databasen,en grupp dÀr man kommunicerar med databasen och jobbar med dess innehÄll och en gruppsom bara pÄverkar sjÀlva programmet.
3.9.1 Skapande funktionerGenom arbetet med UML visade det sig att det finns en hel del olika egenskaper till de artiklarsom ska skapas i databasen. Varje möbel tillhör en specifik möbelgrupp, Àr tillverkade i ettvisst material och tillhör dÀrför en specifik materialgrupp, har ett pris, en beskrivning, ettspecifikt nummer som gör möbeln unik mm.
Programmet bygger upp databasen genom att lÀgga in möbler med alla dess tillhörandeegenskaper i en post dÀr varje egenskap lagras i egna kolumner. För varje ny egenskap t.ex.
en ny materialgrupp, produktgrupp eller sprÄk som lÀggs till i databasen fylls listor med dessagrupper pÄ.
Dessa listor med egenskaper fyller upp comboboxar som underlÀttar för en anvÀndare somvill lÀgga till en ny produkt. Med hjÀlp av comboboxarna kan anvÀndaren vÀlja bland alla despecifika egenskaper en produkt kan ha.
3.9.2 Ăndrande funktioner mot databasenNĂ€r man har skapat poster i databasen sĂ„ behöver programmet ocksĂ„ andra funktioner dĂ€rman kan Ă€ndra posterna i databasen t.ex. Ă€ndra nĂ„got pris eller nĂ„got i en produktgrupp. Dessatyper av funktioner Ă€r alla programmerade pĂ„ ett liknande sĂ€tt, alla tar emot data ochuppdaterar databasen. Alla egenskaper som man skapat och sedan lagrat i databasen kan manĂ€ndra i efterhand förutom identitetsnumret som Ă€r unikt och Ă€r en nyckel i databasen.
Dessa funktioner Àr placerade under olika flikar som Àr inlagda i grÀnssnittet. Varje flik harfÄtt ett namn som Àr vÀgledande och visar vad man jobbar med t.ex. produkt, pris ellermaterialgrupp. NÀr man vÀxlar mellan flikarna anropas olika funktioner, det sker olikasökningar i databasen som visas i en lista som Àr inlagd i grÀnssnittet. GÄr man in pÄ flikenmaterialgrupp syns alla tillgÀngliga grupper frÄn databasen i listan och markerar man en postsÄ visas data i de olika textfÀlt som finns under de olika flikarna.
För att organisera vad som visas i listan Àr en funktion inlagd dÀr man kan göra enklaresorteringar för att fÄ ner antalet poster till en mer lÀtthanterlig mÀngd. Denna funktionanvÀnds nÀr man vÀljer fliken produkter, som innehÄller en oöverskÄdlig mÀngd poster. Meddenna funktion vÀljer man att t.ex. visa alla poster som tillhör en viss produktgrupp.
I kravspecifikationen fanns en önskan frÄn Horreds Möbel AB att det skulle finnas enfunktion dÀr man stÀller in valutakursen och pÄ sÄ sÀtt fÄ priserna i olika valutor. Dennafunktion fungerar sÄ att man stÀller in önskad kurs och sedan trycker pÄ en knapp för attgenerera Àndringarna. Programmet gÄr igenom varje post och Àndrar priset sÄ att man fÄr denefter rÀtt valuta. Valutakurserna lagras i databasen.
3.9.3 Ăndrande funktioner i programmetDetta Ă€r den minsta gruppen funktioner och har gemensamt att de jobbar enbart i programmetoch inte mot databasen. Dessa smĂ„ funktioner Ă€r sĂ„dana som gör Ă€ndringar pĂ„ instĂ€llningarnaför utseendet pĂ„ programmet.
4. Implementation
NÀr man jobbar med JBuilder blir kodning och formgivning en gemensam sak dÄ man byggerupp grÀnssnittet och fÄr kod genererad. Koden skapar objekten i programmet som t.ex.knappar, menyer mm och det Àr sedan upp till programmeraren att utforma funktionerna ikoden och ge objekten funktionalitet.
4.1 AnvÀndargrÀnssnitt
Programmet som anvÀndes för utformningen av grÀnssnittet Àr det grafiska designprogrammetBorland JBuilder2005 Enterprise. Denna typ av program underlÀttar dÄ man kan brainstorma
fram idéer för ett bra anvÀndargrÀnssnitt och man slipper skriva koden för att ge sina idéerutseende.
JBuilder fungerar som ett pussel dÀr det finns ett flertal olika pusselbitar med blandadefunktioner. Man bygger upp ett grÀnssnitt med programmet, t.ex. placerar olika knappar,sÀtter ut olika fÀlt för inmatning av data eller olika typer av redovisningsfÀlt för data.Programmet skapar kod samtidigt som man bygger upp grÀnssnittet, sÄ man fÄr all grundkodav programmet. Sedan kan man utgÄ frÄn grundkoden nÀr man utformar och specificerarresten av programmet.
Grundtanken med programmet Àr att det ska vara enkelt att ta till sig och lÀtt att lÀra siganvÀnda dÄ kraven pÄ datorkunskap Àr lÄg. Kunden Horreds Möbel AB uppgav baraprogramfunktioner i kravspecifikationen och gav inga krav pÄ grÀnssnittet. DÀrför utformadesett par förslag som kunden fick ta del av och ta stÀllning till. Som underlag för utformningenav programmet anvÀndes boken GUI Bloopers av Jeff Johnson.
Det första förslaget baserades pÄ ett grundfönster med de fundamentala funktionerna, dÀr mangenom att klicka pÄ en önskad funktion öppnar ett nytt fönster för underliggande funktionero.s.v. tills man fÄr fram ett fönster med de aktuella funktioner man vill anvÀnda. Idénuppskattades inte dÄ det upplevdes för plottrigt med alla fönster, dessutom upptÀcktes det attkoden blev svÄr att hantera, alltsÄ raka motsatsen till vad som ville uppnÄs. En annan nackdelmed denna struktur skulle vara att det blir monotont och vÀldigt oflexibelt.
Förslag tvÄ innebar att forma ett program som har ett arbetsfönster som innehÄller de önskadefunktionerna. Detta Àr kanske den vanligaste lösningen i dag, vilket man ser hos en mÀngdprogram som mÄnga anvÀnder dagligen t.ex. Word och Excel. Det Àr en bra ide att formaprogrammet pÄ ett sÄdant sÀtt att det har en hög igenkÀnningsgrad, personer tar snabbare tillsig programmet och kÀnner sig tryggare enligt Jeff Johnson.
Den nya idén var som sagt att bara ha ett fönster som skulle innehÄlla grundfunktionerna ochÀven ha nÄgon typ av verktyg som gör att man kan granska och jobba med databasen. Attforma ett program Àr en vetenskap och vÀldigt svÄrt dÄ meningarna gÄr isÀr pÄ vad som Àr denbÀsta lösningen, det finns inget rÀtt eller fel utan bara olika tycke.
4.1.1 GrundfönstretNÀr man startar programmet ska man inte uppleva programmet krÄngligt och ostrukturerat.Grundfönstret bör upplevas enligt Jeff Johnson som tydligt och med ett spartanskt utseende,inte att olika komponenter Àr ihopklumpade vilket gör det svÄrt för anvÀndaren. Men det Àrsamtidigt viktigt att inte ha alla objekt rakt upp och ner för det kan motverka det logiskautseendet.
Enligt kravspecifikationen ska man genom programmet kunna jobba med artiklar i en databas,dÀrför behövdes nÄgon typ av verktyg som tydligt och enkelt redovisar innehÄllet i databasen.Java erbjuder ett par alternativ som uppfyllde behovet och valet blev att anvÀndatableScrollPanel som Àr ett listverktyg och som visas i urklippet.
4.1.2 Menyn & verktygsfÀlt
Syftet med menyer och verktygsfĂ€lt Ă€r att pĂ„ ett strukturerat sĂ€tt samla ett antal funktioner sĂ„att de Ă€r enkla att hitta nĂ€r man behöver dem. Bortsett frĂ„n standardfunktioner som attâSparaâ, âHĂ€mtaâ eller âAvslutaâ sĂ„ innehĂ„ller programmet i princip tvĂ„ olika typer avfunktionsgrupper. En grupp med funktioner som handlar om att skapa nĂ„gon typ av objektoch en grupp funktioner dĂ€r man bearbetar de olika objekten. Hur och var man placerarfunktioner Ă€r vĂ€ldigt blandat men man kan utgĂ„ frĂ„n att alla funktioner ska placeras pĂ„ ett
Illustration 1: Urklipp pÄ grundfönstret i programmet
Illustration 2: Urklipp som visarmenyraden i programmet
stÀlle dÀr det kÀnns logiskt att ha dem. De ska vara lÀtta att finna och det ordnas genom attt.ex. placera standardfunktioner dÀr de vanligtvis ligger i program som t.ex. Word.
DĂ€rför anvĂ€nds en enkel menyrad med rubrikerna âArkivâ, âInstĂ€llningarâ och âHjĂ€lpâ, somför mĂ„nga kĂ€nns bekanta dĂ„ det Ă€r samma namn som anvĂ€nds i Microsoft Office. Att anvĂ€ndadessa namn skapar en viss igenkĂ€nnande effekt och anvĂ€ndaren lĂ€r sig snabbare att anvĂ€ndaprogrammet.
Under âArkivâ placerades de fyra funktionerna âSparaâ, âHĂ€mtaâ, âFörhandsgranskningâ ochâAvslutaâ, alla fyra Ă€r vanliga funktioner som finns i de flesta program i Windows och Ă€ruteslutande placerade i âArkivâ âmenyn. Logiskt och igenkĂ€nnande vilket Ă€r signumet. Hadede lagts under en annan rubrik hade det med stor sannolikhet skapat irritation, vilket Ă€r nĂ„gotJeff Johnson varnar för i sin bok.
Samma gĂ€ller den andra rubriken, âInstĂ€llningarâ. Logiskt sett bör alla funktioner som harmed instĂ€llningar i programmet att göra och som inte Ă€r direkta eller som regelbundet anvĂ€ndsplaceras hĂ€r. AllmĂ€nt sĂ€ger man att alla funktioner ska placeras i menyerna Ă€ven om de finnspĂ„ andra stĂ€llen i programmet men det Ă€r diskutabelt. Programmet har tvĂ„ funktioner som harhand om instĂ€llningar pĂ„ programmet, âUtseendeâ och âValutakursâ.
âUtseendeâ innehĂ„ller möjligheten att Ă€ndra grundinstĂ€llningarna för hur anvĂ€ndargrĂ€nssnittetska se ut. En sĂ„dan funktion kan uppfattas som onödig dĂ„ man vid utvecklingen kommitöverens om hur grĂ€nssnittets ska formas. Men dĂ„ alla Ă€r olika och har olika tycke sĂ„ kan detvara bra att det finns en extra möjlighet att Ă€ndra text och fĂ€rger för att göra det bekvĂ€mare attanvĂ€nda programmet Ă€ven om grundinstĂ€llningen förhoppningsvis tillfredsstĂ€ller de flestaanvĂ€ndare.
Programmets verktygsfĂ€lt Ă€r rĂ€tt sĂ„ litet och innehĂ„ller bara en knapp âNyttâ som, om mantrycker in den, visar en lista med funktioner. Dessa funktioner Ă€r till för att skapa nĂ„got nyttobjekt till databasen, t.ex. en ny materialgrupp. Dessa sparas sedan och lagras sĂ„ att nĂ€r mansedan skapar ett nytt objekt sĂ„ finns de med som alternativ i comboboxar. NĂ€r man vĂ€ljer enav funktionerna sĂ„ öppnas ett temporĂ€rt fönster dĂ€r det finns olika val att fylla i, dennalösning anses som en bra lösning enligt Jeff Johnson. Att man i grundfönstret bara harfunktioner med behandlade funktionalitet.
HĂ€r visas det fönster som man fĂ„r fram nĂ€r man vill lĂ€gga in en ny produkt i databasen. Det Ă€rstrukturerat sĂ„ att fĂ€lt ligger i linje med varandra, den svarta förklarade texten Ă€r hĂ€rvĂ€nsterplacerad och avstĂ„nden mellan de olika komponenterna gör att man tydligt ser vadsom hör ihop. Valet att anvĂ€nda comboboxar till produktgrupp, materialgrupp och sprĂ„k berorpĂ„ att en ny produkt mĂ„ste tillhöra en redan befintlig produktgrupp, materialgrupp och sprĂ„k.Comboboxarna innehĂ„ller alla de grupper som finns i databasen. Knappen âSökâ som finnslĂ€ngst upp innehĂ„ller en funktion som söker igenom databasen sĂ„ att man inte kan vĂ€lja attanvĂ€nda ett redan befintligt artikelnummer. Knappen Ă€r placerad nĂ€ra textfĂ€ltet sĂ„ attanvĂ€ndaren ska förstĂ„ att den hör till just detta fĂ€lt.
4.1.3 VÀnster sidaIden med arbetsfönstret Àr att man ska kunna ha funktionerna synliga samtidigt som man kanse data man jobbar med. DÀrför föll det sig naturligt att anvÀnda ett delat arbetsfönster dÀr enadelen innehÄller funktioner och den andra delen ett fönster som redovisar olika data frÄndatabasen i en logisk tabell. Det blir lÀtt och tydligt nÀr man hela tiden kan se hur manpÄverkar databasen nÀr man jobbar med sina olika funktioner.
PÄ vÀnster sida placerades en flikmeny som innehÄller ett antal flikar med de olikafunktionerna under sig. Placeringen Àr gjord sÄ att den funktion som anvÀnds mest ligger försttill vÀnster o.s.v. Jeff Johnson skriver om hur man bör forma en flikmeny, t.ex. att inteanvÀnda för mÄnga eller att bygga dem ovan pÄ varandra dÄ det gör det rörigt och mindreanvÀndarvÀnligt. Alla funktioner som finns under flikarna Àr till för att Àndra redan inmataddata i databasen.
Att flikmenyn placerades med de olika funktionerna till vÀnster beror delvis pÄ att det Àrenklare att bygga det sÄ nÀr man anvÀnder JBuilder, men ocksÄ att det kÀnns bekvÀmt att hadet sÄ nÀr man jobbar med det. Detta kan bero pÄ att man Àr van med att börja saker frÄnvÀnster och jobba sig mot höger, t.ex. nÀr man skriver och lÀser.
Illustration 3: Urklipp som visar fönstret som kommerfram nÀr man ska skapa en ny produkt.
4.1.3.1 Flikarna
Det finns sex olika flikar som alla innehÄller i stort sett samma typer av objekt som knappar,textfÀlt, comboboxar och radioknappar. NÀr de utformades skulle de givetvis kÀnnas enklaoch tydliga. Bra tips finns i GUI Bloopers av Jeff Johnson.
Knappar ska vara i en storlek sĂ„ att de Ă€r tydliga och lĂ€tta att finna. Texten som stĂ„r i dem skaha ett tydligt budskap som inte Ă€r vilseledande som t.ex. knappen âĂndraâ som innebĂ€r attman utför en Ă€ndring av nĂ„got eller knappen âTa Bortâ som innebĂ€r att man utför en handlingsom tar bort nĂ„got frĂ„n programmet. Valet att placera knapparna lĂ€ngst ner, tĂ€tt ihop och gedem likadant utseende i varje flik underlĂ€ttar för anvĂ€ndare som ska lĂ€ra sig programmet.Knapparna placerades lĂ€ngst ner beroende pĂ„ att det Ă€r med de man ska avsluta nĂ€r man gjortnĂ„gon typ av Ă€ndring och dĂ€rför blir det naturligt för anvĂ€ndaren att blicka nerĂ„t nĂ€r man skagĂ„ vidare, som t.ex. i en bok.
Comboboxar Ă€r ett bra sĂ€tt att lösa mĂ„nga problem. I programmet lagras data pĂ„ olika möbleroch liknande saker som alla har olika attribut och som Ă€r indelade i olika grupper, t.ex.möbelgrupper eller materialgrupper. NĂ€r man har bestĂ€mda attribut pĂ„ objekt Ă€r det smidigtatt anvĂ€nda comboboxar. De fungerar sĂ„ att man fĂ„r ett textfĂ€lt med en pil vid sidan dĂ€r manfĂ„r fĂ€rdiga alternativ att vĂ€lja mellan, man kan alltsĂ„ inte skriva i dem. Man ser ett alternativoch trycker man pĂ„ pilen sĂ„ visas en lista pĂ„ de övriga som man kan vĂ€lja mellan. PĂ„ sĂ„ sĂ€ttundviker man att det skapas massa âskrĂ€pâ i databasen. En annan fördel med dem Ă€r att de Ă€rlĂ€tta att anvĂ€nda.
Radioknappar Àr bra att ha om man har ett mindre antal alternativ dÀr bara ett Àr aktivt ÄtgÄngen. Denna metod Àr tydlig, anvÀndarvÀnlig och svÄr att göra fel med. Det Àr viktigt attplacera radioknappar som hör ihop i en grupp sÄ att man inte kan misstolka vilka som Àrrelaterade till varandra.
För övrigt anvÀnds olika textfÀlt dÀr man vill att anvÀndaren ska har möjlighet att kunnaskriva in nÄgra fria ord, t.ex. en beskrivning pÄ ett objekt.
I urklippet som visar fliken âproduktgruppâ kan man se hur man generellt har utformatgrĂ€nssnittet. Svart tydlig text som förklarar vad som visas i textfĂ€ltet till höger om den, textenĂ€r ocksĂ„ vĂ€nstercentrerad. Allt ligger strukturerat sĂ„ att de flesta objekten ligger i linje medvarandra vilket föresprĂ„kas av Jeff Johnson, allt för att det ska se organiserat och proffsigt ut.Alla fĂ€lt Ă€r dimensionerade sĂ„ att de passar innehĂ„llet bra. I urklippet ser man att knapparnaligger som det beskrevs tidigare och sĂ„ som anses som en bĂ€ttre lösning.
4.1.4 Höger sida
4.1.4.1 Lista
Den högra sidan i grÀnssnittet Àr mindre komplex Àn den vÀnstra dÄ den bara bestÄr utav ettfast fönster och inte har ett skiftande utseende som flikmenyn ger. Tanken Àr att man helatiden ska kunna se och jobba med data frÄn databasen. I JBuilder finns det olika fÀrdiga list-komponenter som man har för att redovisa data pÄ ett bra och tydligt sÀtt. MÄnga anvÀndarekÀnner igen ett Excel-dokument och för att behÄlla den trygghet som mÄnga kÀnner anvÀndsen listkomponent som pÄminner mycket om ett sÄdant. Andra fördelar Àr att det fungerar braatt implementera med en databas.
För att fÄ en bra helhetssyn och möjliggöra att man kan se mÄnga olika poster samtidigtanvÀnds en stor del av fönstrets vÀnstra sida till listkomponenten.
NĂ€r man öppnar fliken âProduktâ sĂ„ kommer det upp tvĂ„ stycken listor, en för att redovisa deolika produkterna och en som innehĂ„ller beskrivningen pĂ„ produkterna. Detta för att ge entydligare bild av hur de Ă€r organiserade.
Illustration 4: Urklipp ur programmet som visarhur fliken produktgrupp ser ut.
4.1.4.2 Valutakurs
PÄ kravspecifikationen efterfrÄgas en funktion dÀr man kan stÀlla in valutakursen och pÄ sÄsÀtt fÄ priserna i olika valutor. Funktion placerades direkt i arbetsfönstret sÄ att man snabbtkan vÀxla mellan valutorna och undvika onödigt sökande i menyer. Genom att anvÀndaradioknappar uppnÄr man tydliga och enkla val av valutor. InstÀllningar av dessa gör attendast en valuta kan vara aktiv Ät gÄngen.
De Àr placerade lÀngst ner dÀr de inte Àr i vÀgen för mer regelbundet anvÀnda komponenter.Samtidigt Àr det bÀttre att placera saker som man inte ska titta pÄ sÄ ofta antingen lÄngt nereller lÄngt upp. Det Àr mest behagligt för huvudet att ha det man arbetar mest aktivt med imitten och det andra vid sidan av. Allt Àr inramat med en tydlig rubrik i ramen som förklararsyftet med knapparna. Bra avstÄnd och fet stil för att inte fÄr det rörigt och svÄrt att ta till sig.En stor knapp har lagts vid sidan av ramen dÀr man aktiverar Àndringen av valutan medförklarade och tydlig text för att göra det enkelt för anvÀndaren.
4.1.4.3 Visning
För att bestÀmma vad som ska visas i listan med produkter sÄ behövs en lÀttÄtkomlig funktioneftersom den troligen kommer anvÀndas regelbundet och för att undvika onödigt sökande imenyer. Den Àr placerad lÀngst ner i hörnet, nÀra listan för att förtydliga relationen mellandem. TvÄ radioknappar visar tydligt vilket visningslÀge som Àr aktiverat. Till den nedre finnsen tillhörande combobox som innehÄller alla olika produkter i databasen. Allt Àr inramat meden fin rubrik för att tydliggöra det hela och gör det snyggt.
4.2 Databas
Databasen som anvÀnds Àr Microsoft SQL 2000 och valet av denna databas beror pÄ attföretaget Horreds Möbel AB redan anvÀnder sig av just Microsoft SQL. Detta Àr en mycketbra databas som Àr erkÀnd och anvÀnds av stora företag över hela vÀrlden. Den Àr kraftfull ochenkel att implementera med Jbuilder2005.
4.2.1 DatabastabellernaDatabasen Àr uppdelad i sex horisontella tabeller som tillsammans handhÄller all deninformation en produkt bestÄr av. Strukturen kan man se pÄ bilaga 8.
De sex tabellerna agerar tillsammans och skapar en struktur som underlÀttar överskÄdlighetenoch gör hela databasen snabbare och mer effektiv jÀmfört med en databas uppbyggd pÄ enenda tabell. Fem av tabellerna agerar ihop genom uppbyggda relationer medan den sistatabellen som innehÄller valutakurser Àr fristÄende.
4.2.1.1 Horreds.dbo.Product
Denna tabell innehÄller kolumnerna productId(ett unikt artikelnummer), groupId(denproduktgrupp artikeln tillhör), materialId(den materialgrupp artikeln tillhör), picture(en bildpÄ artikeln) och price(artikelns pris). Denna tabellen agerar tillsammans med tabellernamaterialgrupp, produktgrupp och text. Tillsammans bildar de Horreds Möbel ABs allaprodukter.
4.2.1.2 Horreds.dbo.Productgroup
Tabellen productgroup beskriver alla de olika produktgrupperna bland Horreds Möblersartiklar. Tabellen innehÄller produktgruppens nummer, namn och en text som beskriverproduktgruppen.
4.2.1.3 Horreds.dbo.Materialgroup
Denna tabell innehÄller information om artiklarnas materialgrupper. HÀr finnsmaterialgruppernas nummer, namn och en beskrivning sparat.
4.2.1.4 Horreds.dbo.Text
I tabellen text finns beskrivningar över alla produkter pÄ alla de sprÄk Horreds Möbel AB valtatt anvÀnda sig av i sin marknadsföring. Tabellen bestÄr av artikelnummer, sprÄkkod ochbeskrivning pÄ aktuellt sprÄk. Denna tabellen agerar tillsammans med tabellerna produkt ochlanguage.
4.2.1.5 Horreds.dbo.Language
För att man pÄ ett enkelt sÀtt ska kunna lÀgga till ett nytt sprÄk finns tabellen language sombestÄr av sprÄk och sprÄkkod.
4.2.1.6 Horreds.dbo.Valutakurs
Man kan i programmet vÀxla mellan ett antal olika valutor och tabellen valutakurs innehÄllerjust alla de valutor Horreds Möbler valt att lÀgga till, och som dom anvÀnder i sinaproduktkataloger. Denna agerar fritt frÄn de andra.
4.3 Kodstruktur
Programmet Àr uppbyggt med olika klasser vilket Àr principen med Java, att allt Àrobjektorienterat. Detta programs klasser Àr strukturerade enligt det klassdiagram (bilaga 7)som formades genom UML. I en huvudklass finns funktionen Main och dÀr startar sÄledesprogrammet vid exekvering. Klassen heter Arbetsfönster och hÀr skapas strukturen ochgrafiken med alla objekt som visas i arbetsfönstret. HÀr skapas alla instanser av de andraklasserna i programmet, sÄledes sker de flesta funktionsanrop hÀr ifrÄn. Denna klass Àr denstörsta.
De övriga klasserna Àr uppbyggda pÄ tvÄ olika sÀtt. De flesta Àr formade sÄ att de genererar ettnytt fönster och innehÄller ett antal funktioner som hör till detta specifika fönster som t.ex.klassen Produkt. Dessa klasser anvÀnds i huvudsak nÀr programmet lÀgger till nÄgot nytt tilldatabasen, fast sjÀlva kommunikationen med databasen sker i en egen klass Datamodule1.Den andra typen av klass genererar inget nytt fönster utan utför bara olika operationer med sinkommunikation med databasen.
Ur den tidigare redovisningen av hur man tillÀmpar UML fick man fram olika Use Case(bilaga 4), kontrakt (bilaga 6) och ett klassdiagram. Dessa anvÀnds som beskrivits vidimplementeringen för att forma klasserna och programmet. HÀr följer en beskrivning av denkod som blev slutresultatet av detta arbete, hÀr specificerat kring klassen Produkt.
4.3.1 LÀgg till ny produkt (addProduct)Denna kod skapades för att kunna skapa en ny produkt till databasen.
//Funktionen innehĂ„ller ett antal olika variabler, alla skickas med nĂ€r man anropar funktionen.public boolean addProduct(String pId, String gId, String pict, double price, String mId, Stringla, String pText){//Ăppna dataset i databasen sĂ„ att man kan kommunicera med den
product.open();text.open();textAll.open();
//Skapar textstrÀngarString[] prodStr = {"productId"};String[] textStr = {"productId","language"};
//Skapar temporÀra dataplatser med de tvÄ textstrÀngarnaDataRow datarowProdTemp = new DataRow(product,prodStr);DataRow datarowTextTemp = new DataRow(textAll,textStr);
//Tilldelar strÀngarna det vÀrde som skickades med vid funktionsanropetdatarowProdTemp.setString("productId",pId);datarowTextTemp.setString("productId",pId);datarowTextTemp.setString("language",la);
//Kontrollerar om det finns en liknande produkt i databasen genom att jÀmföra de temporÀradatasetraderna med de tillgÀngliga. Om inte, tilldelas de olika platserna i databasen de vÀrdensom skickats med och det skapas en ny plats i databasen.
if(!product.lookup(datarowProdTemp,datarowProdTemp,8 | 32)){
DataRow datarowProd = new DataRow(product);datarowProd.setString("productId",pId);datarowProd.setString("groupId",gId);datarowProd.setString("picture",pict);//datarowProd.setInputStream("picture",pict);datarowProd.setDouble("price",price);datarowProd.setString("materialId",mId);product.addRow(datarowProd);
}
//Kontrollerar om det finns en liknande produktbeskrivning i databasen genom att jÀmföra detemporÀra datasetraderna med de tillgÀngliga. Om inte, tilldelas de olika platserna i databasende vÀrden som skickats med och det skapas en ny plats i databasen.
if(!textAll.lookup(datarowTextTemp,datarowTextTemp,8 | 32)){DataRow datarowText = new DataRow(textAll);datarowText.setString("productId",pId);datarowText.setString("language",la);datarowText.setString("text",pText);textAll.addRow(datarowText);text.refresh();
}
//Spara Àndringarna av produkt- och text-datasettenupdateProduct();product.refresh();textAll.refresh();return true;
}
4.3.2 Skapa tabellen materialgruppFunktion som stÀller en frÄga till databasen och fyller upp ett dataset som innehÄllerinformation (material-id och beskrivning av materialet) om materialgrupperna.
materialgroupAll.setQuery(new com.borland.dx.sql.dataset.QueryDescriptor( database1,"SELECT Materialgroup.materialId,Materialgroup.material FROM " +"Horreds.dbo.Materialgroup", null, true, Load.ALL));
5. Applikationens felhantering och hjÀlpinstruktioner
Varje dataprogram utsÀtts för anvÀndare med olika erfarenheter av datorprogram och som mereller mindre skapar situationer som utvecklaren inte förutsett under utvecklingen. Dessasituationer kan leda till osÀkerhet nÀr programmet ska anvÀndas eller att program lÄser sig ochviktig data eller tid kan gÄ förlorad, vilket kan bli kostsamt. En manual hjÀlper anvÀndaren sÄatt programmet anvÀnds korrekt och ett felhanteringssystem sÀkerstÀller programmetsfunktionalitet. Att motverka allt Àr svÄrt dÄ man inte kan förutse alla fel som kan uppkomma,men genom erfarenhet kan man motverka mycket.
5.1 Manualen
En manual Àr svÄr att utforma dÄ den ska vara tilltalande och enkel att förstÄ, Àven för ennybörjare. Genom att anvÀnda urklipp frÄn programmet nÀr man beskriver funktioner ansesofta som mer anvÀndarvÀnligt Àn bara text. Att en bild sÀger mer Àn tusen ord Àr ett allmÀntkÀnt uttryck. DÀrför Àr detta programs manual utformad med mÄnga förklarade bilder medtillhörande text. Manualen gÄr igenom varje funktionen med grundlÀggande stegmoment, dÀrvarje hÀndelse beskrivs med sÄ enkelt sprÄk som möjligt.
5.1 Felhanteringsfunktion
I detta program finns en felhanteringsfunktion som bygger pÄ Java-exceptions, vilket innebÀratt programmet testar (try) data som t ex en anvÀndare skrivit in, och om den skiljer sig frÄnvad som Àr tÀnkt sÄ fÄngar (catch) programmet in detta och utför en operation som kan varaatt meddela anvÀndaren med t ex ett varningsfönster som meddelar anvÀndaren att skriva inett nytt vÀrde
HÀr följer ett stycke ur programmets kod och som visar principen med felhanteringsystemet.
Funktionen tar del av en hĂ€ndelse, en âActionEventâ av hĂ€ndelsen âeâ. Programmet försökerutföra hĂ€ndelsen âeâ i âtry-blocketâ och om det inte fungerar sĂ„ skapas ett âExceptionâ âexâ
som fÄngas upp med funktionen catch som utför en del moment. Detta fall beskriver enuppdatering av valutakurs och som skapar en feltext om det uppstÄr ett fel.
public void CurDeleteBtn_actionPerformed(ActionEvent e){
try{
datamodule1.valutakurs.deleteRow();datamodule1.updateValuta();
}catch (Exception ex){datamodule1.valutakurs.refresh();jdbTable1.setDataSet(datamodule1.valutakurs);System.out.println("Valuta NOT deleted");System.err.println("Exception: " + ex);
}}
6. Problem
Enligt kravspecifikationen skulle det efterfrÄgade programmet kunna visa sÄ kallade EPS(enhanced post script)-bilder och Àven innehÄlla en funktion för att generera en fil som etttryckeri skulle kunna anvÀnda sig av i produktionen av en fysisk produktkatalog till HorredsMöbel AB.
Problemet med EPS Àr att det inte finns nÄgon fÀrdig modul i JBuilder2005 som kan hanteradetta filformat. Programmet klarar dÀremot vanliga filformat som jpeg, gif etc. DÄuppdragsgivaren inte hade bilderna av produkterna som programmet skulle hantera i nÄgot avdessa filformat sÄ fick man undersöka alternativen. En konvertering av bilderna underexekveringen kunde vara ett av dem, men skulle vara oerhört tids- och prestandakrÀvande.
NÀr databasen formats och kommit lÄngt i utvecklingen upptÀcktes en del brister som inte harÄtgÀrdats utan mer konstaterats. Dessa brister upptÀcktes vid granskandet av sprÄkval vidskapandet av nya produktgrupper och materialgrupper. Problemet innebÀr att man harmöjligheten att skapa specifika produkter med olika sprÄk men inte för de olika material- ochproduktgrupperna.
6.1 Tidsaspekten
Detta examensarbete har dragit ut pÄ tiden vÀldigt mycket och dÀrför kan man kanske vÀntasig en förklaring till detta. Problem som skapade stort tidsförluster förekom och Àr nÄgot sombör undvikas i alla projekt.
Genom möten med ansvarig projektledare lades en grund upp med en kravspecifikation somrymde tillrÀckligt med information att gÄ vidare, dock efter en hel del diskussion dÀr denprojektansvarige visade blandat intresse. Planen med att forma programmet med metoden UPtogs och arbetet med verktygen i UML började. MotgÄngar som gjorde att situationen börjadebli tidkrÀvande var ett antal olika saker. Bristande intresse frÄn arbetsgivare skapar dÄligagrunder och ökar inte arbetsinsatsen. Att det brast i drivkraft gör inte situationen bÀttre.
Avvikelser frÄn hur man arbetar med UP och dess verktyg i UML gör att det skapar fel sombildar en tidskrÀvande uppförsbacke.
7. Diskussion
7.1 Applikationens utformning och design
NÀr man formger ett programs anvÀndargrÀnssnitt sÄ finns det inga regler som sÀger vad somÀr rÀtt och fel, dÀremot finns det mÄnga dokumenterade rÄd om hur man bör formagrÀnssnittet för att det ska bli anvÀndarvÀnligt. Dessa rÄd baseras pÄ erfarenhet frÄn tidigareprogramutformningar och hur dessa har bemöts av anvÀndare. Mycket som litteraturenbeskriver Àr de utformningar dÀr den mÀnskliga uppfattningsförmÄgan spelar roll för hur mangör. Helt enkelt hur en person generellt uppfattar olika fÀrger, former och texter. I mÄnga fallbeskrivs det hur grÀnssnitt formats pÄ ett sÀtt som gör att anvÀndare fÄr svÄrt att anvÀndaprogrammet. SÄdan information Àr viktig att ha med sig nÀr man ska designa sitt grÀnssnittoch gör att man kan spara mycket tid och sÄledes Àven pengar för företaget genom att göradem nöjda snabbt. Att tÀnka pÄ Àr att varje individ Àr unik och sÄledes inte blind lita pÄlitteraturen utan som utvecklare bedöma varje detalj ur kundens synvinkel.
Litteraturen beskriver Àven utformningar som gör att program inte fungerar riktigt,beskrivningar om hur utvecklare missat en knapp eller skrivit en felaktig rubrik.GrundlÀggande fel som inte bör passera utvecklingsstadiet och som enklast upptÀcks genomatt testa programmet noga innan det levereras. Men dÄ det Àr lÀtt att stirra sig blind pÄ sinaegna saker sÄ Àr det att rekommendera att lÄta nÄgon utomstÄende testa programmet.
Den generella tanken vid utformningen av detta program var att ha ett vanligt allmÀnt anvÀndprograms grÀnssnitt som underlag, t ex Microsoft Office. Det skapar igenkÀnnande och gör attprogrammet uppfyller de rÄd som givits frÄn litteraturen som var underlag vid utvecklingen.
Specifika lösningar pÄ enskilda grafiska och/eller funktionella problem gÄr att diskutera, t exföresprÄkar man att combobox kan vara bra för att det spara utrymme och ge merprofessionellt intryck. Men att det blev radioknappar berodde mer pÄ estetiska skÀl. DetkÀndes tydligt, enkelt och snyggt. Med en mer avancerad utveckling av programmet sÄ kanman övervÀga att gÄ frÄn dessa dÄ det skulle bli platskrÀvande.
7.2 Applikationens programmeringsstruktur
Att koden har den struktur den har beror framför allt pÄ att det kÀnns mest logiskt att formaden sÄ. En grundklass som hantera det grafiska och ser till att arbetsfönstret fÄr sin strukturoch sedan ett antal klasser som hanterar de stora funktionerna. Att strukturera det sÄ hÀr gördet lÀttare för mer oerfarna programmerare att kunna överblicka och arbeta med den.
Man kan sÀkerligen göra den mycket mer komplex och effektiv, allt handlar om erfarenhet,kunskap och tid. DÄ mÄnga av funktionerna har liknande funktionalitet sÄ skulle man kanskekunna skapa mindre antal klasser som var mer mÄngsidiga. Funktioner som anvÀnds för fleraÀndamÄl. En nackdel emellertid kan vara att det uppstÄr problem sÄ kan det bli svÄrare att lösadet vilket det inte blir med mer uppdelade klasser och funktioner.
7.3 Databasens struktur
Horisontella tabeller innebÀr att tabellen har en fast mall med ett bestÀmt antal kolumner ochatt man Àr tvungen att bygga om modellen med fler kolumner om man vill lÀgga till nyaattribut. Fördelen med detta Àr att den inte tar sÄ mycket plats i minnet. En dynamisk lösningkanske kunde upplevas som överambitiöst dÄ programmet inte har flexibel data utan Àr merbestÀmd. En möbel har exempelvis ett visst antal attribut eller egenskaper.
7.4 Applikationens felhantering
Att programmet skulle ha nĂ„gon typ av felhanteringssystem Ă€r inget svĂ„rt val dĂ„ saknadenskulle vĂ„lla mycket stora risker vid anvĂ€ndandet av programmet. Minneshanteringen sköterprogramsprĂ„ket Java, sĂ„ man behöver inte tĂ€nka pĂ„ minnesallokering men kontrollen att t.ex.rĂ€tt data skrivs in i rĂ€tt fĂ€lt Ă€r viktigt dĂ„ en bokstav istĂ€llet för en siffra kan fĂ„ en algoritm attlĂ„sa sig och sĂ„ledes fĂ„ programmet att krascha. Ăven databasen skulle troligen fyllas medskrĂ€pdata som tar minne och som kan leda till framtida problem.
7.5 Applikationens hjÀlpinstruktioner
En bra manual Àr a och o för att ett program ska vara lÀtt att ta till sig för en ovan anvÀndare.Den ska innehÄlla tydliga beskrivningar om hur alla funktioner fungerar i programmet och hurman gÄr till vÀga nÀr man anvÀnder dem, helst med stegprincipen. Den bör Àven innehÄlla endel som beskriver hur man gör felsökningar nÀr man rÄkar ut för problem. Att skriva enmanual Àr svÄrt, man vill göra den enkel sÄ att alla förstÄr men samtidigt inte sÄ enkel att folkkÀnner sig stötta. SprÄket fÄr inte innehÄlla massa fackliga ord som en nybörjare inte kÀnnertill och som skapar uppgivenhet.
I dagens utvecklade IT-samhÀlle kan en pappersmanual anses bakÄtstrÀvande och nyaprogram innehÄller ofta en digital manual som aktiveras genom menyn eller nÄgotsnabbkommando. Man bör ha bÄda, dÄ anvÀndandet av en digital manual kan uppfattas somkrÄnglig. En digital manual behöver inte ha samma grundlÀggande utförande som en pÄpapper. DÄ anvÀndaren som klarar av den ofta har högre kunskap om data enpappersanvÀndare.
Till detta program finns endast en pappersmanual och dÄ anvÀndarna klassas som nybörjare Àrdetta en tillrÀcklig lösning av hjÀlpande dokument. Manual Àr uppbyggd sÄ att den stegvis gÄrigenom varje funktion med bilder och enkel text för att gör det sÄ enkelt som möjligt förlÀsaren. En digital manual bör införas i en nyare version av programvaran och det har gjortsplats för en sÄdan i programmet.
En vanligt förekommande del i en manual Àr ett kapitel dÀr man möjligen kan finna lösningenpÄ enklare fel i programmet, om det inte fungerar som det ska. Ett sÄdant kapitel finns inte dÄprogrammet Àr vÀldigt lite och dÄ inget enklare fel Àr kÀnda.
7.6 Tidsaspekten
Man kan frÄga sÀg vad som skulle ha gjort för att inte hamna i den situation som gjort attarbetet dragit ut pÄ tiden. Det Àr ingen idé att gÄ in pÄ det personliga och börja hacka utan merse helheten.
Det första misstaget som gjordes var att pÄbörja ett tidskrÀvande arbete dÄ det varken fannstid eller motivation att utföra det. Och det kan man vÀl skriva som en grundregel, att alltid hatid och drivkraft dÄ man antar en utmaning.
Att delegera ut ett arbete och sedan inte visa nÄgot större intresse för att det fullföljs Àr endÄlig kombination. Att sedan inte vara stödjande nÀr det svajar Àr lika dumt. Om företagethade visat större intresse för vad som gjordes och varit mer drivande och stödjande hade detnog aldrig gÄtt sÄ lÄngt som det gjorde. Med rÀtt stöd sÄ hade problem som fanns kunnatlösas.
Att avvika frÄn den arbetsmetod man val skapar ocksÄ problem. Att hoppa över nÄgot stegoch rusa fram med uppgiften skapar en obalans och luckor som gör det hela merarbetskrÀvande. Vid ett projekt gÀller det att tydliggöra arbetssÀtt och metoder tidigt ochsedan jobba enligt dem utan avvikelser. Hade arbetets följt UML utan avvikelser hade detförmodligen gett en struktur i projektet som gjort det hela stabilare. Orsaken till att detuppstod avvikelser beror pÄ bristande erfarenhet hur man jobbade enligt modellen och att manlÀtt undviker delar som uppfattas som trÄkiga och onödiga vilket Àr ett dÄligt antagande.
8. Slutsats
Att utveckla ett dataprogram Àr en process som krÀver bra tillvÀgagÄngssÀtt för attslutresultatet ska bli bra. RÀtt utvecklingsverktyg och program kan göra stor skillnad. UML(Unified Modeling Language) anses som ett bra verktyg och det Àr bara att hÄlla med. Att detsedan Àr lite svÄrt att tillÀmpa det Àr en annan sak, det handlar mest om erfarenhet vilket detav naturliga orsaker fanns lite av. NÀr man jobbar med UML Àr det viktigt att hela tiden görade olika stegen i den ordning som föresprÄkas. NÀr man gÄr hÀndelserna i förvÀg möter manbara en större trappa och det blir bara mer jobb. Det finns inget som sÀger att man mÄste göraalla stegen och hur man tillÀmpar dem och det Àr en avvÀgning man fÄr göra under tiden manjobbar, lite beroende pÄ jobbets storlek m.m. Men den hjÀlper en att lÀgga en bra grund för ettfint program. Allt som tas fram behövs inte anvÀndas men kan fungera som bra riktlinjervilket ocksÄ kanske Àr ett syfte.
NÀr det gÀller implementering och att jobba med JBuilder2005 och Java sÄ gav det braerfarenhet om hur de nyare grafiska programmeringsverktygen fungerar. Det Àr roligare ochenklare att hela tiden se vad man jobbar med och hur det ser ut. JBuilder2005 Àr ett trevligtoch anvÀndarvÀnligt program dÀr de fÀrdiga funktionerna som finns tillgÀngliga gör det helaenklare. Implementeringen mot databasen var inte svÄr, men nÄgot krÄnglig i början dÄerfarenheten av databaskopplingar i Java var dÄlig vilket gjorde att det ocksÄ blevtidskrÀvande. Att programmera och felsöka ett program Àr ocksÄ tidskrÀvande och svÄrt.Framför allt bugg-/felsökningen dÄ det Àr svÄrt att veta vad man ska söka efter. En del fel harupptÀckts men det Àr svÄrt att inte misstÀnka att det finns fler. Men det Àr ett problem som allautvecklare har och som bara tid och pengar kan bota. Det som upptÀcktes Àr ÄtgÀrdat ochprogrammet fungerar tillfredsstÀllande.
Att tiden varit en speciell del av detta arbete gÄr inte att förneka och att det tagit lÄng tid attfÀrdigstÀlla Àr minst sagt anmÀrkningsvÀrt. Att se till att man har tiden som krÀvs vid tillfÀlletdÄ man antar utmaningen Àr vÀldigt viktigt för att undvika samma misstag. Och samtidigtgÀller det att ha rÀtt motivation och kÀnna att man har orken, man startar inte ett projekt utanatt se möjligheten att nÄ mÄlet.
Referenslista
Skansholm, J. (2004) Java direkt - med Swing. Lund: Studentlitteratur.
Booch, G., Rumbaugh, J., Jacobson, I. (2000) The Unified Modeling Language User Guide.Addison-Wesley
Booch, G., Rumbaugh, J., Jacobson, I. (1999) The Unified Software Development Process.Addison-Wesley
Johnson, J. (2000) GUI Bloopers: Don'ts and Do's for Software Developers and WebDesigners. : Morgan Kaufmann.
Connolly, T., Begg C. (2002) Database Systems. Harlow: Pearson Education.
Ronne, E. (1999) Java. Stockholm: Docendo LĂ€romedel AB
Kursdokument om UML, kursen Mjukvarudesign (2001) Högskolan BorÄs
http://java.sun.com/javase/6/docs/api/ (2009-04-25)
Projekttitel:
Produktkatalog Horreds Möbel AB
Datum:
18/1-2009
Version:
2Författare:
Mathias Nilsson
Dokumenttitel:
Bilaga 1: Kravspecifikation
Kravspecifikation databas för prislista Horreds Möbel AB
1. Databasen skall innehÄlla alla Horreds artiklar med priser och symboler
2. Databasen skall vara enkel att uppdatera med nya produkter, bÄde text, priser ochsymboler.
3. Prislista skall finnas i flera sprÄk, idag Svenska, Danska och Engelska. Det vore bra omdet finns en funktion för att lÀgga till ytterligare sprÄk.
4. Valutahantering ska vara inbyggd, vi vill sjÀlva sÀtta valutakursen manuellt.
5. Priserna ska kunna höjas pÄ ett enkelt sÀtt med en procentsats. Det Àr en fördel om mankan höja olika produktgrupper med olika mÄnga procent. Det Àr Àven en fördel om mankan höja vissa priser manuellt.
6. Databasen ska kunna sammanstÀllas sÄ att den rent grafiskt ser ut som nuvarande prislistapÄ ett ungefÀr.
7. Prislistan ska kunna sparas i olika format, t.ex. PDF och XLS. Om ni har fler förslag pÄformat som kan vara bra sÄ Àr det vÀlkommet.
Projekttitel:
Produktkatalog Horreds Möbel AB
Datum:
18/1-2009
Version:
2Författare:
Mathias Nilsson
Dokumenttitel:
Bilaga 2: Begreppslista
Namn Beskrivning TypAktiv anvÀndare Den anvÀndare som har möjlighet att redigera databasens tabeller
AnvÀndare NÄgon som ittererar med systemet
Artikel En produkt i databasen
Artikelnummer Identifierings tal för en enskild produkt Attribut
Comboboxar BenÀmning pÄ en sk. rullgardin, vid ett knapptryck pÄ komponenten visas ett antal valmöjligheter i en lista
Databas Lagring av data i tabeller
Flikmeny En meny uppbygd av flikar för att separera olika funktionaliteter och göra grÀnssnittet anvÀndarvÀnligt
FÀrg FÀrg pÄ bakgrunden i programmet Furnie
Id-nummer En del av ett artikelnummer som betecknar en produkt- eller materialgrupp
Listverktyg Komponent som grafiskt visar en eller flera poster som finns lagrade i databasen
Möbelgrupp En samling produkter som Àr samlade under samma Id-nummer
Nyckel Identifieringsparameter för en post i en databastabell
PDF Filformat
Poster Enhet i databasen
PrimÀraktör Direkt avÀndare av programmet
Pris Prisbeskrivning av en produkt Attribut
Procentsats Ett procenttal som anvÀnds nÀr man berÀknar nya priser pÄ produkterna Attribut
Produkt En artikel i Horreds Möbels databas Klass
Produktgrupp Flera artiklar tillhörande en viss grupp produkter specificerade av Horreds Möbel AB
Radioknapp En komponent som anvÀnds vid vals ituationer dÄ anvÀndaren endast har möjlighet att göra ETT val
Redigera Programdel dÀr man hanterar olika produkter, genom att kunna Àndra de olika parametrarna i produkterna
RedovisningsfÀlt Komponent som grafiskt visar en post eller en del av en post som finns lagrade i databasen
SprÄk SprÄk pÄ textbeskrivning av en produkt i produktkatalogen
Symbol Bildobjekt som beskriver en produkts utseende Attribut
SystemanvÀndare En anvÀndare som inte har rÀtt att redigera databasens tabeller
Text Textbeskrivning av en produkt i produktkatalogen Attribut
TextfÀlt Ett fÀlt dÀr inmatning Àr möjlig
Valutahantering Hantering och val av valutakurser
Valutakurs En kurs pÄ en vald valuta Attribut
XLS Filformat
Projekttitel:
Produktkatalog Horreds Möbel AB
Datum:
18/1-2009
Version:
2Författare:
Mathias Nilsson
Dokumenttitel:
Bilaga 3: Use Case-diagram
Projekttitel:
Produktkatalog Horreds Möbel AB
Datum:
18/1 2009
Version:
3Författare:
Mathias Nilsson
Dokumenttitel:
Bilaga 4: Use Case: LĂ€gg till ny produkt
Namn: Ny produkt i databasenĂversikt: Syftet Ă€r att en anvĂ€ndare ska lĂ€gga till en ny produkt till databasen,
genom att ange pris, produktsymbol, beskrivningstext ochartikelnummer.
PrimÀraktör: Aktiv anvÀndareSekundÀraktör:UtgÄngspunkt: PrimÀrfönstret i programmet.MÀtbart slutresultat: En ny produkt har lagts till i databasen.FlödeshÀndelse:
1. VÀljer produkt i en rullgardin som visas efter att anvÀndaren trycktpÄ knappen lÀgg till.
2. Ett nytt fönster visar ett antal fÀlt dÀr de olika parametrarna fylls i.3. AnvÀdaren fyller i det nya artikelnumret och trycker pÄ sök för att
kontrollera att det aktuella numret inte redan finns.4. De resterande parametrarna fylls i.5. AnvÀndaren trycker pÄ knappen bifoga bild och vÀljer i ett
sekundĂ€rt fönster vilken bildfil man vill bifoga till produkten ochtrycker âOKâ. Det sekundĂ€ra fönstret stĂ€ngs och man Ă„terkommertill fönstret lĂ€gg till ny produkt.
6. NĂ€r allt Ă€r fĂ€rdiginmatat trycker anvĂ€ndaren pĂ„ knappen âOKâ.7. Den nya produkten lĂ€ggs till i databasen.
Avslutande del: à tergÄr till primÀrfönstret.
Alt. flödeshĂ€ndelse: 1. Trycker pĂ„ knappen âCancelâ i fönstret lĂ€gg till ny produkt.
Avslutande del: Programmet ÄtergÄr till primÀrfönstret och inga Àndrar har gjorts.
1
Projekttitel:
Produktkatalog Horreds Möbel AB
Datum:
18/1-2009
Version:
3Författare:
Mathias Nilsson
Dokumenttitel:
Bilaga 5: Systemsekvensdiagram: LĂ€gg till ny produkt
Projekttitel:
Produktkatalog Horreds Möbel AB
Datum:
18/1-2009
Version:
2Författare:
Mathias Nilsson
Dokumenttitel:
Bilaga 6: Kontrakt: LĂ€gg till ny produkt
Namn: LaggTillProdukt(string artikelNummer, string beskrivning, double pris, filesymbol)
Ansvar: Ansvarar för att lÀgga till en ny produkt i databasenTyp: voidReferens: Use Case LÀgg till ny produktNoteringar:Undantagsfall: Produkt finns redan i databasenReturvÀrde: ingetUtgÄngslÀge: AnvÀndare vill lÀgga till produktSlutlÀge: Produkt skapad i databasen
Projekttitel:
Produktkatalog Horreds Möbel AB
Datum:
5/4-2009
Version:
3Författare:
Mathias Nilsson
Dokumenttitel:
Bilaga 7: Klassdiagram/Systemarkitektur
Projekttitel:
Produktkatalog Horreds Möbel AB
Datum:
5/4-2009
Version:
2Författare:
Mathias Nilsson
Dokumenttitel:
Bilaga 8: Databasstruktur