Embed Size (px)
Citation preview
1
IDU0080 Ülesanne „OpenERP“
viimati muudetud: 03.04.2013 1. Ülevaade ülesandest. .......................................................................................................................... 2
1.1. OpenERP majandustarkvara.OpenERP installatsioon TTÜ serveris. ......................................... 4 2. Arve töövoog (workflow) OpenERP veebiliidesel. ............................................................................... 6
2.1. OpenERP-i sisselogimine. ........................................................................................................... 9 2.2. Uue kliendi sisestamine. Andmete sisestamisest OpenERP-i üldiselt....................................... 11 2.3. Uue kauba sisestamine.............................................................................................................. 13 2.4. Teeme arve ja kinnitame............................................................................................................ 15 2.5. Registreerime makseid. ............................................................................................................. 21 2.6. Anname kauba kätte. ................................................................................................................. 25
3. Lahenduse funktsionaalsus. 3 veebilehte: arve tegemine, maksmine ja kauba kätteandmine. Näiterakendused. .................................................................................................................................. 28
3.1. Esimene veebileht , „arve tegemine“. ........................................................................................ 30 3.2. Teine veebileht , „maksmine“. .................................................................................................... 40 3.3. Kolmas veebileht, „kauba väljastamine“. ................................................................................... 44 3.4. Näiterakenduste „ERP_Service“ ja „Myygimees“ ülespanemine oma arvutisse. ...................... 53
4. Lahenduse arhitektuur ja tehnoloogia. .............................................................................................. 57 5. Mis on ette antud. „OpenERPClient“ Eclipse projekti käivitamine ja kasutamine. „OpenERPClient“ meetodite selgitused.............................................................................................................................. 64
5.1. OpenERPClient meetodite käivitamine...................................................................................... 66 5.2. Kliendiga seotud meetodid......................................................................................................... 73 5.3. Toodetega seotud meetodid. ..................................................................................................... 74 5.4. Arve tegemisel kasutatavad meetodid. ...................................................................................... 74 5.5. Maksmisel kasutatavad meetodid. ............................................................................................. 74 5.6. Kauba kätteandmisel kasutatavad meetodid. ............................................................................ 75
6. Kuidas teha........................................................................................................................................ 76 6.1. OpenERPClient Eclipse projekti käivitamine ja uurimine........................................................... 76 6.2. Veebteenuse tegemine. ............................................................................................................. 77
6.2.1. OpenERPClient klassi meetodite muutmine, andmevahetus objektipõhiseks. .................. 77 6.2.2. Veebteenust realiseeriva klassi tegemine. ......................................................................... 78 6.2.3. Veebteenuse genereerimine............................................................................................... 79 6.2.4. Veebteenuse uuendamine ja teenuse uuesti genereerimine. ............................................ 87 6.2.5. Ühe või mitme veebteenuse ajutine mahavõtmine projektist. ............................................ 88
6.3. Veebirakenduse tegemine. Näide nimega „Veebitoorik“. .......................................................... 90 6.3.1. Veebilehe ja servleti tegemine. Lihtsa veebirakenduse arhitektuur. .................................. 94 6.3.2. Veebteenuse kliendiklassi tegemine ja välja kutsumine servletist. Veebteenuse kliendi emuleerimine. Veebivormidel tehtud valikute meeldejätmine varjatud väljade ja „request“-objekti abil................................................................................................................................................. 94 6.3.4. Veatöötluse lisamine kaupade kätteandmise SOAP-teenusele ja seda teenust kasutavale veebirakenduse osale. .................................................................................................................. 96
7. Nõuded lahendusele. Ärireeglid ja muud nõuded. .......................................................................... 100 8. Kaitsmine. ........................................................................................................................................ 102 9. Lisaküsimused ülesande kaitsmiseks. ............................................................................................ 103
9.1. Kas see nõutud lahendus ei ole liiga keeruline, miks nii keerulist lahendust võiks vaja minna?......................................................................................................................................................... 103 9.2. Miks ainult üks veaklass?......................................................................................................... 104 9.3. Kuhu panna kontroll? ............................................................................................................... 104 9.4. Miks me andmeid otse OpenERP-i andmebaasi ei kirjuta?..................................................... 106
10. Seosed teiste selle aine ülesannetega.......................................................................................... 106 11. OpenERP desktop (Windowsi) kliendirakenduse kasutamine. ..................................................... 107 14. Sõnastik ......................................................................................................................................... 113
2
1. Ülevaade ülesandest. Ülesande eesmärgiks ja oodatavaks tulemuseks on realiseerida veebirakendus mis võimaldab teha järgmisi tegevusi: Arve tegemine - kliendi otsing - kaupade otsing ja kauba väljavalimine arve koostamiseks - kauba koguse sisestamine ja muutmine arve vormi peal - arve salvestamine
Arve maksmine - arve otsing arve numbri järgi - arve maksmise registreerimine (olemuselt nagu sularahamakse kassasse) - arvet võidakse maksta osade kaupa (alguses makstakse mingi summa , siis järgmine
summa jne.) - on registreeritud maksmisi selle summa ulatuses mis oli arvel kauba hind siis peab arve
staatuseks saama „makstud“ („paid“). Kauba väljastamine - arve otsing arve numbri järgi (ostja ütleb müüjale arve numbri) - arvel oleva kauba väljastamise registreerimine koos võimalusega sisestada laost
väljaantava kauba kogust Selle ülesande kontekst on umbes selline et meil on tegemist poega kuhu saabub ostja kes tahab midagi osta. Müüja registreerib arve pannes arve peale kliendi (kelle ta otsib süsteemist juba olemasolevate klientide seast) ja kauba (mille ta otsib juba olemasolevate kaupade seast). Siis tuleb klient rahaga (võib-olla maksab kohe arve tegemisel või tuleb hiljem poest läbi kui on ATM-ist raha võtnud), müüja registreerib raha maksmise kassasse. Ostja võib raha tuua mitu korda. Kui ostja on piisavalt maksnud (makstud summa = arve summa) siis saab arve staatuseks „paid“ (seda teeb OpenERP juba ise, automaatselt kui arveid ja makseid õigesti registreerida) ja müüja võib kauba ostjale laost välja anda (oletame et ladu on seal samas poe tagaruumis). Laost väljaandmisel ütleb ostja arve numbri, müüja vaatab kas arve on makstud ja kas laos kaupa on ja annab kauba välja ning registreerib kauba väljaandmise (paneb arve märkustesse kirja et kaup on käes). Nende toimingute läbiviimiseks peab veebirakendus võtma ühendust veebteenustega mis tuleb ka selle ülesande lahendamise käigus ise teha. Veebteenused omakorda võtavad ühendust üle XML-RPC liidese OpenERP majandustarkvaraga.
3
Joonisel jämedama joonega osad on olemas , peenema joonega komponendid tuleb selle ülesande käigus ise teha. Veebirakenduse ja SOAP teenuste osad tehke eraldi tarkvaraprojektidena (ehk siis eraldi Eclipse projektidena). Veebirakenduse osa võib soovi korral teha Java asemele ka mõnes muus programmeerimisekeeles.
veebirakendus
arve tegemine
maksmine
kauba kätteandmine
SOAP teenused
OpenERPClient (etteantud koodi tuleb täiendada)
OpenERP
http://193.40.244.170:1158/
193.40.244.170:1099 SOAP
XML-RPC
4
1.1. OpenERP majandustarkvara.OpenERP installatsioon TTÜ serveris. OpenERP on vabatarkvaraline ERP-tarkvara (Enterprise Resource Planning), meie ülesande kontekstis põhimõtteliselt majandustarkvara. Koduleht openerp.com OpenERP tarkvara viimane versioon on OpenERP 7. Meie TTÜ serveris kasutame versiooni nr. 6, selle põhjuseks on desktop kliendi (Windowsi kliendirakenduse olemasolu) mida 7. versioonis enam ei ole. Serveril koosneb OpenERP tarkvara installatsioon kahest osast – OpenERP andmebaasirakendus ja OpenERP veebirakendus. OpenERP andmebaasirakendus on veebirakenduse osale kättesaadav üle XML-RPC veebteenuste. Põhimõtteliselt on nii OpenERP enda veebirakendus, OpenERP Windows kliendirakendus ja teie tehtud lahendus OpenERP serveri kliendid mis suhtlevad OpenERP serveriga üle sama XML-RPC liidese. OpenERP serveriosa on kirjutatud Pythonis. OpenERP serveri ja klienditarkvara võib tausta nende kodulehelt alla laadida ja oma arvutisse installeerida kuid selle ülesande tegemiseks ei ole see otseselt vajalik, saab kasutada TTÜ
OpenERP server OpenERP web server (veebirakendus) PostgreSQL
OpenERP veebiliides brauseris
OpenERP desktop klient (Windows)
Teie lahendus
OpenERPClient (tuleb täiendada)
XML-RPC XML-RPC
XML-RPC
193.40.244.170:1099
http://193.40.244.170:1158/
openerp_eng
openerp_est
openerp_rus
5
serveri OpenERP installatsiooni. Töö kaitsmisel peab teie lahenduse see osa mis on ühendatud OpenERP serveriga (ehk siis veebteenuste osa) nagunii olema ühendatud TTÜ OpenERP serveriga.
6
2. Arve töövoog (workflow) OpenERP veebiliidesel. Enne kui vaatame lähemalt seda mida teie lahendus peaks täpselt tegema vaatame kuidas käib arve töövoog OpenERP-i enda veebirakenduses. Arve tegemine.
arve rea lisamine
„draft“
kliendi otsing ja väljavalimine
kauba otsing ja väljavalimine
raamatupidamis-žurnaali valik (vaikimisi valik jätta alles)
konto valik
arve valideerimine
kauba koguse sisestamine
tegevused arve seisundid
arve salvestamine
„open“
algseisund
viib seisundisse
arvega seotud raamatupidamise deebetkande tegemine (teeb OpenERP automaatselt peale arve valideerimist)
7
Arve maksmine.
arve otsing ja väljavalimine (teie teete)
makse registreerimine (teie teete), makse meetodiks „Cash Journal – (test)“
arve maksmata summa vähendamine ja arve ära-maksmise kontroll (nii-öelda arve „matchimine“ laekumistega). (teeb OpenERP automaatselt peale igat maksmise registreerimist)
maksega seotud raamatupidamise kreedit-kande tegemine (teeb OpenERP automaatselt peale igat maksmise registreerimist)
arve seisundid tegevused
„open“
kas arve on makstud?
jah ei
tuleb veel maksta
8
Kauba kätteandmine.
arve otsing ja väljavalimine
kauba väljandmise tingimuste kontroll (kas arve on makstud, kas välja antav kogus sobib arvega, kas kaupa laos on, ega kaup ei ole selle arve alusel juba välja antud ) – (teie teete)
„KAUP KAES“ (arve „notes“ väljas)
välja antava kauba koguse sisestamine
kauba väljaandmise registeerimine
selgituseks: tegelikult ei ole OpenERP-is võimalik arvele panna seisundit „Kaup käes“. Kasutame kauba kättandmise märkimiseks arve „notes“ (ehk siis märkuste) välja.
arve seisundid tegevused
9
Arve seisundid kokkuvõtlikult.
2.1. OpenERP-i sisselogimine. Ärge kasutage Internet Explorerit. Põhimõtteliselt küll töötab aga mõned funktsioonid ei paista alati toimivat – näiteks uue kliendi sisestamisel maa (country) valik. Läheme aadressile http://193.40.244.170:1158/ ja näeme järgmist vormil.
„KAUP KAES“ (arve „notes“ väljas)
„draft“
„open“
„paid“
OpenERP viib, peale arve valideerimist
OpenERP viib, peale arve valideerimist
ise märgime arve märkustesse et kaup on käes
OpenERP-i poolt antud algne seisund
10
Valime andmebaasiks „openerp_eng“ (või „openerp_est“ või „openerp_rus“ – kellele mis keel rohkem meeldib). Iga andmebaas on nagu eraldi ettevõte oma infosüsteemiga selles OpenERP serveris. NB! Kui te valite mingi andmebaasi ja hakkate seda kasutama oma lahenduse tegemisel siis arvestage et ka teie OpenERP klient peab käima sama nimega andmebaasi küljes. Vaikimisi on etteantud OpenERPClient-i java lähtekoodis andmebaasiks „openerp_eng“, kui kasutate teist andmebaasi siis peate koodis andmebaasi nime muutma. Kui te seda ei tee siis te OpenERP-i enda veebiliideselt vaatate ühe ettevõtte andmebaasi aga oma lahendus koos oma veebiliidesega on ühendatud teise ettevõtte andmebaasi külge kus on teised andmed. Valige andmebaas, sisestage kasutajanimeks „admin“ ja parooliks valitud andmebaasi nimi (antud juhul siis „openerp_eng“)
11
2.2. Uue kliendi sisestamine. Andmete sisestamisest OpenERP-i üldiselt. Sisestame ühe kliendi kellele hiljem hakkame arveid tegema (ehk siis kes käib meie juures poes kaupa ostmas). Soovitav on igal kasutajal või rühmal sisestada mingi hulk oma kliente ja kaupu mida siis hakatakse hiljem kasutama lahenduse tegemisel. Siis on hea kohe OpenERP-i liidesel endale vajalikud kliendid ja kaubad välja otsida et vaadata nendega seotud arveid, maksmisi ja kauba väljaandmisi. Võib teha näiteks nii: rühm nimega „ryhm233“ sisestab OpenERP-i kliendi nimega „ryhm233_klient“ ja kaubad nimega „ryhm233_kaup1“ ja „ryhm233_kaup2“. Selliste nimedega andmete sisestamine ei ole siiski kohustuslik, võite sisestada ka nn. „normaalsete“ nimedega andmeid. Oluline on see et te need andmed lihtsalt OpenERP-ist üles leiate sest peate arvestama et samasse OpenERP serverisse sisestavad andmeid ka kõik teised rühmad nii et kui sinna tekib palju formaadis nimega „Aaa1“ siis muutub andmetes orienteerumine üsna raskeks. Läheme „Accounting“ -> „Customers“
12
Vajutame „New“.
1.
2.
3.
13
Sisestage kliendile ka mõned aadressi andmed ja telefon. Salvestame.
2.3. Uue kauba sisestamine „Sales“ -> „Products“ -> „New“
14
Märgime kindlasti ära (see on Vaikimisi valitud ka) et „Can be Sold“ sest just müük on see mida me selle kaubaga nüüd tegema hakkame. Müügihinna võiks ka suuremaks panna kui ostuhinna, muidu kaupleme kahjudega. Salvestame. Nüüd uuendame laoseisu ka ja paneme sinna mingi suurema arvu. Katsetades oma lahendust peame ilmselt palju kordi registreerima kauba laost väljaandmist, iga väljaandmisega väheneb kogus laos ja me ehk ei taha et laoseis miinusesse jääks.
15
2.4. Teeme arve ja kinnitame. „Accounting“ -> „Customer Invoices“ -> „New“
„Journal“ peaks kindlasti olema „Sales Journal (test““ nagu on ka vaikimisi ette antud. Kontoks („Account“) valime „X11002 Debtors – (test)“. Arve väljastamisel hakkame nüüd ootama selle tasumist. Eesti keeles oleks selle konto nimi ehk konto “Nõuded ostjate vastu”.
16
Otsime arvele kliendi:
Lisame nüüd arvele ühe rea ehk ühe kauba. Teie lahendus peab võimaldama teha arveid milles on üks rida ehk ainult üks kaup – et oleks lihtsam. Sellepärast paneme ka siin arve peale ainult ühe kauba .
17
Otsime arve rea vormil toote (võtame selleks eelmises punktis sisestatud „Rootormootori“). Eraldi otsinguvormi ei ole vaja avada, trükime toote nime alguse kohe toote nime väljale:
„Save & Close“
18
Arve kuupäevaks võime panna tänase kuupäeva. Salvestame.
19
Ja kinnitame kohe ka arve ära. „Validate“. Nüüd on arve seisundis „open“ ehk siis ootab maksmist. Infosüsteemides kaasnevad paljude tegevustega (kaupade ostmine, arvete tegemine, arvete maksmine, sularahaarveldused kassas jne.) raamatupidamise kanded, nii ka siin. Vaatame selle valideeritud (ehk kinnitatud) arvega seotud raamatupidamiskande deebet ja kreeditkirjeid. „Accounting“ -> „Journal Entries“ – „Journal Entries“. Näeme nüüd raamatupidamiskannete all viimasena meie arvega seotud kannet (kui keegi TTÜ OpenERP serveri sama andmebaasi kasutajatest ei ole muidugi jõudnud vahepeal uut arvet valideerida). Näeme siin ka oma arve numbrit.
20
Nende raamatupidamiskannete infot meil otseselt selles ülesandes midagi teha ei ole, lihtsalt informatsiooniks. Vaatame sinna kannete alla uuesti kui oleme arve ära maksnud.
21
2.5. Registreerime makseid. Teeme nii et maksame arvet mitu korda, esimesel maksmisel ei maksa täis-summat. Nii peab saama teha ka teie veebirakenduses. „Accounting“ -> „Customers“ -> Customer Payment“ -> „New“ OpenERP-i terminoloogias on makse „voucher“. Valime kõigepealt kliendi ja kohe peale kliendi valikut ilmub makse reale meie maksmata arve info (millega me müüsime ühe rootormootori hinnaga 300.00). Neid makse ridu võib juurde lisada aga seda meil vaja teha ei ole, automaatselt openERP-i poolt etteantud makse rida on sobiv. Küll aga muudame makse summat – 300.00 euro asemele (arve summa) maksame ainult 200.00.
Makse meetodiks („Payment Method“) valige kindlasti „Cash Journal – (test)“ – muidu võite saada järgmise veateate:
22
Valideerime.
Ilmub ka makse number, selle järgi saame otsida kui vaja – „CHS/2013/093“. Vaatame nüüd arve „SAJ/2013/056“ infot – et kas on makstud.
23
Ei ole kahjuks – „RESIDUAL“ (ehk arve summa ja makstud summa vahe ) on 100.00. Veel on vaja 100.00 eurot maksta. Maksame.
„OPEN BALANCE“ näitab meie summat mida on vaja maksta (kuipalju arvest on veel maksmata jäänud). Maksamegi siis niipalju et saaks selle asja korda lõpuks. Vaatame nüüd uuesti arve „SAJ/2013/056“ andmeid. Seis on nüüd parem – näeme et arve on makstud:
Vaatame nüüd raamatupidamiskandeid ka ,ehk on ka seal mingeid muutusi toimunud.
24
Näeme et müügi-žurnaalis on üks kanne SAJ2013056 (see mis ilmus arve kinnitamisel) ja kassa-žurnaalis („Cash Journal) on kaks kannet CSH2013093 ja CSH2013094. Vaatame viimase maksmise kande sisse:
„RECONCILE“ on OpenERP-i sisemine identifikaator mille alusel märgitakse arveid ja maksmisi kokku (nn. „matchimine“ arvete ja laekumiste vahel). Näeme et arve kandel on sama „reconcile“ identifikaator.
25
2.6. Anname kauba kätte. „Warehouse“ -> „Product Moves“ -> „Deliver Products“ -> „New“ Vaatame arve pealt mis kaupa me müüsime (teie veebirakenduses peabki kauba kätteandmisel olema esimeseks tegevuseks arve numbri järgi otsimine ja arve andmete näitamine et väljaandja teaks mis kaupa ta peab välja andma). Praegu on meil meeles et müüsime ühe rootormootori kliendile „Eesti Kaubamüük“. Otsime rootormootorit. Valime kõigepealt kauba, vaatame paljus seda kaupa laos on (praegu 200):
26
Valime lao kust kaupa võtame:
27
Vajutame „Process now“ ja registreerime sellega kauba väljaandmise.
Siiski ei ole kõik veel tehtud. Peame otsima üles arve „SAJ/2013/056“ ja kirjutama selle arve märkuste välja et „KAUP KAES“ (või mis iganes muu fraas mis teie lahenduses märgib seda et selle arve alusel on kaup välja antud).
Vajutame „Edit“ ja kirjutame „Other Info“ -> „Additional Information“ sõnad „KAUP KAES“.
28
Kui teie oma veebirakenduses teete kauba väljaandmist siis peab teie veebteenus vaatama arve andmetest selle välja sisu ja kui seal on kirjas et „KAUP KAES“ siis ei tohi kaupa enam teist korda selle arve alusel välja anda. veebteenusel tuleb veebirakendusele väljastada veateade mida see veebirakendus siis omakorda kasutajale näitab.
3. Lahenduse funktsionaalsus. 3 veebilehte: arve tegemine, maksmine ja kauba kätteandmine. Näiterakendused. Kuidas see lahendus mis te selles ülesandes teete peaks töötama seda näitavad rakendused mis töötavad aadressil imbi.ld.ttu.ee:7500 Aadressil http://imbi.ld.ttu.ee:7500/ERP_Service/services on näha SOAP-teenuste rakenduse „ERP_Service“ veebteenused. See on siis veebteenuste osa teie lahendusest mille teine poolt on läbi teie poolt täiendatud OpenERPClient klassi ühenduses OpenERP-iga.
29
Aadressil http://imbi.ld.ttu.ee:7500/MyygiMees/ on näha veebirakenduse osa teie lahendusest mis on eraldi Java veebirakendus (on tehtud eraldi Eclipse projektina). Mõlemad rakendused on kompileeritud kujul war-failidena kättesaadavad aadressilt http://maurus.ttu.ee/idu0080/OpenERP/war/ nii et soovijad võivad need installeerida oma arvutisse Tomcat-i alla.
30
Te peaksite tegema 3 veebilehte millel on võimalik teha järgmisi tegevusi:
3.1. Esimene veebileht , „arve tegemine“. 1. kliendi otsing , kui leitakse otsingu tulemusel üks klient siis valitakse ta automaatselt välja arve tegemiseks. 2. kauba otsing ja väljavalimine. 3. Kui klient on arve jaoks leitud ja kaup on ka välja valitud siis arve vormi kuvamine. Arve vorm näitab poolelioleva, alles loomisel oleva arve andmeid: kes on klient, mis on kaup. 4. Arve vormil peab olema võimalik muuta kauba kogust ja seda kogust veebirakenduse mällu salvestada (nupp „uuenda kogust“) 5. Kui kauba kogust on uuendatud ja see kogus on suurem kui 0 (ja klient ning loomulikult kaup on ka arvel olemas) siis peab ilmuma arve vormile nupp „Tee arve“ (või „Kinnita arve“ või ükskõik milline fraas teile meeldib). Kui kasutaja sellele „Tee arve“ nupule vajutab siis võtab teie veebirakendus ühendust teie SOAP-teenusega mis omakorda võtab ühendust OpenERP-iga üle XML-RPC kutsudes välja OpenERP-i arve tegemise ja kinnitamise teenuseid. OpenERP tagastab uue arve tegemisel arve numbri, see tuleks läbi SOAP-teenuse saata tagasi veebirakendusse ja kuvada kasutajale et ta teaks mille järgi arvet otsida kui ta hakkab makseid registreerima.
arve tegemine.
klientide ja kaupade sisestamine (otse OpenERP-is)
arve maksmine
kauba väljaandmine
vahepealsete ja lõpptulemuste vaatamine (otse OpenERP-ist)
teie tehtud veebirakendus
teie tehtud SOAP-teenuste rakendus
OpenERP
OpenERPClient
peaaegu olemas. aga tuleb muuta, täiendada
SOAP
XML-RPC
31
Joonis „Arve tegemise jadadiagramm“. See mis toimub peale nupulevajutust rakenduse tagumises osas (SOAP-teenus ja OpenERP) on mõnevõrra keerukam kui esialgu tundub. Aga siiski mitte midagi keerukat tegelikult. SOAP-teenus mis võtab vastu veebirakenduse soovi teha uut arvet kutsub välja OpenERPClient klassi meetodi createInvoice() – selle meetodi olete te eelnevalt objektorienteeritud rakendusele sobivaks täiendanud. createInvoice() meetod võtab üle XML-RPC ühendust OpenERP serveriga kutsudes välja uue arve lisamise funktsiooni. OpenERP tagastab sisestatud arve täisarvulise identifikaatori invoice_id (int). Nüüd kutsub createInvoice() välja OpenERP-i arve ridade lisamise funktsiooni (sest arve ridades on kirjas see info mida osteti , kui palju ja mis hinnaga). Vaata lähemalt selle kohta OpenERPClient.createInvoiceLine() meetodist. Kolmandaks peab SOAP-teenus välja kutsuma OpenERP-i arve andmete lugemise funktsiooni, vaata OpenERPClient.readInvoice() – selleks et invoice_id abil kätte saada lisatud arve numbrit (invoice_id ei ole arve number, arve number on kujul „SAJ/2013/056“). Kui arve number on OpenERP-ist kätte saadud siis võib SOAP-teenus veebirakenduse tulemuse tagasi saata, selleks tulemuseks ongi arve number, näiteks „SAJ/2013/056“.
teie veebirakendus teie SOAP-teenus OpenERP etteantud ja muudetud OpenERPClient klass
createInvoice() openerp: create invoice
openerp: create invoice line
openerp: invoice id
openerp: create invoice line
readInvoice(id)
openerp: read invoice
inserted invoice data, incl. invoice number (as string) invoice number
invoice number
invoiceservice. create_invoice()
vajutab nuppu „Tee arve“
32
Vaatame kuidas kõik see toimib näiterakenduses. http://imbi.ld.ttu.ee:7500/MyygiMees/index.html
Uue arve vormi meil praegu ees ei ole sest meil ei ole valitud klienti ega kaupa. Otsime kõigepealt kliendi – sisestame otsingusse sellise nime mille puhul teame et tulemusi tuleb ainult üks. Kui tulemusi tuleb rohkem kui üks siis annab
33
OpenERPClient.searchCustomer() tulemuseks viimase otsingutulemustes olnud kliendi. (Teeme selles ülesandes sellise lihtsustuse et me ei tee veebirakendusel klientide otsingutulemuste näitamist ja nendest soovitud kliendi väljavalimust, saame nii natuke lihtsamalt läbi. sellepärast ka meetodi OpenERPClient.searchCustomer() selline võib-olla mitte kõige korrektsem käitumine.) Otsisime nime järgi „Eesti“ (juhendi kirjutamise ajal oli andmebaasis „openerp_eng“ ainult üks sõnaga „Eesti“ algav klient). Leitakse klient „Eesti Kaubamüük“ ja pannakse see kohe tekkima hakkavale arve vormile.
Otsime kaupa ka. Kauba otsingutulemusi tuleb nüüd (erinevalt kliendi otsingust) näidata kasutajale valikuna. Kliendiotsingul pani veebirakendus leitud kliendi kohe arve vormile, kaupa peab saama valida. Otsime näiteks kaupa milles sisaldub „hdd“.
34
On näha et veebirakendus tõesti selliseid kaupu leiab ja näitab. Ka OpenERP näitab sama:
35
Ei taha siiski praegu arvele kõvakettaid vaid enda sisestatud „rootormootorit“. Otsin uuesti (pöörake tähelepanu et toodetega seotud tegevusi tehes 8toote otsing ja väljavalimine) jäävad muud andmed veebilehele alles – ehk siis poolik arve vorm ja arvele valitud klient).
Valin „rootormootori“ arve peale. Nüüd on klient ja kaup valitud ja arve vorm võib meile näidata koguse uuendamise tekstivälja.
36
Panen koguseks 1 ja vajutan „Uuenda kogust“. Veebirakendus uuendab nüüd ka arve summat (kauba id on teada , selle järgi saab OpenERP-ist küsida kauba andmeid, sealhulgas hinda ja seda hinda arve vormi peal näidata).
37
Kõik andmed arve tegemiseks on sisestatud . Arve et ole veel OpenERP-i jõudnud, tulevase arve andmed on praegu veel ainult veebirakenduse mälus. Saadame arve OpenERP-i. Nüüd käivitubki stsenaarium mida kirjeldab joonis „Arve tegemise jadadiagramm“.
38
Arve on tehtud ja OpenERP süsteemis. Kopeerime selle arve numbri nüüd endale kuhugi tekstifaili – selle numbri järgi arvet otsides algavad tegevused maksmise ja kauba kättetoimetamise veebilehtedel.
39
Vaatame kas OpenERP-is ka selline arve on (peab olema sest veebirakenduse ja SOAP-teenusel mingit oma andmebaasi ei ole – kõik andmed mida veebirakendus näitab tulevad OpenERP-ist).
meelde
40
Tõesti, sellist arvet , staatusega „open“, me ka OpenERP-is näeme:
3.2. Teine veebileht , „maksmine“.
41
Ilmub arve otsimise lahter ja otsingu käivitamise nupp. Siin tuleb jälle arvestada et OpenERPClient.searchInvoice() otsib nii et kui otsingutulemusi on rohkem kui 1 siis antakse tulemuseks viimane arve mis otsingutulemustes on. Seega sisestame täpse arve numbri. Veebirakendus võtab ühendust SOAP-teenusega, see kutsub välja OpenERPClient.
searchInvoiceByNumber() meetodi, searchInvoiceByNumber() tagastab arve numbri järgi leitud arve.
42
Maksame. Aga vähem kui arve summa. Maksame näiteks 150.00
43
On näha et arve seisund on endiselt „open“, OpenERP ei ole seda muutnud. Peale maksmist OpenERP-i tehtud arve päring toob välja ka muutunud „residual“ välja sisu (see on arve põhiandmetes OpenERP-is, maksmata summa) milleks on 150. Maksame siis veel 150.
Nüüd näeme et arve seisundiks on „paid“. Ilus oleks sellise arve puhul mis on makstud mitte enam näidata nuppu „Maksan“. Nagu näete siis on näiterakenduses see tegemata jäänud. Teie lahenduses see ka kohustuslik ei ole. On jäänud veel viimane tegevus: arve alusel kauba väljastamine laost.
44
3.3. Kolmas veebileht, „kauba väljastamine“.
Jällegi kutsume välja kõigepealt arve teenust et otsida üles arve mille alusel hakkame kaupa väljastama.
Näeme et arve on makstud , kaup aga kätte andmata (arve märkuste väljas ei ole „KAUP KAES“ sõnu).
45
Sisestame väljaantava kauba koguse. Aga sisestame selle koguse suurema kui on arve peal. SOAP-teenus peab nüüd kontrollima kas väljaantava kauba kogus vastab arve peal olnud kauba kogusele ja kui see nii ei ole siis tuleb tagastada mingi veakood ja veasõnum. Kauba väljaandmine (delivery) tuleb muidugi jätta OpenERP-is registreerimata.
46
Sisestame nüüd õige arvu (1).
47
Veebteenus tagastab „delivery_id“, see on int-tüüpi kirje identifikaator OpenERP-is. Otseselt selle id järgi OpenERP-ist väljaandmisi otsida ei saa ja ei ole vajagi. Vaatame siiski OpenERP-ist järele kas meie kauba väljastamine seal ikka kirjas on:
48
Hoolika otsimise korral võib URL-i parameetrites näha „delivery_id“ väärtust.
Võtame uuesti ette kauba kättetoimetamise vormi ja proovime sama arve alusel uuesti kaupa välja anda:
49
Veebteenus peab nüüd (pöördudes selleks muidugi jälle OpenERP-i arve andmete järele) kontrollima ega selle arve alusel ei ole kaup juba välja antud. Kuna märkuste väljal on kirjas „KAUP KAES“ (või mis iganes kokkuleppeline sõna või fraas mida teie lahendus kasutab) siis ei tohi selle arve alusel kaupa enam väljastada.
50
SOAP-teenus peab kauba väljastamisel kontrollima ka seda kas arve on makstud. Teeme ühe maksmata arve ja proovime selle alusel kaupa väljastada.
51
Teeme nüüd arve millega ostame mingit kaupa 2 tükki mida on laos ainult 1 tk. Maksame ära ka.
Hakkame nüüd kaupa välja andma. teie lahenduse veebteenus peab kontrollima kauba arvu laos ja kui kaupa on vähem kui klient soovib kätte saada siis tuleks kuvada veateade (saata SOAP-teenuselt veebirakendusele ja veebirakendus siis kuvab seda).
ainult 1 on laos
52
Kauba väljastamisega laost lõpeb meie (st. ka teie) veebirakenduse funktsionaalsus. Meie töö on tehtud. Võime minna puhkama.
tahame rohkem kaupa välja anda/ saada kui laos on
53
3.4. Näiterakenduste „ERP_Service“ ja „Myygimees“ ülespanemine oma arvutisse. Teil on võimalik imbi.ld.ttu.ee serveris olevad veebirakendused laadida ka oma arvutisse. Selleks et vaadata kuidas näide töötab ei ole teil seda vaja teha (vähemalt seni kuni näited serveril imbi.ld.ttu.ee:7500 töökorras on.). Igal juhul on nad (kompileeritud ja war-failiks kokkupakitud kujul selle ülesande /war kataloogis üleval. http://maurus.ttu.ee/idu0080/OpenERP/war/
Installeerimise eeldused: - teil on olemas oma arvutisse installeeritud Apache Tomcat. Kui seda ei ole siis on see tarkvara kättesaadav aadressilt http://tomcat.apache.org/ (Võtke Windowsi 64-bit Windows Service Installer-versioon). Installeerimine. 1. Kopeerige war-failid teie arvuti Tomcat-i webapps-kataloogi ja käivitage Tomcat.
54
Tomcat pakib nüüd rakendused lahti ja paneb tööle.
55
Kui te tahate et teie arvuti MyygiMees-näite-veebirakendus võtaks ühendust teie arvuti ERP_Service SOAP-teenustega (mitte imbi.ld.ttu.ee serveri ERP_Service teenustega) siis muutke veebirakenduste konfiguratsioonifaili:
Kirjutage sinna faili „localhost“ ja oma Tomcat-i pordi number (vaikimisi 8080). tehke rakendusele (või Tomcat-ile) restart.
56
Vaatame nüüd mis me aadressil http://localhost:8080 näeme: http://localhost:8080/ERP_Service/services
http://localhost:8080/MyygiMees/invoice
57
Tuttav pilt.
4. Lahenduse arhitektuur ja tehnoloogia. teie lahendus koosneb kahest rakendusest mis on tehtud eraldi projektidena (Eclipse või mõne muu tarkvaraarenduskeskkonna mõttes projektidena): SOAP-teenuse projekt Veebirakenduse projekt
SOAP-teenus Veebirakendus
OpenERP
OpenERPClient (OpenERP Java XML-RPC kliendi kood) – tuleb täiendada
arve tegemine
maksmine
kauba väljastamine
veebteenuseid realiseerivad klassid
Eclipsega genereeritud veebteenused
SOAP XML-RPC
andmeklassid (Customer, invoice,..)
58
Joonisel on punktiiriga joonistatud see osa mida te peate ise tegema ja pideva joonega see mis on valmis ja ette antud. Kui võtta paari lausega kokku see mida te peate selles ülesandes tegema siis võiks seda öelda nii: 1. Teete uue Eclipse projekti ja kopeerite „OpenERPClient“ klassid sellesse projekti. „OpenERPClient“ sisaldab koodi (meetodeid) mis on vajalikud OpenERP-i serveriga üle XML-RPC liidese ühenduse võtmiseks. „OpenERPClient“ sisaldab kõiki meetodeid mis on vajalikud selleks et te saaksite teha sellise funktsionaalsusega süsteemi nagu selles ülesandes on nõutud. „OpenERPClient“ Eclipse projekt on kättesaadav aadressilt http://maurus.ttu.ee/idu0080/OpenERP/src/
2. Täiendate „OpenERPClient“-klassi meetodeid nii et need sobiksid teie rakenduses kasutamiseks. Asi on selles et näiteks OpenERP serverilt andmeid saavad meetodid ei tagasta neid andmed andmeobjektidena (näiteks (Customer, Invoice, Product, Delivery) vaid trükivad OpenERP-ist saadud andmed konsoolile välja. Nüüd trükib näiteks meetod readCustomer(int customer_id) „Customer“-objekti tagastamise asemel kliendi andmed konsoolile välja:
59
int readCustomer(int customer_id) { // customer.setId(customer_id); // customer.setName((String)cdata.get("name")); System.out.println("name: "+ (String)cdata.get("name")); }
Rakenduse andmeklasside tegemine on osa rakenduse tegemise tööst ja selle töö peate te ise ära tegema ja vastavalt sellele ka muutma „OpenERPClient“ klassi meetodite väljundeid ja mõnikord ka sisendeid. Näiteks: algne meetod: public int createInvoice(int customer_id, String product_name,int product_id, Double price, Double quantity)
täiendatud: public Invoice createInvoice(Customer customer, String note,Product product, Double price, Double quantity)
Kuidas te peaksite „OpenERPClient“ klassi meetodeid muutma nii et nad teie SOAP-teenuse rakenduses oleksid kasutatavad – see ei ole ette kirjutatud, ise otsustate. Olgu siin siiski näiteks toodud töötava näitelahenduse SOAP-teenuste osa „OpenERPClient“ klassi meetodite signatuurid:
60
----------------töötavas näites olevad OpenERPClient klassi meetodid-------------- public int confirmProductDelivery(int delivery_id) public Invoice createInvoice(Customer customer, String note,Product product, Double price, Double quantity) public InvoiceLine createInvoiceLine(int invoice_id,String note, int product_id, Double price, Double quantity, String name) public int createVoucher(int customer_id,String invoice_name, String amount, int invoice_id, int move_line_id) public int createVoucherLine(int voucher_id, String amount,int customer_id, int invoice_id,int move_line_id) public Customer readCustomer(int customer_id) public Invoice readInvoice(int invoice_id) public InvoiceLine readInvoiceLine(int line_id) public int readInvoiceMoveLineId(int invoice_id) public int readMove_line_id(String move_id) public Product readProduct(int product_id) public void readProducts(List<Integer> products) public Voucher readVoucher(int voucher_id) public int registerProductDelivery(int product_id, Double product_qty,String product_name, int partner_id) public int searchCustomer(String customer_name) public int searchInvoiceByNumber(String invoice_number) public List<Integer> searchProducts(String name) public int validateInvoice(int invoice_id) public int validatePayment(int voucher_id) public int writeInvoiceComment(int invoice_id,String comment)
------------------------------------------------------------------------------------------------------------ Kuidas see OpenERPClient klassi meetodite täiendamine võiks välja näha selle kohta on selles teile antud koodis ka näide.
61
Vaadake meetodeid public int readPurchaseOrder(int id)
ja public PurchaseOrder readPurchaseOrderStudent(int id)
ning andmeklassi PurchaseOrder. („Purchase Order“ on ostutellimus OpenERP-is, seda teil selles ülesandes kasutada ei ole vaja, seepärast ongi seda ostutellimuse meetodit siin näitena kasutatud).
Meetod readPurchaseOrder() on samas stiilis nagu teised teile antud meetodid OpenERPClient klassis – trükib saadud andmed konsoolile. ------------------readPurchaseOrder()----------------- public int readPurchaseOrder(int id) { Object [] params; int ret_id=0 ; String name=""; String state=""; String date_order=""; String notes=""; try { Object r[]=new Object[7]; r[0]=client_tinydb; r[1]=(Integer)client_id; r[2]=client_password; r[3]="purchase.order"; r[4]="read"; Object p_orders_ids[]=new Object[1]; p_orders_ids[0]=id; Object[] p_order_fields = { "name", "date_order","state","notes" }; r[5] = p_orders_ids; r[6] = p_order_fields; Object[] ids ; HashMap<String,Object> cdata; ids=(Object[]) XmLRpcOpenERPClient.execute("execute", r);
62
cdata = (HashMap<String,Object>) ids[0]; name = (String) cdata.get("name"); date_order = (String) cdata.get("date_order"); state = (String) cdata.get("state"); notes = (String) cdata.get("notes"); System.out.println("----------purchase_order----------"); System.out.println("name:" + name); System.out.println("date_order:" + date_order); System.out.println("state:" + state); System.out.println("notes:" + notes); System.out.println("-------------------------"); return id; } catch (XmlRpcException e) {... } catch (Exception e) { ... } }
------------------------------------------------------------- Selle meetodi sobivamaks muutmiseks teeme kõigepealt andmeklassi PurchaseOrder: ----------------PurchaseOrder------------------------------ package idu0080.openerp.data; public class PurchaseOrder { int id; String name=""; String state=""; String date_order=""; String notes=""; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getState() { return state; } public void setState(String state) { this.state = state; } public String getDate_order() { return date_order;
63
} public void setDate_order(String date_order) { this.date_order = date_order; } public String getNotes() { return notes; } public void setNotes(String notes) { this.notes = notes; } }
----------------------------------------------------------------- Nüüd teeme muudetud versiooni meetodist readPurchaseOrder mis tagastab väljakutsujale PurchaseOrder-tüüpi objekti: ---------------------------- public PurchaseOrder readPurchaseOrderStudent(int id) { Object [] params; int ret_id=0 ; String name=""; String state=""; String date_order=""; String notes=""; PurchaseOrder purchase_order=null; try { ....algus on sama mis readPurchaseOrder() meetodil..... ids=(Object[]) XmLRpcOpenERPClient.execute("execute", r); cdata = (HashMap<String,Object>) ids[0]; name = (String) cdata.get("name"); date_order = (String) cdata.get("date_order"); state = (String) cdata.get("state"); notes = (String) cdata.get("notes"); // Nii on tehtud teile antud OpenERP kliendikoodis - ei tagasta midagi, trükib ainult välja. // System.out.println("----------purchase_order----------"); //System.out.println("name:" + name); //System.out.println("date_order:" + date_order); //System.out.println("state:" + state); //System.out.println("notes:" + notes); //System.out.println("-------------------------"); // Nii peaksite tegema teie - tagastab ostutellimuse objekti purchase_order = new PurchaseOrder(); purchase_order.setId(id); purchase_order.setDate_order(date_order); purchase_order.setName(name); purchase_order.setNotes(notes);
64
purchase_order.setState(state); return purchase_order; } catch (XmlRpcException e) { System.out.println("purchaseOrder: XmlException Error while logging to OpenERP: "+e); return purchase_order; } catch (Exception e) { System.out.println("purchaseOrder error: "+e); return purchase_order; } }
--------------------------------------------------------------------------------------------------------- Nüüd peaks olema aru saadav mida on mõeldud selle all et teile etteantud OpenERPClient-klassi meetodeid tuleks muuta. Kui selles osas jääb midagi arusaamatuks siis küsige kindlasti õppejõult üle. Olgu siinkohal ka näitena toodud andmeklasside paketi sisu mis on töötavas näites (seda klasside nimekirja te saate vaadata ka siis kui vaatate lahtipakitud war-faili, ERP_Service.war).
Pakettide, meetodite, klasside nimed , meetodite argumentide nimed, tüübid ja järjekord on teie vabal valikul, neid ei pea tegema täpselt nii nagu siin näites näha on.
5. Mis on ette antud. „OpenERPClient“ Eclipse projekti käivitamine ja kasutamine. „OpenERPClient“ meetodite selgitused. Ette on antud Eclipse projektina „OpenERPClient“ klass mis sisaldab meetodeid mis on vajalikud OpenERP-serveriga suhtlemiseks XML-RPC vahendusel. Te võite teha ka SOAP-
65
teenuste projekti eraldi ja lihtsalt kopeerida „OpenERPClient“ projektist klassid oma SOAP-teenuse projekti. Oluline on siinkohal teada et „OpenERPClient“ kasutab OpenERP serveriga ühendusepidamiseks Apache XML-RPC teeke mis on kättesaadavad aadressil http://ws.apache.org/xmlrpc/ Need Apache XML-RPC teegid peavad olema teie SOAP-teenuse rakenduse /lib kataloogis. „OpenERPClient“ projektis ei ole veebirakendus, ta on käsurealt käivitatav rakendus ja XML-RPC teegid on projekti lülitatud Eclipse abil:
Kui te tahate käivitada „OpenERPClient“ klassi meetodeid siis te peate importima „OpenERPClient“ projekti Eclipse’i, tõmbama aadressilt http://ws.apache.org/xmlrpc/ XML-RPC teegid ja lisama nad projekti teekide hulka („Build Path..“)
Siis tekib teil Eclipse all samasugune teekide loetelu nagu pildil.
66
Vaata ka http://doc.openerp.com/v6.1/developer/12_api.html#java
5.1. OpenERPClient meetodite käivitamine. Kui olete XML-RPC teegid „OpenERPClient“ projekti seadistanud nii nagu eelmises punktis kirjas siis võite Eclipse’s käivitada OpenERP meetodite väljakutseid. Selleks on tehtud mõned main()-meetodeid sisaldavad abistavad klassid mida saab otse Eclipse’s käivitada. runPurchaseOrder käivitab eelpool viidatud readPurchaseOrder() ja readPurchaseOrderStudent() meetodeid: -------------------------------------------------------------------------------------------------------- public static void main(String[] args) { OpenERPClient client = new OpenERPClient("openerp_eng","admin","openerp_eng","193.40.244.170",1099); client.getDatabaseList(); int id = client.Connect(); client.XmLRpcOpenERPClient = client.getOpenERPClient(); System.out.println("connected user id:" + Integer.toString(id)); // Ostutellimuse otsing int[] order_ids=client.searchPurchaseOrder("PO00002"); int i; for(i=0; i<order_ids.length; i++) { client.readPurchaseOrder(order_ids[i]); PurchaseOrder po = client.readPurchaseOrderStudent(order_ids[i]); System.out.println("PurachaseObject.getId():" + po.getId()); System.out.println("PurachaseObject.getName():" + po.getName()); System.out.println("PurachaseObject.getDate_order():" + po.getDate_order()); System.out.println("PurachaseObject.getNotes():" + po.getNotes()); System.out.println("PurachaseObject.getState():" + po.getState()); } }
---------------------------------------------------------------------------------------------------------
67
Kui teil see käivitamine õnnestub siis see tähendab seda et teie Eclipse alt käivitatud rakendus (antud juhul OpenERPClient) pääseb üle võrgu OpenERP serverile ligi ja saab sealt andmeid.
68
Purchase Order meid edaspidi siiski eriti ei huvita, seda ei ole meil vaja oma ülesandes kasutada. Käivitame klassi ReadOnly. Selle klassi käivitamisel OpenERP-i andmeid ei lisata ega andmeid ei muudeta, tehakse ainult päringuid. ----------------------------------------------------------------------- public class ReadOnly { /** * @param args */ public static void main(String[] args) { OpenERPClient client = new OpenERPClient("openerp_eng","admin","openerp_eng","193.40.244.170",1099); client.getDatabaseList(); int id = client.Connect(); client.XmLRpcOpenERPClient = client.getOpenERPClient(); System.out.println("connected user id:" + Integer.toString(id)); // Toote otsing client.readProducts(client.searchProducts("HD")); // Arve andmete lugemine arve id järgi // Kliendi otsing. Anda ette selline olemasolev kliendi (tapne) nimi mis annab ainult yhe kliendi vastuseks. int customer_id = client.searchCustomer("Syleam"); // Trykib kliendi andmed konsoolile client.readCustomer(customer_id); int invoice_id = client.searchInvoiceByNumber("SAJ/2013/018"); System.out.println("invoice_id:" + invoice_id); // arve andmete lugemine arve id järgi client.readInvoice(invoice_id); } }
--------------------------------------------------------------------------
69
Olulisemad ja teie jaoks kasulikumad OpenERPClient klassi meetodite väljakutsed on klassis InvoiceWorkFlow. Nagu klassi nimigi ütleb tehakse selle klassi käivitamisel läbi kogu töövoog mida teie peate realiseerima veebirakenduse ja SOAP-teenuse kombinatsiooniga. ------------------------------------------------------------------------------------------ package idu0080.openerp.client; .... public class InvoiceWorkFlow { public static void main(String[] args) { OpenERPClient client = new OpenERPClient("openerp_eng","admin","openerp_eng","193.40.244.170",1099); client.Connect(); System.out.println("user id" + Integer.toString(client.client_id)); client.XmLRpcOpenERPClient = client.getOpenERPClient();
70
// ----------KLIENDI OTSING JA ANDMETE LUGEMINE------------- int customer_id = client.searchCustomer("Agrolait"); client.readCustomer(customer_id); //---------TOOTE OTSING JA ESIMESE TOOTE VÄLJAVALIMINE------------ int product_id = client.getFirstProductId(client.searchProducts("HD")); String productName = client.readProduct(product_id); //----------------------ARVE TEGEMINE-------------------------- Double price=900.0; Double invoice_product_qty=1.0; int invoice_id = client.createInvoice(customer_id,productName,product_id,price,invoice_product_qty); client.validateInvoice(invoice_id); // ----------MAKSMINE------------- String amount = "900"; int move_line_id = client.readInvoiceMoveLineId(invoice_id); String invoice_number=client.readInvoice(invoice_id); int voucher_id = client.createVoucher(customer_id,invoice_number,amount,invoice_id,move_line_id); client.validatePayment(voucher_id); //------KAUBA VÄLJAANDMINE---------- Double delivery_product_qty=1.0; client.registerProductDelivery(product_id, delivery_product_qty,productName,customer_id); client.writeInvoiceComment(invoice_id, "KAUP KAES"); System.out.println("ARVE, MAKSE ja KAUBA KÄTTEANDMINE LAOST tehtud."); System.out.println("ARVE NUMBER OLI:"+invoice_number); // workflow lopp, arve on makstud }
} -------------------------------------------------------------------------------------------- Võite selle InvoiceWorkFlow lähtekoodi muuta muutes otsitavate klientide ja toode nimesid , arve ja makse summasid. Peale käivitamist võite vaadata/otsida kas selle käivitamise tulemused OpenERP-ist ka leitavad on. Müüme ühe rootormootori hinnaga 450.00 kliendile nimega „Eric Dubois“ aga maksame selle eest ainult 300.00. Anname selle arve alusel siiski kauba laost välja ka (maksmata arve kontrolli peab tegema teie kirjutatud SOAP-teenus teie lahenduses, OpenERPClient meetodid sisendandmete vastavust ärireeglitele ei kontrolli).
olemasoleva kliendi nimi
selline nime algus et leitaks vähemalt 1 sellise nimega toode
teie lahenduses võetakse toote hind siia, praegu peame ette andma suvalise summa
71
----------------------------------
----------------------------------
72
Otsime arve SAJ/2013/059 OpenERP-ist ka üles:
73
Näeme et 150.00 on arvest veel maksmata. client.writeInvoiceComment(invoice_id, "KAUP KAES") meetod on siiski oma töö teinud:
OpenERPClient meetodite kohta on täiendavaid selgitusi ka meetodite lähtekoodis kommentaaridena. seega : kui te tahate teada kuidas teie SOAP-teenus peaks OpenERP serveriga suhtlema siis hakake uurima kuidas töötab ja mida kutsutakse välja InvoiceWorkFlow.main() meetodis.
5.2. Kliendiga seotud meetodid. public int searchCustomer(String customer_name) – kliendi otsing nime järgi. Tagastab viimase leitud kliendi id (seega tuleks argumendiks anda selline nimi mis toobki ainult ühe kliendi tulemuseks.) public int readCustomer(int customer_id) – kliendi andmete lugemine kliendi id järgi.
74
5.3. Toodetega seotud meetodid. public List<Integer> searchProducts(String name) – toodete otsing. Tagastab leitud toodete openERP-i identifikaatoreid sisaldava massiivi. public String readProduct(int product_id) – ühe toote andmete lugemine id järgi.
5.4. Arve tegemisel kasutatavad meetodid. public int searchInvoiceByNumber(String invoice_number) – arve otsimiseks arve numbri järgi. public String readInvoice(int invoice_id) – arve andmete lugemiseks arve id järgi. Kutsub omakorda välja meetodit readInvoiceLine(int line_id) arve ridade lugemiseks. public int readInvoiceLine(int line_id) – arve ridade lugemine. public int createInvoice(int customer_id, String product_name,int product_id, Double price,
Double quantity) – arve loomine. Kutsub välja meetodit createInvoiceLine() arve rea loomiseks. public int createInvoiceLine(int invoice_id,String note, int product_id, Double price, Double
quantity, String name) – arve rea loomine. public int validateInvoice(int invoice_id) – arve kinnitamine (kutsutakse välja kohe peale arve loomist, siis kui invoice_id on teada)
5.5. Maksmisel kasutatavad meetodid. public int searchInvoiceByNumber(String invoice_number) – arve otsimiseks arve numbri järgi. public String readInvoice(int invoice_id) – arve andmete lugemiseks arve id järgi. Kutsub omakorda välja meetodit readInvoiceLine(int line_id) arve ridade lugemiseks. public int readInvoiceMoveLineId(int invoice_id) – ühe vajaliku identifikaatori („move_line_id“) saamine mida on vaja kasutada makse tegemiseks et „matchiks“ makse kokku makstava arvega. public int createVoucher(int customer_id,String invoice_name, String amount, int invoice_id,
int move_line_id) – makse (voucher) registreerimine OpenERP-is. public int validatePayment(int voucher_id) – makse valideerimine, tehakse kohe peale makse loomist. public int readVoucher(int voucher_id) – makse andmete lugemine OpenERP-ist et peale makse tegemist saaks kasutajale veebilehel näidata tehtud makse numbrit.
75
---------------------töötava näite maksmise SOAP teenuse realisatsiooni klassi kood--------- public String makePayment( String invoice_number, int customer_id, Double payd_amount ) { String payment_number=""; Voucher voucher=null; Invoice invoice=null; int invoice_id ; invoice_id = client.searchInvoiceByNumber(invoice_number); invoice = client.readInvoice(invoice_id); int move_line_id = client.readInvoiceMoveLineId(invoice.getId()); int voucher_id = client.createVoucher(customer_id,invoice_number,Double.toString(payd_amount),invoice.getId(),move_line_id); client.validatePayment(voucher_id); voucher = client.readVoucher(voucher_id); payment_number = voucher.getNumber(); return payment_number; }
--------------------------------------------------------------------------------------------------------------
5.6. Kauba kätteandmisel kasutatavad meetodid. public int searchInvoiceByNumber(String invoice_number) – arve otsimiseks arve numbri järgi. public String readInvoice(int invoice_id) – arve andmete lugemiseks arve id järgi. Kutsub omakorda välja meetodit readInvoiceLine(int line_id) arve ridade lugemiseks. Kauba väljaandmisel on vaja veebilehel näidata arve andmeid ja väljaandmise registreerimise kontrollida kauba väljastamise andmete arve andmetega – kas arve on makstud, kas kaup on välja andmata, kas väljaantava kauba kogus vastab arvel olnud kauba kogusele. public String readProduct(int product_id) – toote andmete lugemine (sealhulgas selleks et kontrollida laoseisu). public int registerProductDelivery(int product_id, Double product_qty,String product_name, int
partner_id) – kauba väljaandmise registreerimine OpenERP-is (kui arve andmed, toote laoandmed ja väljastatava kauba kogus läbivad kontrolli). public int writeInvoiceComment(int invoice_id,String comment) – arve kommentaaridesse „KAUP KAES“ kirjutamine.
76
6. Kuidas teha. soovitatav tööde järjekord:
1. uus „Dynamic Web Project“ veebteenuste jaoks. 2. „OpenERPClient“ klass ja Apache XML-RPC teegid uude projekti. 3. „OpenERPClient“ klassi meetodite täiendamine. Nende meetodite testimine, otse
käivitamine Eclipsest. 4. Veebteenust realiseeriva („Impl“) klassi kirjutamine. Selle meetodi testimine, otse
käivitamine Eclipsest. 5. Veebteenuse genereerimine Eclipses. 6. Veebteenuse testimine (SoapUI või genereerite veebteenusele Java kliendi ja käivitate
seda).
6.1. OpenERPClient Eclipse projekti käivitamine ja uurimine. Importige Eclipse projekt „OpenERPClient“ oma Eclipse workspace’i ja uurige seda. http://maurus.ttu.ee/idu0080/OpenERP/src/ Vaadake kuidas selles projektis InvoiceWorkFlow main()-meetodis käiakse läbi kogu arve töövoog ja kutsutakse selle töövoo käigus välja klassi OpenERPClient meetodeid. Muutke InvoiceWorkFlow main() meetodis lähteandmeid endale sobivamaks ja käivitage see meetod (Run As Java Application). Vaadake OpenERP-ist mis andmed sinna tekivad. Kui java rakendusel tekivad probleemid TTÜ OpenERP serveriga ühendumisel kontrollige aadressil http://193.40.244.170:1158/ kas TTÜ OpenERP server ikka on kättesaadav. Kui ei ole võtke ühendust aadressil [email protected].
---------------------InvoiceWorkFlow.main()------------------------ //---------KLIENDI OTSING------------ int customer_id = client.searchCustomer("Eric Dubois"); client.readCustomer(customer_id); //---------TOOTE OTSING JA ESIMESE TOOTE VÄLJAVALIMINE------------ int product_id = client.getFirstProductId(client.searchProducts("rootor")); String productName = client.readProduct(product_id);
-----------------------------------------------------------------------------
siia mõne OpenERP-is oleva oma kliendi nimi
siia mõne OpenERP-is oleva oma toote nimi
77
Kui InvoiceWorkFlow.main() meetod töötab andmed OpenERP-i tekivad siis tähendab et teie Eclipses käivitatud Java rakendusel on ühendus serveriga ja teie käsutuses on toimib kood selle serveriga suhtlemiseks ja kõigi arvetega seotud tegevuste tegemiseks. Võite alustada veebteenuste osa tegemist.
6.2. Veebteenuse tegemine. Töötava veebteenuse näide on aadressil http://imbi.ld.ttu.ee:7500/ERP_Service/services Kompileeritud kujul (war-failina) on seesama teenuste rakendus kättesaadav aadressilt http://maurus.ttu.ee/idu0080/OpenERP/war/ Tehke uus Eclipse projekt, selle projektiga te teete valmis veebteenuste osa. Kopeerige selle projekti alla klass „OpenERPClient“ ja lisage projekti teekide (libs) hulka ka Apache XML-RPC teegid. Projekti tüübiks valige „Dynamic Web Application“ kuna tegemist on veebteenuste projektiga.
6.2.1. OpenERPClient klassi meetodite muutmine, andmevahetus objektipõhiseks. Järgmise tegevusena (enne kui hakkate kirjutama veebteenust realiseerivat klassi) on teil vaja muuta „OpenERPClient“ klassi meetodid teie veebteenuste rakenduses kasutatavaks sest need meetodid praegu ei toimi päris nii nagu teil vaja oleks – näiteks andmete tagastamise asemel trükivad nad neid andmeid System.out.println() abil konsoolile välja. Muutke OpenERPClient meetodeid nii nagu on kirjeldatud punktis „4. Lahenduse arhitektuur ja tehnoloogia“. Esimeseks tegevuseks selles osas on teil ilmselt andmeklasside loomine:
78
Neid andmeklasse hakkavad teie poolt täiendatud OpenERPClient klassi meetodid kasutama andmete tagastamisel ja mõnikord ka argumentidena. Vt lk. 59 seda millised võiksid olla muudetud meetodite signatuurid ja tagastatavad tüübid. Kui olete OpenERPClient klassi meetodid ümber kirjutanud siis proovige kindlasti ka kuidas nad töötavad. Võite kopeerida InvoiceWorkFlow klassi ka oma veebteenuste rakendusse ja seda nii muuta et ta kutsub välja nüüd juba teie poolt muudetud OpenERPClient klassi meetodeid. Soovitus: ärge proovige kohe kõiki meetodeid ümber kirjutada. Alustage lihtsamast (näiteks kliendi otsing searchCustomer() ja kliendi andmete lugemine readCustomer() ning kui need valmis on siis proovige neid kohe ka käivitada. Võite kasutada InvoiceWorkFlow main()-meetodit käivitamiseks kui olete enne nende meetodite väljakutsed mida te käivitada ei taha välja kommenteerinud (ajutiselt).
6.2.2. Veebteenust realiseeriva klassi tegemine. Kui need muudetud OpenERPClient meetodid töötavad mis on vajalikud ühe veebteenuse tegemiseks (kõige lihtsamad veebteenused on „customerservice“ ja „productservice“ mis m kasutavad ainult paari OpenERPClient-i meetodit, nendest on mõistlik alustada) siis tuleks kirjutada veebteenust realiseeriv klass. Teeme selleks eraldi paketi kuhu alla hakkame tegema teenuste realisatsioone.
kommenteerime kõik alumised väljakutsed välja ajutiselt
79
Nagu näete sisaldab näiteks „customerservice“ ainult ühte meetodit – searchCustomerByName(name). OpenERP-i veebteenuste puhul on kliendi otsing ja kliendi andmete lugemine eraldi – selleks et klienti otsida välja kutsuda eraldi teenus (mida teeb siin client.searchCustomer()) ja leitud klientide andmete lugemiseks tuleb kliendipõhiselt kutsuda välja kliendi andmete lugemise teenus (client.readCustomer(id)). Meie oma veebteenuses sellist eraldamist vaja ei ole – me tahame veebteenuselt otsingu tulemusena kätte saada kohe kliendi andmeid. Oleme valmis saanud teenuse „customerservice“ realisatsiooni ja oleme valmis Eclipse abil veebteenuse genereerimiseks.
6.2.3. Veebteenuse genereerimine. Veebteenuseid olete te eelmistes ülesannetes juba piisavalt Eclipse abil genereerinud, antud ülesandes toimub kõik nii nagu eelmistes ülesannetes.
80
81
82
83
84
85
Laske oma veebteenuste rakendus serveril käima.
86
(Soovitav on „runtime“-na kasutada Tomcat 7 mitte „J2EE Preview“-d.) Läheme rakenduse aadressile oma koduarvutis (rakenduse nimele lisaks + „services“). http://localhost:8080/ERP_Service/services
Seda teenust on nüüd lihtne näiteks SoapUI-ga testida.
87
6.2.4. Veebteenuse uuendamine ja teenuse uuesti genereerimine. Ilmselt on teil vaja mõnikord veebteenuse realisatsiooni uuendada – mida siis teha? Sellisel juhul ei ole tavaolukorras vaja midagi kustutada (kui veebteenust realiseeriva klassi nimi ei muutu). Tuleb lihtsalt veebteenus uuesti genereerida nii nagu eelmises punktis. Kui siiski selgub et asjad ei tööta nii nagu peaks võib veebteenuse genereerimise tulemused ka projekti alt kustutada et alustada nii-öelda „puhtalt lehelt“. Kuidas seda teha vaadake järgmisest punktist. NB ! Ärge unustage et kui olete veebteenuse alusel juba genereerinud ka veebteenuse kliendi (mis peaks teil asuma teises projektis – veebirakenduse projektis) siis peate selle kliendi ka uuesti genereerima.
88
6.2.5. Ühe või mitme veebteenuse ajutine mahavõtmine projektist. Kui soovite mingil põhjusel mõne veebteenuse ajutiselt projekti alt maha võtta (näiteks rakendus ei tule üles selletõttu et mingi viga on seotud mõne veebteenusega ) siis peaksite tegema nii: 1. kustutate veebteenuse genereerimisel tehtud klassid. 2. kustutate veebteenuse wsdl-i. 3. kustutate beans.xml-failist veebteenuse definitsiooni 4. kustutate veebteenuse realisatsiooniklassist veebteenuse annotatsiooni mille generaator sinna lisas. Genereeritud veebteenuse klasside kustutamine.
Genereeritud wsdl-failide kustutamine
89
beans.xml failis muudatuste tegemine
NB! Kui olete faili beans.xml redigeerimise lõpetanud siis pange see fail Eclipses kindlasti kinni. Vastasel korral võib Eclipse teinekord selle faili ära rikkuda kui hakkab uuesti veebteenuseid genereerima.
see osa maha
90
Genereeritud java annotatsiooni mahavõtmine veebteenuse realisatsiooni klassist.
6.3. Veebirakenduse tegemine. Näide nimega „Veebitoorik“. Töötava veebirakenduse näide on aadressil http://imbi.ld.ttu.ee:7500/MyygiMees/ Kompileeritud kujul (war-failina) on seesama rakendus kättesaadav aadressilt http://maurus.ttu.ee/idu0080/OpenERP/war/ Lähtekoodina (Eclipse projekt) on üks veebirakenduse näide millest võiks tegemist alustada aadressil http://maurus.ttu.ee/idu0080/OpenERP/src/ „VeebiToorik.zip“. Töötaval kujul on seesama VeebiToorik üleval aadressil
see rida maha
91
valin toote
92
Mis teile sellest „toorikust“ kasu on ? Selles toorikus on alustatud järjekorras esimese, arve tegemise veebilehe tegemist. Sellest näitest te näete kuidas - toimub kliendi otsing - kaupade otsing - kauba väljavalimine otsingutulemuste hulgast - otsitud kliendi ning väljavalitud kauba meelespidamine - esialgse (küll pooliku) arve tegemise vormi genereerimine kui klient on otsitud ja kaup on välja valitud. See väike rakendus toimib järgmisel põhimõttel:
invoice.jsp InvoiceServlet doGet() doPost()
HTTP GET
HTTP POST
response HTML
„request“ ServiceClientNotReallySOAP
SOAPServiceClient
teie kirjutate. võtab üendust genereeritud SOAP kliendi vahendusel veebteenustega
genereeritud SOAP klient
93
1. Milles lingile http://imbi.ld.ttu.ee:7500/VeebiToorik/invoice.jsp avaneb arve tegemise
veebileht mille genereerib serveril invoice.jsp. 2. veebilehelt tulnud pöördumisi töötleb InvoiceServlet . 3. InvoiceServlet kutsub pöördumise teenindamiseks välja veebteenuste kliendi
„ServiceClientNotReallySOAP“ meetodeid. Nagu klassi nimigi ütleb ei võta see selle klassi meetodid tegelikult ühegi veebteenusega ühendust vaid ainult emuleerivad veebteenuste kliendi tööd.
4. Kui andmed teenuse kliendilt on kätte saadud siis laeb InvoiceServlet uuesti lehe
invoice.jsp (forward()-meetodiga) andes sellele lehele „request“-objekti sees (request.settAttribute()) edasi vajalikud andmed mida lehe peal peaks näitama.
Seega on arve tegemise jaoks vaja:
- üks veebileht invoice.jsp - üks servlet mis töötleb kõiki kasutajapoolt sellel veebilehelt (õigemini invoice.jsp poolt
genereeritud veebilehelt) tehtud pöördumisi. - veebteenuse kliendiklass mis kutsub välja Eclipsega genereeritud SOAP-teenuse
kliendiklasse. Sellist lahendust on kasutatud ka lahenduses „MyygiMees“. Soovitus: tehke veebirakendus hästi lihtsa arhitektuuriga. Keeruliste disainimustrite ja veebiraamistike uurimisega poleks siin vaja tegeleda, lihtsal JSP + servlet + teenuse klient kombinatsiooniga saab need kolm veebilehte selles ülesandes hästi ja lihtsalt tehtud. Te võite selles ülesandes veebirakendust tegelikult teha suvalisel platvormil ja suvalises programmeerimiskeeles ja sellise arhitektuuriga nagu teile meeldib. Allpool punktis 6.3.1. ja näites „VeebiToorik“ on toodud soovitatav lahendus sellepärast et te ei raiskaks aega väga keeruliste lahenduste väljamõtlemiseks vaid võtaksite kasutusele lihtsaima skeemi ja kulutaksite veebirakenduse osa tegemisele minimaalselt aega.
94
6.3.1. Veebilehe ja servleti tegemine. Lihtsa veebirakenduse arhitektuur. Sellel joonisel on skeem mis näitab lahenduse „MyygiMees“ sisemist struktuuri. Iga veebilehe jaoks on oma servlet mis töötleb sellelt veebilehelt laekunud HTTP-pöördumisi ja kui töötlemine on tehtud siis laadib sama veebilehe uuesti kliendile tagasi. Andmete edastamiseks veebilehele kasutab servlet „request“ objekti millest veebilehel on lihtne andeid kätte saada et HTML-i genereerida.
6.3.2. Veebteenuse kliendiklassi tegemine ja välja kutsumine servletist. Veebteenuse kliendi emuleerimine. Veebivormidel tehtud valikute meeldejätmine varjatud väljade ja „request“-objekti abil. Enne veebteenuse kliendiklassi tegemist tuleb veebirakenduse osasse teha andmeklassid (üsna sarnane selle samasuguse tegevusega veebteenuste osas). Mõelge läbi milliseid andmeid teil on vaja veebirakenduses kasutada et kasutajale andmeid näidata ja milliseid andmeid on teil vaja ühendusepidamiseks SOAP-teenustega. Selle läbimõeldud info põhjal tehke oma veebirakenduse „data“ pakett ja sinna andmeklassid.
Võrrelge veebirakenduse andmestruktuure veebteenuse andmestruktuuridega (vt. näide üleval veebteenuste punktis). Näete et veebirakenduse osas on meil andmemudel oluliselt lihtsam, ei
invoice.jsp
payment.jsp
delivery.jsp
InvoiceServlet
PaymentServlet
DeliveryServlet
SOAPClient genereeritud SOAP-kliendi klassid
SOAP teenus (teisest projektist)
95
ole vaja kõiki andmestruktuure mis meil on vaja veebteenuse osas OpenERP-iga suhtlemiseks. Veebirakenduse jaoks vajaliku SOAP-kliendi klassi saate nüüd valmis kirjutada ilma et teie veebirakendusel tegelikult SOAP-teenusega veel mingit ühendust oleks. public class SOAPClient { public Product SearchProduct(String product_name) { Product product = null; product = new Product(1,"HDD3","HDD Seagate 7200.8 120GB",100.0); return product; } public Customer SearchCustomer(String customer_name) { Customer customer = null; customer = new Customer(1,"Axelor"); return customer; } } Soovitus: veebirakendus ongi võimalik nii peaaegu valmis teha (või vähemalt 80% temast) nii et reaalsel SOAP-teenusega ühendust ei võeta ja SOAP-klienti ei genereerita. Kui valmib reaalne SOAP-teenus ja saab klienti genereerida siis saab klassis SOAPClient meetodi SearchProduct() sisu asendada reaalse SOAP-teenuse väljakutsega. Kuidas kasutada „request“ objekti servletist andmete edasiandmiseks JSP lehele ja kuidas kasutaja poolt veebilehel tehtud valikuid meelde jätta ja kasutada serveril – selle kohta peaks andma infot näide „VeebiToorik“. 6.3.3. SOAP-teenuse kliendi genereerimine ja veebteenuse kliendiklassi täiendamine genereeritud SOAP-kliendi väljakutsetega. SOAP-kliendi genereerimine Eclipsega on analoogne eelmistes ülesannetes kasutatud kliendi genereerimisega, selle ülesande puhul mingeid erinevusi siin ei ole.
selle rea asendame SOAP-teenuse väljakutsega
96
6.3.4. Veatöötluse lisamine kaupade kätteandmise SOAP-teenusele ja seda teenust kasutavale veebirakenduse osale. Eesmärgid: kontrollida kaupade kätteandmise teenuses veebirakenduse poolt saadud andmeid ja kui andmed ei ole sobivad siis saata veebirakendusele sobiva koodiga ja tekstiga veateate. Veebirakendus peab talle SOAP-teenuse poolt saadetud veakoodi ja veateadet näitama veebilehel kaustale. soovitatav tegevuste järjekord:
1. oma veaklassi tegemine SOAP-teenuste poole 2. kauba kätteandmise teenust realiseeriva klassi koodi muutmine – paneme ta viga
viskama. 3. veebteenuse uuesti genereerimine 4. veebteenuse kliendi uuesti genereerimine 5. veebirakenduse SOAPClient klassi muutmine nii et ta püüaks kinni veebteenuse poolt
visatud vigasid ja tagastaks need DeliveryServlet-ile.
SOAP teenus veebteenuse_meetod(argument) { throw MyBusinessException ; }
SOAP klient (veebirakendus) kliendi kood () { } catch (MyBusinessException) { }
this.error_message=e.getFaultInfo().getErrorMsg(); this.error_code=e.getMessage(); delivery_id=-1;
„sisendandmed ei sobinud!“
registerDelivery(kaup, arve)
97
6. DeliveryServlet-i koodi muutmine nii et ta võtaks vastu SOAPClient-i poolt tagastatud vea
Kuidas kontrollida veebteenuste poole peal kaupade kätteandmisel kas kõik on korras: - arve seisund - kaupade olemasolu laos - seda ega kaup ei ole juba välja antud selle arve alusel - kas väljastatav kaubakogus langeb kokku arvel oleva kauba kogusega.
Veaklassi tegemine: Lahendust alustage oma veaklassi tegemisest SOAP-teenuste poolet. Tehke üks oma veaklass mis sisaldab veakoodi ja veateadet. Näiteks nii (klassi nimi ei pea teil samasugune olema):
package idu0080.service.exception; public class BusinessLogicException extends Exception { public String errorMsg = null; public BusinessLogicException(String code, String msg) { super(code); this.errorMsg = msg; } }
Teenuse koodi täiendamine: Nüüd täiendage kaupade väljaandmise teenuse klassi – kirjutage sinna sisse sisendandmete kontrollid ja visake sobiva koodi ja veateatega viga kui need sisendandmed ei sobi.
Lisage sisendandmete kontrollid :
98
3. Veebteenuse uuesti genereerimine: Genereerige kaupade väljaandmise teenus. Teenuse genereerimisel on nüüd üks erinevus võrreldes eelnevate veebteenuse genereerimisega: võtke ära „linnuke“ valiku „Generate separate XSD for the types“ eest.
Kui te seda ei tee siis hiljem seda teenust kliendi poolel välja kutsudes võite saada veateateid mis näevad välja umbes sellised: javax.xml.ws.soap.SOAPFaultException: Unmarshalling Error: unexpected element (uri:"http://service.idu0080/", local:"errorMsg"). Expected elements are<{}errorMsg> Põhjuseks on see et SOAP-teenus saadab kliendile veainfo andmed mis on teenuse vastuses seotud ka namespace-iga, genereeritud klient aga ootab et SOAP-vastuses olevatel vea-andmetel ei ole namespace’i infot.
99
4. Veebteenuse kliendi uuesti genereerimine: genereerige veebirakenduse projektis kauba kätteandmise teenuse klient uuesti. 5. Veebirakenduse SOAP kliendi koodi muutmine: Pange see klient nüüd teie serveri poolel tehtud viga püüdma:
Kuidas tekkis teie veebirakendusse sama nimega veaklass mille te tegite SOAP-teenuste poole (antud näites siis klass BusinessLogicException_Exception )? Vastus on lihtne – Eclipse genereeris teenuse wsdl-i alusel. Vaadake muudetud veebteenuse wsdl-i:
Selle wsdl-i lõigu alusel genereeribki Eclipse kliendi poolele klassi BusinessLogicException:
100
6. servleti ja veebilehe koodi muutmine: nii et SOAP-kliendi poolt tagastatud veainfo jõuaks kasutajani:
7. Nõuded lahendusele. Ärireeglid ja muud nõuded. selles punktis on kokkuvõtlikult üles loetud nõuded lahenduse toimimisele, enamikust nendest nõuetest on olnud juttu selle juhendi eelnevates punktides.
Oluline nõue: veatöötlus peab teie lahenduses toimima nii nagu siin punktis on kirjeldatud – see tähendab et te üleval pool toodud äriloogika kontrollide puhul viskate oma veaklassi kuuluva vea (nt. BusinessLogicException) ja kliendi poolel püüate sama tüüpi vea ka ühes catch-blokis kinni. Nagu näiteks nii: catch (BusinessLogicException_Exception e) { this.error_message=e.getFaultInfo().getErrorMsg(); this.error_code=e.getMessage(); delivery_id=-1; }
101
1. Lahenduse veebiosal on kolm eraldiseisvat lehekülge – ühel lehel saab teha arveid, teisel lehel saab arveid maksta ja kolmandal lehel saab registreerida kaupade väljaandmisi laost arve alusel. 2. Arve tegemiseks peab saama otsida kliente OpenERP-is registreeritud klientide hulgast. Sisestada tuleb selline kliendi nimi mille alusel leitakse OpenERP-ist üks sobiv klient mis valitakse siis kohe peale otsingut automaatselt ka arve peale (kui arve saaja). Otsingutulemuste alusel kliendi väljavalimist veebilehel ei ole vaja teha. 3. Arvele jaoks peab saama otsida kaupu mis on registreeritud OpenERP serveris. Otsingutulemusi tuleb kuvada kliendile et ta saaks soovitud kauba välja valida. 4. Arvele peab saama panna ainult ühe kauba, selliseid arveid ei ole vaja teha kus ühe arvega saab osta rohkem kui ühte erinevat kaupa. Kui kasutaja teeb uue kauba otsingu ja valib uue kauba siis arve peal eelmine kaup asendatakse uue kaubaga (sellega mida kasutaja viimati valis). Selline kauba vahetamine võib toimuda enne arve kinnitamist, kinnitatud (OpenERP-i saadetud) arvele jääb seega siis see viimane kaup. 5. Arvel peab saama sisestada ja muuta (enne arve kinnitamist) kaubakogust. Vastavalt kaubakoguse muudatusele (kasutaja vajutab nuppu „Uuenda kogust“) tuleb kasutajale näidata ka muutnud arve kogusummat (mis vastab valitud kauba ja koguse korrutisele. arve summa = kauba hind x kogus). 6. Ei tohi teha (OpenERP-i saata ) arvet millel kauba kogus on 0. 7. Arve maksmise registreerimine tuleb teha nii et maksta on võimalik osad kaupa. Kui makstud on kokku sama palju kui oli arve summa siis peab see arve olema OpenERP-i poolt viidud seisundisse „paid“ (makstud), seda arve staatuse muutust peab olema võimalik OpenERP-ist näha. 8. Kauba väljaandmise veebteenus peab enne väljaandmise registreerimist OpenERP-is kontrollima : - kas arve on makstud (seisundis „paid“). - kas laos on seda toodet piisavalt (sama palju või rohkem kui on arve peal selle kauba
koguseks) - ega selle arve alusel ei ole kaupa juba välja antud - kas väljaantava kauba kogus vastab kauba kogusega arvel
Oluline nõue: maksmine tuleb teha nii et OpenERP vähendab makstud summa võrra selle arve tasumata summat. Vaata lähemalt OpenERPClient meetodi readInvoiceMoveLineId(int invoice_id) kommentaare lähtekoodist.
102
Igale siin toodud veasituatsioonile peab vastama oma veakood ja veateade mille SOAP-teenus tagastab veebirakendusele. Teenuse poolt veebirakendusele väljastatud veainfot (veakoodi ja veateadet) tuleb näidata veebilehel kasutajale. 9. Kaupade väljaandmise teenust realiseeriva klassi meetod (või meetodid kui neid on mitu) peavad ebakorrektsete sisendandmete korral viskama vastavat (teie poolt loodud) tüüpi vea, sama tüüpi vea kinnipüüdmise catch-blokk peab olema ka veebirakenduse SOAP-teenust välja kutsuvas meetodis.
8. Kaitsmine. Ülesande kaitsmine võiks toimuda järgmise stsenaariumi kohaselt:
1. Sisestate kaitsmise alguses otse OpenERP-i mõned kliendi ja kauba. Kaubale panete mingi koguse laoseisuks ka.
2. Võtate ette oma veebirakenduse ja teete selle kliendi ja kaubaga seotud arve. 3. vaatate koos õppejõuga kas selline arve jõudis OpenERP-i ja kas selle arvega seotud
raamatupidamis-kanded on ka OpenERP-is olemas. 4. Võtate ette oma veebirakenduse arve maksmise osa ja maksate ära osa arvest. 5. vaatate kas makse jõudis OpenERP-i ja kui suur osa arvest on nüüd makstud
(„residual“ välja väärtus arve vormil OpenERP-is). Vaatate maksega seotud raamatupidamiskandeid ka.
6. Maksate ära arve ülejäänud osa (teete uue makse maksmise veebilehel). Vaatate kas arve seisund OpenERP-is muutus.
7. Lähete kauba väljaandmise lehele ja proovite kaupa välja anda. Aga proovite välja anda suurema koguse kui arve peal kirjas. Vaatate kas saate veebilehele veakoodi ja veateate.
8. Nüüd sisestate korrektse kaubakoguse ja registreerite oma veebilehel kauba väljaandmise laost.
9. Vaatate kas kauba kogus OpenERP-is vähenes. 10. Vaatate kas arve märkustes on kirjas et „KAUP KAES“ (või mis iganes muu tekst
mida te arve märkustes kasutate tunnusena et selle arve alusel on kaup juba väljastatud).
11. Proovite selle punktis 2. tehtud arve alusel uuesti kaupa laost välja anda. Vaatate kas saate veateate (sest selle arve alusel on kaup juba välja antud).
12. Teete uue arve. Arvele panete kauba koguse suuremaks kui kauba laoseisu. Arvet ära ei maksa. Proovite selle arve alusel kaupa laost välja anda. Vaatate kas saate veateate.
13. Maksate eelmises punktis tehtud arve ära. Proovite kaupa laost välja anda. Kuna arve peal on kauba kogus suurem kui teil laos on siis peaksite saama veateate.
14. Vaatate koos õppejõuga teie lahenduse lähtekoodi ja vastate õppejõu küsimustele lähekoodi kohta.
15. vastate selle juhendi punktis 9. esitatud küsimustele.
103
9. Lisaküsimused ülesande kaitsmiseks.
9.1. Kas see nõutud lahendus ei ole liiga keeruline, miks nii keerulist lahendust võiks vaja minna? Miks sellist veebirakenduse ja veebteenuse kombinatsiooni nagu te selles ülesandes tegite reaalses ettevõttes võiks vaja minna? Võiks ju sellise lahenduse asemel teha palju lihtsama: Millised võiksid olla teie lahenduse eelised võrreldes alumisel skeemil toodud lahendusega?
OpenERP server
OpenERP server
veebirakendus
veebirakendus SOAP-teenus XML-RPC
XML-RPC
SOAP
104
9.2. Miks ainult üks veaklass? Selle juhendi materjalides soovitatakse kauba väljaandmise teenusele teha üks veaklass ja kui sisendandmed ei sobi (selliste andmete alusel ei saa kaupa välja anda) siis tuleks teenuse kliendile (veebirakendusele) visata viga mis on selle teie tehtud veaklassi tüüpi, näites oli selle klassi nimeks BusinessLogicException. Kas oleks parem teha ühe BusinessLogicException-klassi asemel teha igale veatüübile vastav klass ja kirjutada teenuse koodis nii?: -----------------kauba väljaandmise teenuse kood--------------------------- if (invoice.getInvoice_lines().get(0).getQuantity() < qty) { throw new ProductQuantityException("Ei saa kaupa välja anda rohkem kui arve peal kirjas"); } if (invoice_note.equals("KAUP KAES")) { throw new ProductsDeliveredException("Kaup käes"); } if (qty > product.getQty_available()) { throw new QuantityException(""Laos ei ole niipalju kaupa"); } --------------------------------------------------------------------- Põhjendage oma arvamust.
9.3. Kuhu panna kontroll? Oletame et meil on ettevõttes veebteenus mis võimaldab registreerida kaupade väljaandmist. Oletame meil on olemas ettevõttes kaks allüksust (näiteks üks on ladu ja teine on kuskil kaubanduskeskuses olev pood mis võib ka kaupa välja anda). Oletame et meil on lao ja kaubanduskeskuses oleva poe jaoks kaks erinevat veebirakendust mille abil on võimalik registreerida kaupade laost väljaandmist. Need mõlemad veebirakendused on ühendatud sama veebteenuse külge.
105
Oletame et laol on õigus välja anda suvalises koguses ja suvalise summa eest kaupu aga poel ei ole õigust ühele kliendile anda välja korraga rohkem kui 10 000.- eest kaupu. Küsimus: kuhu te paneksite kontrolli et väljaantavate kaupade kogusumma ei tohi ületada väärtust 10 000.- ? Kas veebteenuse sisse, teeksite sellest kontrollist veebteenuse funktsiooni? Või paneksite selle kontrolli poe veebirakenduse sisse? Põhjendage oma vastust.
kaupade väljastamise veebteenus
OpenERP server lao veebirakendus
poe veebirakendus kontroll: ei või
anda rohkem kui 10 000.- eest
?
?
106
9.4. Miks me andmeid otse OpenERP-i andmebaasi ei kirjuta? OpenERP kasutab andmete hoidmiseks PostgreSQL-i andmebaasi mis sisaldab ka meid huvitatavaid arve , kauba ja kliendi tabeleid.
Võib-olla oleks lihtsam teha veebirakendust või veebteenust mis kirjutab (ja ka loeb) andmeid otse OpenERP-i andmebaasist ja jätab OpenERP serveri üldse vahele? Mida teie sellisest lahendusest arvate? Põhjendage ka.
10. Seosed teiste selle aine ülesannetega. Esimene ülesanne(arendusvahendid): Eclipse kasutamine ja lihtsa servletiga veebirakenduse tegemine. Selles ülesandes läheb mõlemaid vaja. Kui tekib probleeme servletiga või Eclipse seadistamisega siis tuletage meelde mis ja kuidas te esimeses ülesandes tegite. Veebirakenduse osas vaadake ka näidet nimega „VeebiToorik“.
veebirakendus või veebteenus
OpenERP server 193.40.244.170:1099
107
Teine ülesanne(sünkroonne SOAP päring): SOAP teenuseid läheb vaja selle ülesande SOAP teenuse osas, nii teenuse kui teenuse kliendi koodi genereerimine on selles ülesandes vajalikud. Kui tekib probleeme SOAP-teenuse serveri või kliendipoole genereerimisega siis tuletage meelde mida ja kuidas te teises ülesandes tegite. Kolmas ülesanne (asünkroonne hajussüsteemi päring): otsest seost käesoleva ülesande ei tundu olevat. Aga vaatame alumist skeemi: Eesmärk – kindlustada veebirakendusest (või mõnest välisest infosüsteemist, nt. pangast) laekunud makseinfo jõudmine OpenERP-i ka siis kui OpenERP server ei ole üleval. Siin toodud skeem peaks selgitama kuidas asünkroonne andmevahetus ja konkreetselt JMS-teenus võiksid meie käesoleva ülesandega seotud olla. Neljas ülesanne (SOAP päringu veahaldus): Kui 4. ülesandes te pidite tutvuma SOAP-teenuse veahaldusega teoreetiliselt ja ainult need kes soovisid lisapunkte tegid midagi praktilist siis käesolevas ülesandes tuleb need teoreetilised teadmised ja kogutud materjalid tööle rakendada kaupade väljaandmise teenuse ja selle teenuse kliendi tegemisel. Viies ülesanne (Äriprotsess võrgus): sisaldas mõnevõrra suuremas mahus SOAP-klientide ja teenuste tegemise treeningut mis käesolevas ülesande jaoks kindlasti kasulik on.
11. OpenERP desktop (Windowsi) kliendirakenduse kasutamine. Soovijad võivad OpenERP-iga töötamiseks kasutada ka Windows klienti mis on kättesaadav OpenERP-i kodulehelt (openerp-client-setup.exe) http://nightly.openerp.com/6.0/6.0/
OpenERP server
JMS server (QoS)
SOAP-teenus (ja JMS klient)
veebirakendus JMS klient (sõnumite vastuvõtja + OpenERP XML-RPC klient)
makse info
makse info (kui sõnum)
makse info (kui üleskorjatud sõnum)
XML-RPC
108
või aadressilt http://maurus.ttu.ee/idu0080/OpenERP/windows/ Rakenduse installeerimine on lihtne – kuna OpenERP Windows klient kasutab neid samu XML-RPC teenuseid üle HTTP mida kasutab ka teile antud „OpenERPClient“ (seega ka teie enda lahendus kasutab samu teenuseid) siis on OpenERP serveriga ühendamiseks vaja sisestada OpenERP serveri XML-RPC teenuste aadress ja saategi sisse logida. Mingeid andmebaasi draivereid või muud täiendavat tarkvara ei ole Windowsi kliendi kasutamiseks installeerida vaja. TTÜ OpenERP serveri XML-RPC teenuste aadress on 193.40.244.170:1099
Ja ette tuleb veebiliidesega funktsionaalses mõttes üsna sarnane pilt:
109
Leiame siit üles meile peamiselt vajaliku arvete osa:
110
12. TTÜ OpenERP serveri ja ülesandega seotud materjalide andmed. Ülesande materjalid http://maurus.ttu.ee/idu0080/OpenERP/ OpenERP Developer Book (kahjuks sellest antud ülesande tegemisel palju abi ei ole, XML-RPC teenuste kasutamise näiteid on seal minimaalselt). http://doc.openerp.com/v6.0/developer/6_22_XML-RPC_web_services/index.html Apache XML-RPC library http://ws.apache.org/xmlrpc/ TTÜ OpenERP serveri veebiliides: http://193.40.244.170:1158/
111
TTÜ OpenERP serveri XML-RPC teenuste aadress: http://193.40.244.170:1099 Töötava lahenduse veebirakenduse osa aadress: http://imbi.ld.ttu.ee:7500/MyygiMees/ Töötava lahenduse veebteenuste osa aadress: http://imbi.ld.ttu.ee:7500/ERP_Service/services Veebirakenduse „VeebiToorik“ näide töötaval kujul (lähtekood on materjalide /src kataloogis) 13. Andmete sisestamisest, muutmisest ja kustutamisest TTÜ OpenERP serveris. Soovitav on sisestada OpenERP-i mingid nn. „oma“ kliendid ja kaubad mida te hakkate arendamisel ja testimisel kasutama. Siis te leiate OpenERP-ist andmeid otsides enda lahenduses kasutatud ja tekitatud andmed (arved, kliendid, kaubad, kauba väljaandmised) kiiresti üles. Peate arvestama et sama serverit kasutavad teisedki ja selletõttu võib sinna kliente ja kaupu ja arveid päris palju koguneda. Ärge sisestage väga lühikeste ja mõttetute nimedega kaupu ja kliente OpenERP (nagu näiteks nimedega „aa“ või „k12“. Kui te kustutate OpenERP-ist mingeid andmeid siis kustutage ainult neid andmeid (kliente ja kaupu) mida olete ise sisestanud. Arveid , kaupade väljaandmisi ja raamatupidamiskandeid ärge kustutage. Üldiselt on parem üldse mitte midagi kustutada, vajadusel saab andmeid muuta. Kõik teie katsetuste ja testimiste tulemusel tekkinud andmed võivad sinna OpenERP serverisse jääda. Kui teile meeldib paremini eesti või venekeelne liides siis võite valida kasutamiseks ka andmebaasi „openerp_est“ või „openerp_rus“ (kasutajanimi ikka „admin“ ja parooliks vastava andmebaasi nimi).
112
Või
113
NB! See andmebaas mida te kasutate OpenERP-i veebiliidesega peab muidugi langema kokku selle andmebaasiga mida kasutab „OpenERPClient“. Vaikimisi on selleks andmebaasiks „openerp_eng“, kui kasutate teist andmebaasi siis muutke andmebaasi nimi ära kui loote uut OpenERPClient klassi eksemplari konstruktoriga. Vaata InvoiceWorkFlow.main() ------------------------------------------- OpenERPClient client = new OpenERPClient("openerp_eng","admin","openerp_eng","193.40.244.170",1099); client.Connect(); System.out.println("user id" + Integer.toString(client.client_id)); client.XmLRpcOpenERPClient = client.getOpenERPClient(); -------------------------------------------
14. Sõnastik „residual“ – arve summa mis on maksmata „voucher“ – OpenERP-i saadetud/sisestatud makse. Kui makse on õigesti tehtud (sisaldab viidet arvele) siis vähendab OpenERP ise arve maksmata summat (makse „matchimine“ arvega, nn. laekumiste sissekandmine). „reconcile“ – makse kokkuviimine arvega mida makstakse
muudame sellel real andmebaasi nime ja admini parooli
