Een proces ontwerpen

Doel

Een proces tekenen: de banen die het doorkruist, de stappen in elke baan en de verbindingen ertussen.

De designer openen

Selecteer in Processen een proces en kies Ontwerpen — of klik op de rij. Het canvas opent binnen de app, met het kruimelpad en de titelbalk er nog boven.

Een proces dat je nog nooit hebt getekend, opent op een startdiagram in plaats van een leeg canvas: één baan, een start en een einde. Dat is de vorm die elk proces heeft, dus dat is de vorm waarmee je begint.

De vier gebieden

• Het palet, aan de linkerrand — wat je kunt toevoegen: een baan en de soorten knooppunten.
• De structuur, ernaast — het proces als boom: de hoofdknoop, de banen en de knooppunten in elke baan. Selecteren in de structuur selecteert op het canvas, en andersom. Sleep de rechterrand om hem breder te maken.
• Het canvas, in het midden — het diagram zelf.
• Het eigenschappenpaneel, rechts — alles over wat er geselecteerd is.

Banen: wie het werk doet

Voeg een baan toe vanuit het palet, of sleep er een op het canvas. Noem hem naar de rol, niet naar de persoon — "Manager", geen naam — want een proces leeft langer dan wie de functie deze maand toevallig vervult.

• Hernoem een baan door op de kop te dubbelklikken.
• Wijzig de grootte door de grens eronder te slepen. De banen eronder schuiven mee naar beneden, en hun knooppunten ook.
• Een knooppunt hoort bij de baan waarin het staat. Sleep het naar een andere baan en het gaat over in andere handen.

Stel de rol van de baan in, anders gaan de stappen naar niemand

Een baan "Manager" noemen vertelt een lezer wie het werk doet. Het vertelt het de engine niet. Selecteer de baan en kies de Rol in het eigenschappenpaneel — een zoekveld over de beveiligingsrollen die deze omgeving heeft, met een zoekvak: begin te typen en de lijst wordt korter, op de naam van de rol of op de logische naam.

Vroeger was het een vak waarin je de naam typte, zodat een typfout een baan opleverde waarvan het werk naar een rol ging die niet bestaat — en niets meldde dat totdat een uitvoering stilviel. Laat je het leeg, dan beslist elke stap voor zichzelf.

Elke gebruikerstaak in die baan gaat dan naar wie die rol heeft — precies waarom een zwembaan het tekenen waard is, en het wordt één keer voor de baan ingesteld in plaats van bij elke stap. Een stap met een eigen Toegewezen aan-expressie gaat daarboven.

let op

Een baan zonder Rol en stappen zonder Toegewezen aan vormen een proces dat start en dan stilvalt met "… could not be assigned to anybody". De taak wordt wel aangemaakt, zodat een beheerder hem kan zien — maar hij staat in niemands lijst.

Er moeten nog twee dingen kloppen voordat een rol bij een persoon aankomt: de rol moet bestaan (Rollen, in het Beheercentrum) en iemand moet de rol in een eenheid hebben (Procesrollen, in de app Organisatie). Zie Je organisatie inrichten.

Knooppunten: de stappen

Soort	Wat het betekent
Start	Waar het proces begint. Teken er precies één.
Einde	Waar het eindigt. Er mogen er meerdere zijn — goedgekeurd en afgewezen zijn allebei een einde.
Taak	Een stap. Die gebruik je het meest.
Vertakking	Een beslissing: één weg erin, meerdere wegen eruit.
Splitsing	Opsplitsen in paden die allemaal worden doorlopen.
Samenvoeging	Wachten tot die paden weer samenkomen.
Timer	Een tijdsduur wachten, of tot een bepaald moment. Niemand hoeft iets te doen.

Een taak heeft ook een soort taak, gekozen in het eigenschappenpaneel — gebruiker, service, script, handmatig, verzenden, ontvangen, bedrijfsregel. Dat tekent een klein badge op het knooppunt, en zo ziet een lezer in één oogopslag het verschil tussen "iemand vult dit in" en "het platform doet dit zelf".

Welke stappen wachten

Alleen een Gebruiker-taak laat de uitvoering op iemand wachten. Elk ander soort taak draait zijn Bij binnenkomst en Bij verlaten en gaat meteen verder; het soort is er voor wie de tekening leest.

Wanneer een uitvoering meerdere paden heeft

Na een Splitsing loopt een uitvoering over meerdere paden tegelijk. Twee keuzes bepalen wat er gebeurt als die eindigen.

• Bij een Samenvoeging, Gaat verder wanneer: Alle paden zijn aangekomen (standaard), Het eerste pad aankomt of Een aantal paden is aangekomen, met Hoeveel paden ernaast. Geteld worden de paden die de Splitsing startte, niet de verbindingen die erheen getekend zijn. Een pad dat nog loopt wanneer de Samenvoeging verdergaat, wordt gestopt en zijn open taak wordt ingetrokken.
• Bij een Einde, Wanneer een pad het bereikt: Dit pad beëindigen (standaard: de uitvoering stopt als er geen ander pad meer loopt) of De hele uitvoering beëindigen, wat elk ander pad stopt. Die tweede is het einde voor "afgewezen, alles stoppen".

De titel en de naam van een stap

Elke stap heeft ze allebei, en ze doen verschillend werk — hetzelfde paar als de weergavenaam en de logische naam van een tabel.

• Titel is wat het vak op het canvas toont. Schrijf die voor een lezer, in welke taal je ook werkt, en herformuleer hem wanneer je wilt.
• Naam is hoe code, de uitvoeringsgeschiedenis en een ander proces de stap aanroepen. Hij bestaat uit kleine letters, cijfers en underscores, en is verplicht.

Normaal typ je de naam niet. Hij vult zich in vanuit de titel terwijl je typt — "Approve Leave" wordt approveleave — en hij volgt niet meer zodra je hem zelf bewerkt, zodat een naam die je zelf hebt gekozen nooit wordt overschreven. Maak het vak leeg om het voorstel terug te krijgen.

Twee stappen kunnen geen naam delen. Levert een titel een naam op die al bezet is, dan krijgt de nieuwkomer _2; de stap die hem al had, houdt hem, want die hernoemen zou veranderen waarnaar elk script dat er al naar verwijst, verwijst.

tip

Een titel in het Perzisch of Arabisch levert geen naam op, dus de stap wordt naar zijn soort genoemd — task, task_2. Geef hem een naam die je in de geschiedenis van een uitvoering herkent.

Processen getekend voordat namen verplicht waren

Een naam was vroeger optioneel, dus een eerder getekend proces kan stappen zonder naam hebben — of met een naam in de oude, vrije stijl. Zulke documenten worden niet meer geaccepteerd.

Open ze een voor een in de designer en sla ze op. De namen vullen zich bij het openen in vanuit de titels, en opslaan is de hele oplossing. Niets zet ze voor je om, en een proces dat je niet opnieuw hebt geopend, weigert op te slaan de volgende keer dat je het bewerkt.

Verbindingen

Kies Verbinden in het palet en sleep dan van het ene knooppunt naar het andere. Verbindingen worden automatisch gerouteerd — de hoeken teken je niet zelf.

• Geef een verbinding een label waar dat nodig is. Op de uitgaande verbindingen van een vertakking is dat wat een lezer als de beslissing leest: Goedgekeurd, Boven limiet, Afgewezen.
• Verbindingsstijl — gebogen of met rechte hoeken — staat op de hoofdknoop van het proces en geldt voor het hele diagram, want een diagram dat de twee door elkaar gebruikt, leest als een vergissing in plaats van een keuze.

Variabelen: wat het proces meedraagt

Selecteer de hoofdknoop van het proces in de structuur en voeg Variabelen toe — de waarden die dit proces van de ene stap naar de volgende meeneemt. Elke variabele heeft een naam en een type (tekst, getal, ja/nee, datum).

De naam is wat een script schrijft: getVariable("total"). Een variabele hernoemen herschrijft de scripts die hem noemen niet, dus behandel de naam als het ding dat je benoemt, niet als een label dat je vrij kunt wijzigen. Een variabele zonder naam wordt nergens aangeboden.

Beslissingsformulieren: wat iemand invult om een stap af te ronden

Een beslissingsformulier is het korte formulier dat iemand invult om een gebruikerstaak af te ronden, samen met de uitkomsten — de knoppen die de taak beëindigen. Het is geen modelgestuurd formulier op een tabel: het hoort bij het proces, reist mee in het procesdocument en vraagt alleen wat de beslissing nodig heeft.

Selecteer de hoofdknoop van het proces in de structuur — daar opent de designer — en je krijgt Beslissingsformulieren onder Variabelen, omdat een beslissingsformulier bij het proces hoort en niet bij één stap: meerdere stappen kunnen hetzelfde tonen.

Elk beslissingsformulier heeft:

• Een naam van het beslissingsformulier, waarmee een taak ernaar verwijst, en een kop, die de persoon ziet die het leest.
• Velden — een veldnaam, een label en een gegevenstype. Dit zijn de eigen veldtypen van het platform, dus een beslissingsformulier krijgt dezelfde datumkiezers, kalenders en keuzelijsten als een recordformulier.
• Uitkomsten — één rij per knop. De knoptekst is wat erop staat, de stijl hoe hij eruitziet (gewoon, primair, destructief), en Opmerking vereist zorgt dat die ene knop een antwoord eist in het eerste meerregelige veld van het beslissingsformulier. Zet het aan bij een afwijzing en laat het uit bij een goedkeuring: dat is het verschil waarvoor de instelling bestaat.

Selecteer dan een gebruikerstaak en kies het Beslissingsformulier uit de lijst.

Een taak zonder beslissingsformulier wordt nog steeds afgerond, maar de persoon kan er niets over zeggen. Een proces waarvan de menselijke stappen niets vragen, is meestal een proces dat nog niet af is ontworpen.

Waar ze naar kijken terwijl ze beslissen

Onder het beslissingsformulier kiest Wat ze bekijken wat het hoofdgebied vult terwijl de persoon beslist: niets, het formulier van een record, een lijst, een rapport of een scherm. Kies er een en de rest van de sectie verschijnt.

Veld	Waarvoor het is
App	In welke app het opent. Laat je het leeg, dan opent het in een app die bevat waar de stap over gaat: de app waarin de persoon zit, als die het bevat, en anders een app die meedoet aan bedrijfsprocessen. Zo blijft een proces werken nadat het ergens anders is geïmporteerd.
Tabel / Rapport / Scherm	Waar de stap over gaat. Welke van de drie je krijgt, hangt af van wat je hierboven hebt gekozen.
Welk formulier / Welke weergave	Een specifiek formulier of een specifieke weergave in plaats van de standaard van de tabel. Leeg betekent de standaard.
Geopend	Alleen-lezen of om te bewerken. Alleen-lezen is het gebruikelijke antwoord — iemand leest om te kunnen beslissen — en bewerken gebeurt onder de eigen machtigingen van het record: een taak geeft zelf geen toegang.

Elk van deze velden is een vervolgkeuzelijst van wat deze omgeving werkelijk heeft. Het waren vakken waarin je een logische naam typte, en een met de hand getypte naam kan alleen maar verkeerd gespeld worden — wat weken later zichtbaar wordt als "de stap opent niets", in het bijzijn van degene voor wie het proces is gebouwd.

Welk record er wordt geopend, staat niet in deze lijst: dat is een expressie, dus het staat onder Code, bij de andere expressies. Meestal getRecordRef("request") — het record waar deze uitvoering over gaat.

Parameters: wat de stap verder te horen krijgt

Het record beantwoordt welk record, en op een formulier is dat meestal de hele vraag. Overal elders is het dat niet: een rapport wil de periode die het beslaat, een scherm wil het bedrag dat wordt goedgekeurd en wie het heeft ingediend. Die waarden zitten in deze uitvoering, niet in het artefact.

Selecteer Parameter toevoegen, geef hem de naam die het rapport of scherm verwacht, en de waarde verschijnt als rij onder Code — want een waarde is een expressie over de variabelen van het proces en de toestand van deze uitvoering: getVariable("month"), instanceStartedBy().

Het artefact vindt een waarde aan de hand van de naam, dus twee parameters kunnen geen naam delen, en een parameter zonder naam wordt weggelaten wanneer het proces wordt opgeslagen.

Uitkomsten: welke beslissing welke verbinding neemt

Een gebruikerstaak eindigt wanneer iemand op een van de uitkomsten van het beslissingsformulier drukt, en elke uitkomst stuurt het proces een andere kant op. Selecteer een verbinding die een gebruikerstaak verlaat en stel Gekozen wanneer in — een vervolgkeuzelijst met de uitkomsten van het beslissingsformulier van die taak.

Daardoor is Goedkeuren of afwijzen één stap, in plaats van een taak gevolgd door een vertakking die opnieuw vraagt wat de persoon al heeft besloten.

• Het wordt alleen aangeboden waar de taak een beslissingsformulier met uitkomsten toont. Elders valt er niets te kiezen.
• Een beslissingsformulier met één uitkomst heeft dit allemaal niet nodig: één knop, één uitweg.
• Bij meerdere uitkomsten wil elke uitkomst een eigen verbinding. Het paneel Problemen meldt het — een uitkomst die geen enkele verbinding neemt, twee verbindingen die dezelfde uitkomst claimen, en een verbinding die een uitkomst noemt die het beslissingsformulier niet meer biedt; dat laatste gebeurt als je een beslissingsformulier bewerkt dat ook door een andere taak wordt getoond.

Een ander proces aanroepen

Stel het Type van een taak in op Proces aanroepen en kies het Uit te voeren proces. De bedoeling is dat deze stap wacht tot dat proces klaar is en dan verdergaat, maar de engine voert het nog niet uit. De keuze blijft bewaard en het problemenpaneel controleert dat er een gekozen is; tijdens een uitvoering draait de stap zijn Bij binnenkomst en Bij verlaten en gaat meteen verder zonder het andere proces te starten, zoals elke stap die geen gebruikerstaak is.

Gebruik dit wanneer meerdere processen hetzelfde stuk werk nodig hebben — een goedkeuring, een kredietcontrole. Eén proces dat drie keer wordt aangeroepen, blijft één ding om te wijzigen; drie kopieën ervan zijn het binnen een jaar met elkaar oneens.

De kiezer toont de andere processen in deze omgeving. Een proces kan zichzelf niet aanroepen.

Voorwaarden: welke kant een vertakking op gaat

Selecteer een verbinding die een vertakking verlaat en open de Voorwaarde onder Code — één expressie die bepaalt of de stroom die verbinding neemt. getVariable("approved") aan de ene kant, !getVariable("approved") aan de andere.

Dit wordt aangeboden op de verbindingen van een vertakking en nergens anders. Een taak heeft één uitweg, dus een voorwaarde daar zou een vraag met één antwoord zijn.

Een voorwaarde mag alleen lezen. Ze bepaalt een route, en de engine kan haar vaker dan eens evalueren, dus een voorwaarde die iets veranderde, zou het proces afhankelijk maken van hoe vaak ze toevallig werd gevraagd — de editor biedt je de woorden om dat te doen niet eens aan.

Naar wie een taak gaat

Een gebruikerstaak heeft een rij Toegewezen aan onder Code: één expressie die antwoordt wie de taak moet doen.

Je wilt	Schrijf
Wie een rol heeft	role("Manager")
Een bepaalde persoon	user("a.khan")
Een team	team("Finance")
Wie het proces heeft gestart	instanceStartedBy()

Het is bewust een expressie en geen kiezer: de toewijzingen die de moeite van het schrijven waard zijn, zijn juist die een kiezer niet kan uitdrukken — de goedkeurder voor het bedrag in een variabele, de manager van degene die het heeft ingediend.

Alleen een gebruikerstaak heeft er een. Een servicetaak wordt door het platform uitgevoerd, dus er is niemand om hem aan te geven.

Een stap zonder expressie valt terug op de rol van zijn baan, en dat is het gewone geval: schrijf de expressie alleen waar één stap afwijkt van de rest van de baan.

Wachten, en te laat zijn

Een timer: wachten op de klok

Teken een Timer waar het proces gewoon moet wachten. Niemand hoeft iets te doen: de uitvoering stopt daar en gaat vanzelf verder.

Stel Gaat af in op Na een tijdsduur en vul Wachten gedurende in: een getal en een eenheid die je ernaast kiest — 3 dagen, 4 uur, 90 minuten.

Een timer zonder tijdsduur wacht niet — hij stopt de uitvoering. Het is de enige instelling van een proces zonder zinnige standaardwaarde: meteen afgaan zou een wachttijd ongemerkt in geen wachttijd veranderen, dus in plaats daarvan stopt de route en zegt de geschiedenis van de uitvoering "… does not say when it fires". Gaat een timer die je hebt getekend nooit af, controleer dit dan eerst.

Maanden en jaren worden bewust niet aangeboden. Een maand is 28 dagen in februari en 31 in maart, dus een wachttijd die zo is geschreven, zou een ander aantal uren betekenen afhankelijk van wanneer hij begon. Vraag om 30 dagen.

Voor wie het document leest

De tijdsduur wordt opgeslagen als ISO-8601-duur — P3D, PT4H, PT90M — en dat is wat de engine leest en wat een met de hand geschreven of door AI gegenereerd proces moet bevatten. Je typt het nooit; het getal en de eenheid zijn het hele veld. Een met de hand geschreven tijdsduur in twee eenheden (PT4H30M) opent als dezelfde duur in één eenheid (270 minuten).

Kies in plaats daarvan Op een moment dat de code bepaalt wanneer het moment van de gegevens afhangt — de datum op het record, een variabele die iemand heeft ingevuld. Schrijf dan de expressie onder Code; die mag een moment of een tijdsduur opleveren.

Een deadline: wanneer een stap klaar moet zijn

Selecteer een gebruikerstaak en vul Uiterlijk binnen in — hetzelfde paar van getal en eenheid dat de timer gebruikt. De klok begint te lopen op het moment dat de taak in iemands lijst verschijnt — niet wanneer die persoon hem opent — zodat een taak die op vrijdagmiddag binnenkomt niet stilletjes het weekend erbij krijgt.

De persoon ziet Uiterlijk … onder de taak in zijn lijst, en zodra dat moment voorbij is, wordt het rood en staat er Was uiterlijk …. Ernaast zegt Wachtend hoe lang de taak er al ligt.

Als het te laat is bepaalt wat het proces eraan doet:

Keuze	Wat er gebeurt
Als te laat markeren	Er verandert niets. De taak staat zichtbaar als te laat in de lijst, en de geschiedenis van de uitvoering legt het vast.
Ook hogerop aanbieden	Wie de escalatie van de baan noemt, krijgt de taak ook aangeboden. De persoon die hem al had, houdt hem — er kan één persoon meer handelen, en er wordt niets afgenomen van iemand die misschien bijna klaar is.
Automatisch beslissen	Het proces drukt namens hen op een van de eigen knoppen van de taak. Kies welke onder Beslissen als.

Automatisch beslissen gebruikt de eigen uitkomsten van de stap, dus het diagram laat al zien waar het proces daarna heen gaat — er is geen tweede, onzichtbare uitweg uit de stap. "Als niemand binnen drie dagen goedkeurt, behandel het als afgewezen" schrijf je door Automatisch beslissen te kiezen en dan Afwijzen.

Laat Uiterlijk binnen leeg voor een stap zonder deadline, en dat zijn de meeste — het getal leegmaken is ook hoe je een deadline weer weghaalt.

Kijk mee zonder een dag te wachten

Stel tijdens het bouwen de tijdsduren in op een minuut of twee, publiceer en start een uitvoering: de escalatie, de wachttijd en de automatische beslissing gebeuren allemaal terwijl je naar de geschiedenis van de uitvoering kijkt. Zo is bpms-deadlines-and-timers ingesteld, en dat is het enige onrealistische aan dat voorbeeld.

Code: wat er draait, en wat er wordt berekend

Selecteer een taak en je krijgt de lijst Code — alles aan die stap wat in BS Lang is geschreven. Selecteer een rij en de codepagina opent.

De eerste vier zijn de momenten waarop de stap kan reageren:

Slot	Wanneer het draait
Bij binnenkomst	Het proces bereikt deze stap.
Bij toewijzen	De taak heeft iemand — alleen gebruikerstaken.
Bij voltooien	Die persoon markeert hem als klaar — alleen gebruikerstaken.
Bij verlaten	Het proces verlaat deze stap, welke kant het ook op gaat.

De hoofdknoop van het proces heeft er drie van zichzelf, in dezelfde vorm: Bij start, Bij voltooien en Bij annuleren. Bij start is waar je een variabele zijn eerste waarde geeft.

Daaronder staan, op een gebruikerstaak, de dingen die hij berekent in plaats van uitvoert: Toegewezen aan, Record en één rij per parameter, genoemd naar de parameter. Ze staan in dezelfde lijst omdat ze van dezelfde soort zijn — een stuk BS Lang dat bij deze stap hoort — en één lijst is één plek om te zoeken naar "wat draait deze stap".

De lijst geeft aan op welke rijen al iets geschreven staat, zodat je in één oogopslag ziet waar het werk zit.

Een vertakking heeft Bij binnenkomst en Bij verlaten, en geen slot dat een route kiest.

• Bij binnenkomst draait op het moment dat het proces aankomt, voordat er een voorwaarde wordt gevraagd. Hier doet een vertakking zijn rekenwerk: bereken het antwoord één keer, zet het in een variabele en laat elke voorwaarde het lezen. Zes schijven van een bedrag worden dan zes korte voorwaarden in plaats van zes kopieën van de som.
• Bij verlaten draait zodra er een route is gekozen. Het draait niet als geen enkele voorwaarde waar was — er ging niets weg, dus er was geen vertrek.
• De beslissing blijft op de verbindingen. Er is bewust geen code die een uitweg kiest: een diagram waarvan de vertakking wordt beslist op een plek die je niet kunt zien, is een diagram dat liegt over wat het proces doet.

De codepagina

Die vult de editor en heeft de lijst met slots langs de zijkant, zodat wisselen tussen de momenten van een taak één klik is. Het oog in de kop toont alles wat je vanuit dat slot kunt aanroepen — en dat is niet overal hetzelfde: een voorwaarde en Toegewezen aan mogen alleen lezen, een handler mag dingen wijzigen, en alleen Toegewezen aan krijgt user(), role() en team() aangeboden.

Er is geen Opslaan op de codepagina. Opslaan in de titelbalk is de enige, en die slaat het hele proces op.

opmerking

Een script opslaan voert het niet uit. Variabelen, voorwaarden, toewijzingen en scripts worden met het ontwerp opgeslagen en gecontroleerd terwijl u ze schrijft; ze lopen zodra het proces is gepubliceerd en een uitvoering start.

Problemen: wat er nog ontbreekt

In de hoek van het canvas staat een balk die zegt hoeveel problemen het proces heeft. Open hem voor de lijst; selecteer een regel en de designer brengt je naar waar die over gaat — het knooppunt, de verbinding of de hoofdknoop van het proces.

Hij controleert wat de engine zal eisen:

• precies één Start en minstens één Einde;
• geen verbinding gaat een Start in of een Einde uit, want een uitvoering begint bij het ene en stopt bij het andere, dus die wordt nooit gevolgd;
• geen stap die de stroom nooit kan bereiken, en geen stap die hij nooit kan verlaten;
• een voorwaarde op elke verbinding die een vertakking verlaat, en minstens twee uitwegen uit een vertakking;
• minstens twee uitwegen uit een splitsing en twee ingangen in een samenvoeging, en evenveel van beide;
• elke variabele die een script noemt, is gedeclareerd, en elke variabelerij heeft een naam;
• elk script wordt geparseerd.

Niets hiervan houdt je tegen. Een half getekend proces meldt een pagina vol problemen en wordt prima opgeslagen — daar is tekenen nu juist voor. De lijst is hoe je ontdekt wat er nog te doen is, en het is dezelfde lijst die het platform toepast wanneer een proces wordt gepubliceerd om te draaien.

Een opmerking over twee ervan. Het paneel zegt of een script wordt geparseerd; of het een bepaalde naam mag aanroepen, is de zaak van de code-editor, en die onderstreept dat terwijl je typt, op basis van wat dat slot kan zien. En splitsingen en samenvoegingen worden geteld, niet één op één aan elkaar gekoppeld — een proces dat vaker splitst dan samenvoegt, heeft nog een pad lopen wanneer het klaar zou moeten zijn, en dat is bijna altijd de fout.

Automatisch schikken

Beeld → Automatisch schikken zet het diagram netjes van links naar rechts, in stroomvolgorde, en houdt elk knooppunt in zijn eigen baan. Het verplaatst knooppunten horizontaal en routeert de verbindingen opnieuw; het verschuift nooit werk van de ene persoon naar de andere.

Genereren met AI

Genereren met AI beschrijft een proces in woorden en tekent het. Wat er terugkomt, wordt gevalideerd voordat het op het canvas komt, precies zoals een geïmporteerd bestand — dus een gegenereerd diagram dat niet klopt, wordt geweigerd in plaats van getekend.

Het corrigeert zichzelf voordat het opgeeft. Klopt wat terugkomt niet, dan stuurt het platform het meteen terug naar het model met het probleem erbij, in plaats van jou te vragen een schemafout op te lossen die je nooit hebt geschreven. Het probeert het tot drie keer, en de knop toont intussen Bezig met corrigeren… poging 2 van 3. Je krijgt pas een fout te zien nadat corrigeren is geprobeerd, en wat je dan ziet, is het laatste wat er mis was.

Het vervangt wat er op het canvas staat en slaat niet op. Bekijk het voordat je op Opslaan drukt.

Jij beschrijft het proces, en verder niets. Welk AI-model antwoordt, wordt één keer voor het hele platform door een beheerder ingesteld — er is geen sleutel om te plakken en geen provider om te kiezen, en niets wat je hier typt, gaat ergens anders heen dan naar dat ene model.

Is er geen AI gekoppeld, dan zegt Genereren dat. Een tenantbeheerder koppelt er één keer een, onder Instellingen → AI, voor iedereen in de organisatie. Een maker zet dit niet zelf aan.

Opslaan

Opslaan, in de titelbalk, schrijft het proces weg. Dat is de enige Opslaan: het ontwerp maakt deel uit van het onderdeel, dus er is geen bestand om gelijk te houden en niets om te onthouden te exporteren.

Vertrekken met niet-opgeslagen wijzigingen vraagt eerst om bevestiging — via Sluiten, via de navigatiebalk en via de terugknop van de browser.

Publiceren: opslaan is nog niet uitleveren

Opslaan bewaart je werk. Publiceren verandert wat er draait. Het zijn twee knoppen omdat het twee beslissingen zijn, en die splitsing bestaat om één reden: een proces dat al draait, mag niet veranderen onder de mensen die ermee bezig zijn. Zonder die splitsing zou het verbeteren van een typfout om vier uur 's middags het proces herschrijven dat elke lopende instantie volgde — inclusief stappen die ze al gepasseerd waren.

Daarom leest de engine alleen wat je hebt gepubliceerd, en een publicatie is een genummerde, bevroren kopie van de tekening zoals die op dat moment was.

De regel onder de titel zegt in welke van de drie toestanden je bent:

Er staat	Het betekent
Nog niet gepubliceerd	Niets voert dit proces uit.
Versie 3 draait en komt overeen met wat je ziet	Je kijkt naar wat live is.
Versie 3 draait. Je hebt niet-gepubliceerde wijzigingen	Je opgeslagen bewerkingen zijn nog niet live.

Selecteer Publiceren en het concept wordt de volgende versie. Heb je niet-opgeslagen bewerkingen, dan worden die eerst opgeslagen, want publiceren wat op het scherm staat, is wat het woord betekent.

Een paar dingen om te weten:

• Een ongewijzigd proces publiceren wordt geweigerd. Is er sinds de vorige publicatie niets veranderd, dan valt er niets te publiceren, en een geschiedenis vol identieke versies kan niemand lezen.
• Publicatie ongedaan maken bestaat niet. Een versie die iemand misschien aan het uitvoeren is, verwijder je niet. Wil je terug, zet dan de vorige tekening op het canvas en publiceer die — de geschiedenis blijft intact, en daarom is ze het hebben waard.
• Instanties houden de versie waarmee ze zijn begonnen. Wat onder versie 2 is begonnen, eindigt onder versie 2, wat je ook publiceert terwijl het loopt.

opmerking

Publiceren start niets. Het bepaalt wat er loopt de volgende keer dat het proces start, en uitvoeringen die al lopen houden de versie waarmee ze begonnen.

Publiceren wacht tot de lijst met problemen leeg is. Zolang de hoek van het canvas iets toont, is de knop niet beschikbaar, en als je de aanwijzer erboven houdt, staat er waarom. Een proces met problemen zou niet draaien; vroeger sloeg publiceren eerst de tekening op en werd het daarna geweigerd.

Importeren en exporteren

JSON exporteren downloadt het ontwerp als .bpms.json-bestand — wat er nu op het canvas staat, inclusief niet-opgeslagen bewerkingen, want het bestand is bedoeld om een ontwerp ergens anders heen te brengen, en de versie van vorige week exporteren terwijl je naar die van deze week kijkt, is het soort verrassing dat je pas aan de andere kant ontdekt.

JSON importeren laadt er een terug. Het vervangt wat er getekend staat en slaat niet op, dus een import die het verkeerde bestand blijkt te zijn, maak je ongedaan door het scherm te verlaten zonder op te slaan.

Het bestand wordt gecontroleerd voordat het wordt geladen: de versie, de banen, de knooppunten, en of elke verbinding echt twee bestaande knooppunten verbindt. Een bestand dat niet door de controle komt, zegt welke id niet klopte.

Zodra een proces in zijn oplossing meereist, zijn importeren en exporteren bedoeld om een ontwerp met de hand tussen omgevingen te verplaatsen — een gemak, niet de manier waarop werk wordt doorgezet. Dat doet de oplossing.

Een afbeelding exporteren

Exporteren → Afbeelding (PNG) en Afbeelding (SVG) tekenen het diagram zoals het eruitziet — voor een document, een dia of een muur. Geen van beide is het proces: ze kunnen niet terug worden geïmporteerd.

Problemen oplossen

• Mijn variabele verschijnt niet in de suggesties van de editor. — een variabele zonder naam wordt nergens aangeboden. Geef de rij een naam en verlaat het veld, zodat de naam wordt vastgelegd.

• Ik kan setVariable niet vinden in een voorwaarde. — een voorwaarde mag alleen lezen; zie hierboven. Zet de wijziging in plaats daarvan in het script van een taak.

• Een script dat ik op een taak heb geschreven, is verdwenen. — de soort van een taak wijzigen, verandert welke momenten hij heeft. Maak van een gebruikerstaak een servicetaak en Bij toewijzen en Bij voltooien worden niet meer aangeboden; bij een ontwerp dat met die scripts wordt geïmporteerd, vallen ze weg.

• "That file is not valid JSON, so it could not be imported." — het bestand is afgekapt of is helemaal geen ontwerp.

• "That file is not a valid process design: …" — de details noemen de id die niet klopt: een knooppunt in een baan die niet in het bestand staat, een verbinding naar een knooppunt dat er niet is.

• Opslaan zegt dat het ontwerp niet geldig is. — dezelfde controle draait vóór het opslaan. Herstel het knooppunt of de verbinding die wordt genoemd; het diagram op het scherm gaat niet verloren.

• Een knooppunt verschoof toen ik het proces opende. — een knooppunt dat buiten zijn baan stond, wordt bij het openen teruggetrokken. De baan van een knooppunt is wie het werk doet, dus die twee mogen het nooit oneens zijn.

• Automatisch schikken deed niets. — het schikt op stroom, dus het heeft verbindingen nodig. Een diagram met losse knooppunten heeft geen volgorde om in te schikken.

• Het problemenpaneel zegt dat een stap "nergens heen leidt". — vanaf die stap is geen Einde te bereiken. Verbind hem verder, of verbind hem met iets wat al een Einde bereikt.

• Het zegt dat mijn script niet wordt geparseerd, terwijl de code-editor er goed uitzag. — het paneel controleert elk script in het proces, ook de scripts waar je niet naar kijkt. Selecteer de regel om naar het knooppunt te gaan en open dan het slot dat wordt genoemd.

• "Er is geen AI-provider ingesteld. Open Instellingen → AI om er een te koppelen." — de organisatie heeft nog geen AI-koppeling. Een tenantbeheerder maakt die één keer, onder Instellingen → AI, voor iedereen.

• "The AI answered without a design in it." — het model antwoordde met tekst in plaats van een proces. Beschrijf de banen en de stappen eenvoudiger en genereer opnieuw; er gaat niets op het canvas verloren.

Gerelateerde scenario's

• Een proces maken.
• Een onderdeel aan een oplossing toevoegen.