61 artikelen over Samples, in leesvolgorde.
Parsware Platform
What Parsware is and how its parts fit together, shown through one real application, from the tables underneath it to the phone screen, the approval process and the printed report.
Parsware Platform
An auto-number field gives every new record a reference like EQ-2026-00001 the moment it is saved. Nobody types it, nobody can change it, and nobody has to look up the last one used. We imported the Enquiries sample, saved a few enquiries, and changed the format halfway through.
Parsware Platform
A table's constraints are rules the database itself enforces: no two records may share a code, and no two bookings of one thing may overlap. They hold for a form, an import, a script and two people saving at the same moment. We imported the Court Bookings sample and tried to break both.
Parsware Platform
A File field holds a document and an Image field holds a picture, each belonging to one record. Add one to a table, attach a file on the form, and see what Save, the size cap and the record's permissions do with it.
Parsware Platform
A file too big for the environment's database is moved to object storage on its own. The form, Download and who may read it all stay the same, and deleting the record deletes the file.
Parsware Platform
A table whose records have a parent of their own kind can be shown as a tree, with another table's records hanging underneath, the selected record's form beside it, and a check that stops a branch being moved inside itself.
Parsware Platform
Load a CSV file into a table. See what is in each column before you import, map columns to fields, and get the rows that failed back as a file to fix, with a reason on each one.
Parsware Platform
Turn auditing on for a table and every create, update and delete of its records is recorded, with who made the change and what each field was before and after. Leave out the fields that don't matter, and read a record's history in the Audit Log.
Parsware Platform
When two people edit the same record and both press Save, the second save is refused instead of silently overwriting the first. Here is what each of them sees, and how to carry on.
Parsware Platform
Building an app doesn't give it to anyone. Share it with a role, check who that actually reaches, and the app appears on their launcher and nobody else's. The sharing travels in the solution, so you don't redo it in every environment.
Parsware Platform
A timeline puts every call, email, meeting and note about a customer in one column on their form, newest first. Filter it by kind, start a new one already filled in, and set it up in the Form Designer from any table that points at the record.
Parsware Platform
Any table with a date can be read as a calendar. Pick which field says when a record starts, colour the blocks by a choice, and people click an empty slot to book it, with the rooms side by side on the day sheet.
Parsware Platform
Add your own buttons to a list's or a form's command bar. Most need no code, because they open a view, start a record or open an address. When the button depends on what the user ticked or typed, it runs a short script.
Parsware Platform
A dashboard in Parsware is a screen you draw. Counted tiles, charts, the table's own grid and its quick create form sit on one page, and the page goes into an app's navigation like any table.
Parsware Platform
When a Parsware business process needs a person, it sends them a task. My tasks lists yours; opening one takes it and shows what it is about, and Decide finishes it with an outcome such as Approve or Reject, after which the process moves on by itself.
Parsware Platform
The charts on a Parsware dashboard do more than sit there. Hover over a bar or a slice for its exact number, and select a legend entry to hide that series, so the rest can be read on its own. Here is what each one tells you, and the one thing to watch for.
Parsware Platform
A saved query in Parsware is one question with one definition. A report fills its table from it, and a server script runs it by name, so correcting the question once corrects every answer that names it, in this environment and in the next one the solution goes to.
Parsware Platform
The BS editor offers names as you type. At the start of a line it lists the functions the script's host provides, the functions it imported from a solution script, and its own variables. After a dot it lists the value's methods. Here it is in a form rule from the Expense Limit sample, with what it offers and what it leaves to you.
Parsware Platform
A server-side script can read more than the record it's working on. getRecord fetches one record, queryRecords and countRecords match one field, and runQuery takes a whole query with and/or filters, joins and totals. We used them in a plugin step that refuses an invoice when a customer would go over their credit limit, and in a Custom API that joins two tables.
Parsware Platform
When a plugin step and a Custom API need the same rule, write it once as a solution script and import it into both. We used the Shared Server Logic sample, where an approval limit decides both whether an order saves and what an API tells a partner, then changed the limit in one line and watched both follow. Here is how import and export work, and which scripts can import.
Parsware Platform
callService lets a server-side script post to another system, like a payment provider. The script never holds the address, only a service name. Each environment sets where that name points, so Test can use a sandbox and Production the real thing, and an environment that sets nothing reaches nothing. We took payments in a sample order app, and saw an answer, a refusal and a missing setting.
Parsware Platform
sendEmail sends a message through a mail service the environment names, just like callService. It never stops the script. It tells you whether the email went, and the script decides what to do about it. In the sample, a paid order records Sent or Not sent with the reason. Here is the call, what the mail service receives, and why an email step shouldn't refuse a save.
Parsware Platform
A server-side script can write a file to storage and read it back, and it can put a file into one record's File field. They're two different places for two different kinds of file. We exported expense claims as a CSV into a bucket, then attached a receipt to one claim and found it on the claim's form.
Parsware Platform
A form rule runs in the browser and changes the form as you type. In the Expense Approval sample, typing "rejected" into Status shows a Rejection reason and makes it required, and approving the claim hides it again and locks the amount. Here is the form, the three rules behind it, and the one script they share.
Parsware Platform
A claim over 1,000 needs an approval note. The form can show that as you type, but only a plugin step makes it true, because it runs on the server whatever saved the claim. We imported a spreadsheet of claims past the form and watched two rows refused with the step's message, then looked at how one script holds the limit for both sides.
Parsware Platform
A server validation rule is a plugin step that refuses a save and says why. We added one from scratch, "a claim over 10,000 needs a purchase order", then watched the editor catch a misspelt function and the form show the step's message when we saved a claim that broke it.
Parsware Platform
A plugin step is registered against a table, a write, a stage and an order, and the stage decides the most. We put a second step behind the order-stock sample's own, watched a refusal before the write undo the stock the first step had taken, then moved the same refusal after the write and watched the order line stay.
Parsware Platform
The answer to "is there enough stock?" isn't on the order line. It's on the product. We saved three order lines against a product with 10 in stock and watched a plugin step read the product, take the stock and log the movement, or refuse the line, then read the script that does it.
Parsware Platform
Not every server rule refuses. This one approves. A claim of 50 or less is marked approved as it's saved, by a plugin step that sets a value on the record before it's written. We saved a taxi fare and a hotel bill, watched only one come back approved, then watched the sample's own lock stop the approved one being edited up.
Parsware Platform
A plugin step that runs after the response has nobody to tell when it fails. So it tries five times, and then it waits on a list. We made one fail for a real reason, read the failure, fixed the setting it needed, and pressed Retry.
Parsware Platform
A loop that never ends is a typo away, and on the server it would hold a save open forever. So every script runs on a budget. We wrote two broken plugin steps, a loop counting the wrong way and a function with no way out, and read what the platform says when it stops them.
Parsware Platform
The same solution in two environments should call two different payment services, a sandbox in one and the real thing in the other, without anybody editing a script. That's what an environment variable is for. We installed one solution in two environments, gave each its own value, and saved the same order in both.
Parsware Platform
A security role says what somebody may do with a table. A data policy says which records that reaches, and when a save is refused. We imported a sample with one of each kind, gave its role to two regional managers, and watched the same grant show each of them a different list and refuse one of them an approval.
Parsware Platform
A business process in Parsware is drawn, not coded. Lanes for who does the work, shapes for the steps, arrows for the order. We opened the leave-approval sample and went round the designer: the palette, the outline, the canvas, the properties panel, and the problems panel that checks the process as you draw.
Parsware Platform
A swimlane named Manager tells a reader who does the work. It tells the engine nothing until you give the lane a Role, picked from the environment's security roles. We set one on the leave-approval sample, added a lane, and followed a role from the designer to the people who hold it.
Parsware Platform
Four shapes carry most processes: a start, tasks, a branch where the process decides, and a finish. We opened the two-step approval sample and clicked each one to see what it asks for and where it can connect, and found the designer letting a connection leave a Finish without a word. It says so now.
Parsware Platform
A task's Type puts a small badge on the step: user, service, script, manual, send, receive, business rule. Only one of them changes what a run does. We went through the list on the two-step approval sample, and say plainly what each type does and what it only describes.
Parsware Platform
A purchase order needs Finance and Legal to sign off, and neither should wait for the other. A Fork sends it to both at once, and a Join waits until they have both answered. We opened the parallel sign-off sample, and fixed three things on the way: unreadable labels, stray resize handles, and a Join whose most useful setting had no control.
Parsware Platform
You drag from one step to another to connect them, the designer draws the corners, and View → Auto arrange tidies the whole diagram without moving work between lanes. Trying it for this article found four things to fix: two kinds of overlapping lines, a drag that drew nothing, and a hint that was always in English.
Parsware Platform
A branch doesn't decide anything by itself. Each connection leaving it carries a condition, one line of BS that is true or false, and the run takes the one that's true. We read the conditions on the Leave Approval sample, tried to break them three ways, and fixed two things on the way.
Parsware Platform
Every step in a process can run code at the moments that matter to it: when the run arrives, when the task is given to someone, when they finish it, when the run leaves. A user task also works out who gets it and which record they look at. We opened the manager's step in the Leave Approval sample and went through all six.
Parsware Platform
A user task has to land in somebody's list. It goes to whoever its Assigned to answers, or failing that whoever holds its lane's role in the run's unit, and a step can refuse the person who started the run. We went through each on the Leave Approval sample, and found the help page telling people to write something that doesn't work.
Parsware Platform
A process carries values from one step to the next: what the manager decided, how many days were asked for. Each is a variable, declared once on the process with a name and a type, given a first value in On start, and read and written by name. We added one to the Leave Approval sample and misspelt another on purpose.
Parsware Platform
The process designer checks the drawing as you draw it, and the corner of the canvas says what is still missing: a step nothing reaches, a step that leads nowhere, a timer that never fires, a misspelt variable. Selecting a line takes you to the thing it is about. Nothing stops you saving, but Publish now waits for the list to be empty.
Parsware Platform
When a process step reaches a person, they read what it opens and then decide. A coform is what they decide on: a few fields and the buttons that end the step. We built one in the parallel sign-off sample, put it on a task, and routed each button its own way. The field types now read as words.
Parsware Platform
A process design is a plain JSON file you can export, edit and import, and the import checks it before anything reaches the canvas. Export a picture, PNG or SVG, for a document or a slide. Trying both, we fixed two things: the pictures now carry the lane names, and a refused file names the missing node.
Parsware Platform
A drawn process that nobody's software follows is a poster. In Parsware the drawing is what runs: you draw who does what on swimlanes, publish a version, and the engine starts it from a record, sends each step to the right person's task list, and keeps a history of every run. This is how the three parts fit together.
Parsware Platform
Save keeps your work; Publish changes what runs. Each publish is a numbered version, a run keeps the version it started on, and the line under the title says whether what you see is live. Writing this we found Publish stopping after it saved unsaved edits, and fixed it.
Parsware Platform
A change request goes to one person, who may correct it, then to a second, who reads a report of it and approves or rejects. We ran it as two different people, and the run's history says who decided each step. Writing this we found four things that only an administrator never notices, and fixed them.
Parsware Platform
An employee asks for a week off, their manager decides, and a branch sends the request one way or the other. We ran it as both people and read the run afterwards. The sample shipped with roles that only opened the app and a manager's step that said read-only; both are fixed.
Parsware Platform
A purchase order goes to Finance and Legal at the same moment, two people decide on their own, and the process waits for both before it gives one answer. We ran it with Finance signing off and Legal refusing, and watched the run wait at the join in between.
Parsware Platform
A step can be due within a set time, and when it isn't done, the process can offer it to somebody else as well or decide it by itself. A timer makes the process wait. We ran a support ticket through all three, and fixed five things on the way, starting with the designer turning every timer into a plain task.
Parsware Platform
A process can start by itself when a record is created, changed or deleted, or from a button on the record's form and list. Either way the run knows which record it's about. Running the sample as two people found a status that never changed and people named by their email address; both are fixed.
Parsware Platform
Small requests go to a department head, bigger ones to the finance director, the biggest to a committee as well. The bands live in a table finance edits, not in the process, so moving one changes who decides the next request. The sample said it worked this way and didn't; now it does.
Parsware Platform
Every run of a process has a page: the route it has taken so far, where it is now, who it's waiting on, and everything that has happened, in order. From there you can pause it, stop it, or hand a waiting task to somebody else. We followed one change request from start to finish.
Parsware Platform
A run's page says where one request has got to. A process's Insights screen says what keeps happening: how many runs got through, how long work waits before anybody picks it up, where runs stall, and how decisions usually go. Trying it, we fixed two things: decisions are named by their button, and the people view names people.
Parsware Platform
A process moves between environments the way everything else does: in its solution, with its table, its form, its app and its roles. Import publishes it, and uninstall takes it out again. Trying that with a run still waiting, we fixed what happens to the run: it's now stopped, and its history says why.
Parsware Platform
Studio screens and reports are drawn on one canvas, the Graphic Designer. Here's where everything is: the toolbar, the tool rail, the layers and components on the left, the inspector on the right. Touring it, we fixed two small things in its right-click menu.
Parsware Platform
Pan with the wheel, zoom with Ctrl, and press Shift+1 to see the whole drawing or Shift+2 to fill the window with what you selected. Trying them, we found the zoom keys missing and added them.
For Power Apps
The Parsware Samples solution brings two small tables, eight finished reports, two Studio apps and an app that opens them. The tables arrive empty, because a solution carries components and not rows, so one page fills them with 200 rows each. Here is what's in it and how to fill it.
For Power Apps
The fastest way to a report of your own is often one that already works. The Parsware samples come with an editable copy of each drawn design, so you can rename one, change it and publish it into your own solution, while the original stays exactly as it shipped.
