Handleiding YasperWE en Infopath Jan Martijn van der Werf 27 januari 2006 Inhoudsopgave Handleiding YasperWE en Infopath... 1 Inhoudsopgave... 1 Inleiding... 1 Idee achter YasperWE... 1 Benodigde versies... 2 Yasper... 2 YasperWE... 2 Infopath... 2 Gebruik van YasperWE... 2 Stappenplan... 2 Definiëren en koppelen van rollen aan transities... 2 Gebruik van Infopath... 3 Koppelen van Infopath aan het Petri net... 4 Documenteren en specificeren van transities... 6 Debuggen in YasperWE... 7 Voorbeelden in YasperWE... 7 Voorbeeld 1: een urenregistratiesysteem... 7 Referenties... 13 Bijlage 1: Urenregistratie... 14 Manager... 16 Werknemer... 22 Inleiding Deze handleiding is bedoeld om het gebruik van YasperWe en Infopath te illustreren en is geschreven voor OGO 2.2 (2IO50). Deze handleiding bestaat uit twee delen, allereerst een uitleg over hoe je de combinatie Yasper, YasperWE en Infopath gebruikt, met een stappenplan hoe je het handigste met deze toolset om kunt gaan Idee achter YasperWE In de colleges systeem modelleren wordt een methode aangeleerd om (informatie) systemen te ontwikkelen. Centraal in deze methode staat het gebruik van technieken om te kunnen modelleren. Informatiestructuren en gedrag worden vastgelegd op een wiskundige manier, om op zo te laten zien dat het ontwikkelde systeem correct is en doet wat het moet doen. Hierbij wordt gebruik gemaakt van Object (data) modellen en Petri netten. Wanneer we een programma hebben dat Petri netten begrijpt en kan uitvoeren, samen met de manipulaties op het object model, hebben we een krachtige en snelle methode om systemen te ontwikkelen en daadwerkelijk in te zetten. Met dit doel is YasperWE ontwikkeld. Om ook datamanipulaties door de verschillende gebruikers (actoren) toe te staan, wordt Infopath gebruikt.
Benodigde versies Yasper Om alle features van YasperWE ten volle te kunnen benutten, moet je de laatste build hebben van Yasper (versie 1.3b7, [1]). Deze ondersteunt namelijk het query gedeelte van YasperWE. YasperWE Om ook datamanipulatie toe te staan, is YasperWE versie 1 nodig. Deze is te downloaden vanaf [2]. Let op, om YasperWE te kunnen draaien, heb je ook IIS 5.0 en MySQL 4.1(!) nodig. IIS kun je vanaf de Windows XP CD installeren. Mocht je deze CD niet hebben, kun je langs het BCF gaan. Infopath Gebruik Microsoft Infopath SP1, behorende bij Microsoft Office 2003 professional, te downloaden vanaf de TU/e. Gebruik van YasperWE Stappenplan Om van YasperWE gebruik te maken kun je het beste het volgende stappenplan volgen: 1. Modelleer het Petri net voor het gehele systeem 2. Controleer of het model goed is (test bijvoorbeeld via de simulator) 3. Definieer de rollen / actoren die de transities uitvoeren. Het is handig vanwege debug doeleinden een rol All toe te voegen, om niet iedere keer van rol te hoeven wisselen. 4. Koppel de actoren aan de transities. Als een actor gekoppeld wordt aan een transitie, koppel dan ook de actor All aan de transitie. NB Je kunt dus ook transities hebben die geen enkele rol hebben: automatische transities! 5. Definieer de Infopath data en de formulieren. Het handigste is om dit iteratief per transitie te doen: a. Definieer de case data nodig voor de transitie b. Definieer de view voor een transitie c. Schrijf de queries die nodig zijn om de case data vooraf in te vullen d. Schrijf de queries die nodig zijn om de case data achteraf te verwerken in de globale data (het objectmodel). e. Test of het werkt. Definiëren en koppelen van rollen aan transities Rollen definieer je als volgt in Yasper:
1. Selecteer het menu Roles Define Roles Je krijgt het volgende scherm te zien: 2. In dit scherm staan de verschillende rollen en hun capaciteit: het aantal beschikbare rollen. Voeg in het eerstvolgende lege veld de naam van de rol in. De capaciteit wordt automatisch op 1 gezet. 3. Herhaal dit tot je alle rollen gedefinieerd hebt. Vervolgens kun je de rollen aan de verschillende transities. Dit kan op een tweetal manieren. Als alle transities al gedefinieerd zijn, gaat dit het eenvoudigste via: 1. Selecteer het menu Roles Assign to tasks Je krijgt dan het volgende scherm te zien: 2. In dit scherm zie je alle transities, hier taken genoemd, en de gedefinieerde rollen. Om een rol aan een transitie te koppelen, zet je een vinkje in de juiste cel. Wanneer je een hiërarchisch net hebt, kun je aangeven of je alleen de transities van het zichtbare gedeelte wilt zien (de optie in current net) of alle transities (de optie in whole net). Daarnaast kun je via de Properties van een transitie op het tabblad Advanced aanvinken welke rol(len) de transitie kunnen uitvoeren. Gebruik van Infopath Infopath is een formulierapplicatie. Je kunt er formulieren in ontwerpen die de inhoud van een XML bestand laten zien. Een Infopath document heet een solution. Een XML bestand heeft zelf ook een structuur, die in Infopath Datasource wordt genoemd.
Datasources YasperWE maakt gebruik van een database. Om de globale data aan de case data te kunnen koppelen, moet de XML omgezet worden naar een relationele database. Dit heeft tot gevolg dat je géén attributen (datatype: Field (attribute)) als datatype voor velden kunt gebruiken. Verder is het verstandig om, ook om conflicten te ontwijken, om, als je een groep definieert, een prefix te gebruiken. Houd rekening met de verschillende soorten datatypen die je kunt toevoegen in Infopath. Een groep die niet repeating is, wordt omgezet in een tabel met een enkele(!) rij, ofwel, een tabel waar je alleen maar updates en selects op mag uitvoeren. Om een Infopath solution te kunnen gebruiken, moet je minimaal de volgende dataset hebben (gedefinieerd als een boom): myfields viewname (datatype: Field (element), string) taskid (datatype: Field (element), string) runinstanceid (datatype: Field (element), string) choice (datatype: Field (element), string) Onder myfields kun je je eigen dataset verder uitwerken. Views In een Infopath solution kunnen meerdere views gedefinieerd worden. Kijk voor iedere taak of je een view kunt hergebruiken, of een nieuwe moet ontwerpen. Geef de view een duidelijke naam. Koppelen van Infopath aan het Petri net Views koppelen aan transities Het koppelen van Infopath aan het Petri net gebeurt op twee manieren. Allereerst moet de view gekoppeld worden aan de transitie. In Yasper termen betekent dit dat de naam van de view in het Description veld van de transitie gekoppeld moet worden. Daarnaast zit er nog een onhandigheid in Infopath, die opent namelijk alleen de standaardview. Om ervoor te zorgen dat Infopath automatisch het juiste formulier toevoegt, moet je een regel toevoegen: 1. Kies menu Tools Form Options, en dan het tabblad Open and Save. 2. Klik op de knop Rules
3. Klik in het nieuwe scherm op Add 4. Klik op de knop Set Condition 5. Kies in het 3 e invulvak voor type text en type de naam van de view 6. Klik op OK 7. Klik vervolgens op Add action 8. Geef als actie Switch views aan, en selecteer de view die getoond moet worden. 9. Klik 2x op OK 10. Herhaal dit voor iedere view 11. Klik op OK om het venster Form Options te sluiten. De verschillende views zijn nu gekoppeld aan het Petri net, en als een transitie gekozen wordt, verschijnt de juiste view. Het volgende dat ingesteld moet worden is de datamanipulatie op het objectmodel door de verschillende transities.
Datamanipulatie Zoals eerder al gemeld, werkt Infopath met XML, terwijl YasperWE een relationele database heeft. Daarom wordt de XML omgezet in een relationeel model en toegevoegd aan het globale dataschema. Op deze manier kun je SQL queries schrijven om de datamanipulatie uit te drukken. Om deze queries te kunnen schrijven, moet je weten hoe de XML omgezet wordt in een relationeel model. Zogenaamde Groepen in Infopath worden omgezet naar tabelnamen. Je hebt twee typen groepen: repeating en non-repeating. Beiden worden omgezet naar een tabel, er is enkel een groot verschil: een non-repeating groep heeft slechts één record, een repeating groep een willekeurig aantal. Dit moet je goed in gedachten houden tijdens het schrijven van de verschillende queries. Daarnaast worden velden omgezet naar veldnamen in de tabel. Omdat XML ambigu is in het gebruik van elementen en attributen, is er voor gekozen om de attributen niet mee te nemen. Daarom kun je ook alleen maar gebruik maken van element velden in Infopath. Let op, het algoritme let er niet op of de tabelnaam al in de database bestaat, dus zorg ervoor dat de groepen in je Infopath solution andere namen hebben dan de objecten in je object (data) model. Op [3] vind je een tool waarmee je automatisch van een Infopath solution de tabel definities kunt extraheren. Wanneer we praten over case data praten we over de data die Infopath kan verwerken, ofwel het relationeel model dat uit de XML wordt gegenereerd. Met het object model bedoelen we het globale model dat je eerder in het project gedefinieerd en geanalyseerd hebt. Omdat transities nu invoer kunnen verwachten van de gebruiker / actor, kun je de transitie in het Petri net zien als een taak bestaande uit een drietal subtaken: 1. prepareer de case data 2. laat de gebruiker de informatie invullen (deze stap is optioneel) 3. voer postprocessing uit op de case data Daarom heb je in YasperWE de mogelijkheid om twee queries te schrijven: prequeries om de case data te prepareren, en postqueries om de case data te gebruiken om het object (data) model te manipuleren. Omdat je alleen maar met SQL queries de data kunt manipuleren, is het handig om te weten hoe je met de MySQL variant van SQL om kunt gaan. Deze biedt namelijk extra mogelijkheden in de vorm van variabelen, if-then-else en case-when functiewoorden. Zie [4] voor een volledige handleiding over MySQL en haar taal. Documenteren en specificeren van transities Bij het specificeren en documenteren van de transities, moet per transitie aangegeven worden met welke plaatsen en stores er gecommuniceerd wordt, welke rollen de transitie kunnen vuren en welke view dan getoond wordt. Daarnaast moet aangegeven worden hoe de transitie het object model manipuleert. In het voorbeeld hieronder is een voorbeeld van documenteren gegeven. Op [7] kun je een transformatie vinden die deze documentatie kan genereren. Tevens is hier een tweede transformatie toegevoegd die de queries uit een Yasper document kan halen.
Debuggen in YasperWE Omdat YasperWE slechts een prototype is, is de user interface een ondergeschoven kindje. Er worden geen mooie foutmeldingen gegenereerd als er iets mis gaat. Wel wordt er uitgebreid gelogd in de tabel log van de YasperWE database. Als er iets misgaat, kun je in de logtabel terugvinden wat er mis is gegaan. De MySQL Querybrowser [5] en de MySQL Administrator [6] zijn hierbij zeer handig hulpmiddelen en besparen je een hoop gepuzzel. Voorbeelden in YasperWE Voorbeeld 1: een urenregistratiesysteem Het urenregistratiesysteem is een klein systeem dat gebruikt moet gaan worden in een bedrijf dat veel projecten draait. Ieder project wordt gerund door een manager met een aantal werknemers. De manager definieert de taken in het project, samen met de werknemers die aan de taken mogen werken. Een taak gekoppeld aan een (aantal) werknemer(s) heet een activiteit. Een werknemer kan inloggen in het systeem en zien aan welke projecten hij deelneemt. Wanneer hij een project kiest moet hij de activiteiten zien van het gekozen project en de mogelijkheid hebben om uren te registreren op de uitgevoerde taken. Eisen Aan het systeem zitten nog extra eisen: Het systeem kan niet stopgezet worden als er nog mensen ingelogd zijn en werken met het systeem. Als een systeem gestopt moet worden, mogen er geen nieuwe mensen inloggen in en werken met het systeem Managers moeten de mogelijkheid hebben om nieuwe projecten toe te voegen Actoren en hun acties Het systeem kent de volgende actoren, met bijbehorende acties: Systeem beheerder: o Kan het systeem opstarten o Kan het systeem stoppen Manager: o Werknemers en managers toevoegen o Projecten aanmaken o Projecten verwijderen o Werknemers aan projecten koppelen o Taken toevoegen aan een project o Taken verwijderen aan een project o Werknemers koppelen aan taken o Werkoverzicht opvragen van een project Werknemer: o Kan zijn projecten zien o Kan inloggen op het systeem o Kan inloggen op zijn projecten o Kan zijn activiteiten opvragen o Kan uren aan een activiteit hangen
o Kan zijn urenoverzicht van een project opvragen Object model Om dit systeem mogelijk te maken, zijn er de volgende objecten nodig: Project: het object dat een project definieert. Werknemer: wie er actief is in het systeem. Het type geeft aan of de werknemer actief is (groter dan, of gelijk aan 0), een gewone werknemer is (gelijk aan 0) of een manager is (groter dan 0). Taak: een eenheid binnen een project wat gedaan moet worden Activiteit: een eenheid binnen een project die aangeeft wat er door wie moet worden gedaan Werk: een eenheid binnen een taak die aangeeft wie er al hoelang aan gewerkt heeft Werknemers kunnen in meerdere projecten werkzaam zijn, en er kunnen meerdere werknemers op een taak gepland worden. Dit zijn dus many-to-many relaties. Hiermee komen we tot het volgende data model: PK Project id naam deleted PK,FK1 PK,FK2 PW project werknemer actief Activiteit werknemer PK id naam pw type PK,FK1,FK2 PK werknemer taak uitvoerend PK FK1 Taak id naam omschrijving project PK FK2 FK1 Werk id werknemer taak uren omschrijving De twee belangrijke constraints in dit model zijn: Een werknemer kan alleen activiteiten hebben in een project waar hij in mag werken: a Activiteit : p PW : Project(Taak(a)) = Project(p) werknemer(p) = werknemer(a) Een werknemer kan alleen werk invullen voor een taak van een activiteit die hij mag uitvoeren: w Werk : a Activiteit :Taak(w) = Taak(a) Werknemer(w) = Werknemer(a)
Geïntegreerd systeem Het totale systeem bestaat uit een drietal delen, opgesplitst naar actor. Het hoofdniveau toont het starten en stoppen van het systeem, en wanneer de verschillende actoren mogen inloggen en hun taken uitvoeren. Vervolgens zijn er een tweetal subniveaus, die de verschillende taken van de actoren mogelijk maken. Hoofdniveau In dit systeem zien we dat het systeem maar één keer opgestart wordt. Meerdere instanties tegelijk zijn niet mogelijk. De emitor startengine zorgt ervoor dat het systeem gestart kan worden. Zodra deze gevuurd heeft, kunnen werknemers en managers in het systeem inloggen. Wanneer de systeembeheerder het systeem stopt via stop, kunnen er geen nieuwe actoren inloggen op het systeem. De lopende cases moeten nog afgerond worden, waarna het systeem via de transitie End daadwerkelijk stopt. De collector Collect zorgt voor eindiging van het geheel, waarna het systeem weer opnieuw gestart kan worden. Verificatie Wanneer we naar het systeem kijken, zien we een tweetal problemen in verband met analyseerbaarheid: de transitie End en de plaats runningcases. Iedere keer als de transitie EnterWerknemer of EnterManager vuurt, zal er een token in runningcases bij komen. Dit betekent dat de plaats runningcases unbounded is. Ervan uitgaande dat de subsystemen Werknemer en Manager sound zijn, zal iedere keer als EnterWerknemer, respectievelijk EnterManager vuurt, endwerknemer, respectievelijk endmanager uiteindelijk ook zal vuren. Het aantal tokens in runningcases zal dus uiteindelijk altijd weer terug gaan naar het initiële aantal, namelijk 0 tokens, dus zal uiteindelijk de transitie End ook kunnen vuren, en kan het systeem eindigen.
Werknemer subniveau We komen in dit subsysteem als een werknemer succesvol heeft ingelogd op het systeem (de transitie inloggeninsysteem van het hoofdniveau). De transitie _doorvoer_ heeft enkel de functie om ervoor te zorgen dat het subsysteem een correct Workflow net blijft. De werknemer kan inloggen op een project via de transitie Inloggen, en vervolgens zijn activiteiten, taken, voor het project bekijken en zijn werk aan toevoegen. Verificatie Het gehele systeem, op de transitie Inloggen na, is een state machine. De transitie Inloggen is een XOR transitie en dus te vertalen als een state machine. Het gehele subsysteem is dus een state machine, en dus per definitie sound.
Manager subniveau De transitie _doorvoer_ heeft hier dezelfde functie als bij werknemer, ervoor zorgen dat het geheel een correct workflow net is. We zien dat een manager kan Inloggen via de transitie Inloggen. Wanneer dit lukt, kan de manager de aanwezige projecten zien, projecten toevoegen en projecten verwijderen. Ditzelfde kan hij met werknemers. Daarnaast kan hij een project selecteren via SelecteerProject en taken, activiteiten en werknemers definiëren en koppelen aan het project. Verificatie Het gehele systeem, op de transitie Inloggen na is een state machine. De transitie Inloggen is een XOR transitie, en dus te vertalen als een state machine. Het gehele subsysteem is dus een state machine. Omdat het tevens een correct workflow net is, is het systeem per definitie sound. Case data In de figuur hieronder is de case data weergegeven als een XML boom. Zoals te zien zitten de standaardvelden benodigd voor YasperWE erin, samen met overige informatie nodig om de verschillende views te kunnen vullen. Belangrijk om te weten
hierbij is het verschil in gewone groups en repeating groups. In de figuur daarrnaast is de XML data omgezet naar een SQL schema (zonder attributen hier). De tabellen in de omlijning zijn repeating tabellen en kunnen dus meerdere rijen bevatten. Op de overige tabellen mogen enkel(!) UPDATE en SELECT queries uitgevoerd worden. Houd hier rekening mee! cd_project cd_taak cd_werk cd_werknemer cd_activiteit cd_werken cd_werknemers cd_inloggen cd_hulp cd_activiteiten cd_projecten cd_taken myfields Views Voor iedere taak binnen het model moet een view gemaakt worden. Dit betekent voor dit systeem dat de volgende views aanwezig zijn: OnlySubmit Enkel een submit button, veelal om te testen, of voor transities zonder datamanipulatie inloggenprojectwerknemer Inloggen op een project in het systeem. Zowel voor manager als werknemer inloggenwerknemer Inloggen in het systeem met gebruikersnaam en wachtwoord. Zowel voor manager als werknemer toevoegenproject Toevoegen van een of meerdere projecten verwijderenproject Verwijderen van een project
toevoegentaak Toevoegen van een of meerdere taken toontaak Aanwezige taken verwijdertaak Aanwezige taak verwijderen toonwerknemers Werknemers in het systeem tonen toevoegenwerknemer Toevoegen van een of meerdere werknemers aan het systeem verwijderenwerknemer Verwijderen van een werknemer van het systeem toevoegenactiviteit Toevoegen van een activiteit: het koppelen van een activiteit aan een werknemer verwijderenactiviteit Verwijderen van een activiteit: het ontkoppelen van een activiteit met een werknemer toonactiviteiten Toont de koppelingen binnen dit project tussen werknemer en activiteit toevoegenwerk Toevoegen van een werkzaamheid aan een taak door een werknemer toonwerk Toont de verschillende werkzaamheden die uitgevoerd zijn. Hetzij horende bij een taak van een project (manager), hetzij de taken die een werknemer uitgevoerd heeft bij een taak (werknemer) verwijderwerk Verwijdert werk van een werknemer Transitiespecificatie Zie bijlage 1. Referenties [1] Yasper, versie 1.3b7: http://wwwdev.yasper.org/beta [2] YasperWE, versie 1: http://dev.yasper.org/we/ [3] Tool voor het onttrekken van een SQL schema uit XML: [4] MySQL handleiding: http://dev.mysql.com/doc/refman/4.1/en/index.html [5] MySQL Query browser: http://dev.mysql.com/downloads/query-browser/ [6] MySQL Administrator: http://dev.mysql.com/downloads/administrator/ [7] Transformaties op PNML: http://wwwis.win.tue.nl/~jmw/pnml/
Bijlage 1: Urenregistratie startengine Input: Output: All, SystemEngineer, OnlySubmit stop started, caseenabled, running, running Input: started, caseenabled Output: waittoend All, SystemEngineer, OnlySubmit End Input: waittoend Output: Ended, runningcases Collect Input: Ended, running Output: EnterWerknemer Input: caseenabled Output: caseenabled, runningcases, starten All, Werknemer, inloggenwerknemer
endwerknemer Input: runningcases, stoppen Output: EnterManager Input: caseenabled Output: startmanager, runningcases, caseenabled All, Manager, inloggenwerknemer EndManager Input: stoppen, runningcases Output: inloggeninsysteem Input: starten Output: stoppen, ingelogd SELECT @userid := w.`id` FROM `werknemer` AS w, `cd_inloggen` AS i WHERE w.`naam` = i.`username` AND w.`pw` = i.`password` AND w.`type` >= 0 ; UPDATE `cd_inloggen` SET `userid`=@userid; UPDATE `myfields` SET `choice`= IF( @userid > 0, 'ingelogd','stoppen' );
Manager _doorvoer_ Input: Output: startinloggen Inloggen Input: startinloggen Output: ingelogd, stoppen SELECT @userid := w.`id`, @manager := w.`type` FROM `werknemer` AS w, `cd_inloggen` AS i WHERE w.`naam`=i.`username` AND w.`pw` = i.`password` ; UPDATE `cd_inloggen` SET `userid` = IF (@manager > 0, @userid, -1 ); UPDATE `myfields` SET `choice` = IF (@manager > 0, 'ingelogd', 'stoppen' ); haalprojectlijst Input: ingelogd Output: projecten DELETE FROM `cd_project`; INSERT INTO `cd_project` SELECT `naam`,`id`,1 FROM `project` WHERE `deleted` = 0 Uitloggen Input: projecten Output: stoppen All, Manager,
VoegProjectToe Input: projecten Output: ingelogd All, Manager, toevoegenproject DELETE FROM `cd_project`; INSERT INTO `project` (`naam`,`deleted`) SELECT `name`, 0 FROM `cd_project`; VerwijderProject Input: projecten Output: ingelogd All, Manager, verwijderenproject SELECT @del := `delete` FROM `cd_hulp`; UPDATE `project` SET `deleted` = 1 WHERE `id`=@del; UPDATE `cd_hulp` SET `delete` = ''; SelecteerProject Input: projecten Output: project All, Manager, inloggenprojectwerknemer haaltakenlijstop Input: project Output: taken DELETE FROM `cd_project`; SELECT @project := `project` FROM `cd_inloggen`; INSERT INTO `cd_project` SELECT `naam` `id`,1 FROM `project`
WHERE `id` = @project; INSERT INTO `cd_taak` SELECT `id`,`naam`,`omschrijving`,1 FROM `taak` WHERE `project` = @project; terug Input: taken Output: ingelogd All, Manager, voegtaaktoe Input: taken Output: project All, Manager, DELETE FROM `cd_taak`; SELECT @project := `project` FROM `cd_inloggen`; INSERT INTO `taak` (`naam`,`omschrijving`,`project`) SELECT `taaknaam`, `omschrijving`,@project FROM `cd_taak`; kijktaken Input: taken Output: project All, Manager, toontaken verwijdertaak Input: taken Output: project All, Manager, verwijdertaak SELECT @deleter := `delete` FROM `cd_hulp`; DELETE FROM `activiteit` WHERE `taak`=@deleter; DELETE FROM `werk` WHERE `taak`=@deleter; DELETE FROM `taak` WHERE `id`=@deleter;
UPDATE `cd_hulp` SET `delete`=''; Transition: tr29 Input: stoppen Output: koppelwerknemersaanproject Input: taken Output: project koppelwerknemers SELECT @project := `project` FROM `cd_inloggen`; INSERT INTO `PW` (`project`,`werknemer`,`actief`) SELECT (@project,`wnmid`,1) FROM `cd_werknemer` ON DUPLICATE KEY UPDATE `actief`=1; haalusersop Input: startwnm Output: werknemers DELETE FROM `cd_werknemer`; Terug Input: Output: INSERT INTO `cd_werknemer` SELECT `naam`, `pw`, IF (`type` > 0, 'manager', 'werknemer' ), `id`, 1 FROM `werknemer` WHERE `type` >= 0 ORDER BY `naam` ; werknemers projecten All, Manager,
delete from `cd_werknemer`; kijkusers Input: werknemers Output: startwnm All, Manager, toonwerknemers kieswerknemersectie Input: projecten Output: startwnm All, Manager, VoegUserToe Input: werknemers Output: startwnm All, Manager, werknemertoevoegen DELETE FROM `cd_werknemer`; INSERT INTO `werknemer` (`naam`,`pw`,`type`) SELECT `naam`,`wachtwoord`, IF (`type` = 'manager', 1, 0 ) FROM `cd_werknemer` ; verwijderuser Input: werknemers Output: startwnm All, Manager, SELECT @userid := `userid` FROM `cd_inloggen`; DELETE FROM `cd_werknemer` WHERE `wnmid` = @userid; SELECT @deleter := `delete` FROM `cd_hulp`; UPDATE `pw` SET `actief` = 0 WHERE `werknemer`= @deleter; UPDATE `activiteit` SET `uitvoerend`=0 WHERE
`werknemer`=@deleter; UPDATE `werknemer` SET `type` = -1 WHERE `id` = @deleter; UPDATE `cd_hulp` SET `delete` = ''; maakactiviteit Input: pl15 Output: pl15 toevoegenactiviteit DELETE FROM `cd_activiteit`; INSERT INTO `activiteit` SELECT a.`awnmid`,t.`taakid`, 1 FROM `cd_activiteit` AS a, `cd_taak` AS t ON DUPLICATE KEY UPDATE `uitvoerend`=1; toonactiviteit Input: pl15 Output: pl15 toonactiviteiten INSERT INTO `cd_activiteit` SELECT w.`naam`,t.`naam`, w.`id`,t.`id`, 1 FROM `werknemer` AS w, `taak` AS t, `activiteit` AS a, `cd_taak` AS c WHERE a.`werknemer` = w.`id` AND a.`taak` = t.`taak` AND t.`id` = c.`taakid`; verwijderactiviteit Input: pl15 Output: pl15 verwijderactiviteit INSERT INTO `cd_activiteit` SELECT w.`naam`,t.`naam`, w.`id`,t.`id`, 1 FROM `werknemer` AS w, `taak` AS t, `activiteit` AS a, `cd_taak` AS c WHERE a.`werknemer` = w.`id` AND a.`taak` = t.`taak` AND t.`id` = c.`taakid`; SELECT @wnm := `delete` FROM `cd_hulp`; SELECT @taak := `taakid` FROM `cd_taak`; UPDATE `activiteit` SET `uitvoerend`=0 WHERE `werknemer`=@wnm AND `taak`=@taak; selecteertaak
Input: taken Output: pl15 SELECT @taak := `delete` FROM `cd_hulp`; DELETE FROM `cd_taak`; INSERT INTO `cd_taak` SELECT `id`,`naam`,`omschrijving`,1 FROM `taak` WHERE `id`=@taak; UPDATE `cd_hulp` SET `delete`=''; Werknemer _doorvoer_ Input: Output: naarprojecten haalprojectenop Input: naarprojecten Output: projecten DELETE FROM `cd_project`; INSERT INTO `cd_project` VALUES('stoppen',-1,1); INSERT INTO `cd_project` SELECT p.`naam`, p.`id`, 1 FROM pw, `project` as p, `cd_inloggen` AS i, WHERE pw.`project` = p.`id` AND pw.`werknemer` = i.`userid` AND pw.`actief`= 1 AND p.`deleted` = 0; Inloggen Input: projecten Output: ingelogd,
All, Werknemer, inloggenprojectwerknemer SELECT @projectid := `project` FROM `cd_inloggen`; UPDATE `myfields` SET choice=if ( @projectid < 0, 'stoppen', 'ingelogd' ); haaltakenop Input: ingelogd Output: taken SELECT @userid := `userid` FROM `cd_inloggen`; INSERT INTO `cd_taak` SELECT t.`id`,t.`naam`,t.`omschrijving`,1 FROM `taak` AS t, `activiteit` AS a WHERE a.`taak` = t.`id` AND a.`werknemer` = @userid; Uitloggen Input: taken Output: naarprojecten All, Werknemer, UPDATE `cd_inloggen` SET `project`=-1, `userid`=-1, `username`='',`password`=''; DELETE FROM `cd_taak`; DELETE FROM `cd_werk`; kijktaken Input: taken Output: ingelogd All, Werknemer, voegwerktoe Input: taken
Output: ingelogd All, Werknemer, SELECT @taak := `delete` FROM `cd_hulp`; SELECT @userid := `userid` FROM `cd_inloggen`; INSERT INTO `werk` (`werknemer`, `taak`, `uren`, `omschrijving`) SELECT @userid,@taak,`werkuren`,`werkomschrijving` FROM `cd_werk`; UPDATE `cd_hulp` SET `delete` = '';