In this demonstration we
will build a simple employee directory application.
The first thing we will do
is build a new database table named “Employee.”
In the table, we will define
several attributes and define their specific properties.
We can define the database
model here visually. And the Agile Platform will
take care of creating and updating the physical tables
once we deploy the application. Now for the user interface, we
will create a user navigation flow to list and edit employees.
We will create a web page
on our flow diagram to list employees, and a second to
edit employee details, and to create new employees.
Once we deploy the application,
the Agile Platform will automatically generate the
ASP.NET or JSF web pages and deploy them in the
Now let’s create the
user interface for the employee list page.
We will set the title of the
page to “Employee List,” and add a widget to list all
employees in the employee table. For that we will need to
add a query to the page preparation logic.
We can name it “GetEmployees,”
and define it visually using the employee table we
created previously. We will order the
query results by name.
Now let’s bind our query
to the user interface.
We will also create a
link so that users can create new employees.
This link will navigate to
the employee details web page, which will also serve to edit
existing employees in the database.
For the added capability, we
will need to pass the selected employee ID to the employee
detail page in order to edit a particular employee’s details.
As you can see, web page inputs
are typified and validated for coherence to prevent mistakes.
Now let’s create the employee
detail user interface. We will change the title of the
page to “Employee Details,” and insert a form widget, which
will allow us to edit existing details or add new employees.
We will add a button
to save our changes. Those changes will need to be
saved in the database, so under the processing logic, we will
add the action to create or update the employee.
As you can see here, for
all created tables the Agile Platform automatically
gives you APIs to handle data on these tables.
After creating or updating the
employee in the database, we will provide the end user
with a nice feedback message. In the end, we want to return
to the Employee List web page. On deploy, all this logic
will be compiled by the Agile Platform into standard C# or
Java code, and be deployed to the application server.
Finally, we need to supply
the form with an existing employee’s detail as selected
in the Employee List web page. For this, we will add a query
to our employee detail preparation logic, which gets
the employee details of the employee we want to edit, and
we will feed the form widget with the results of the query.
Now we can simply publish our
new application by using the Agile Platform’s 1-Click
Publishing capability. By doing this, the Agile
Platform will take care of creating the new database
table, generating all of our application code, and deploy
the final application to the application server.
Once we open the browser,
we can execute our new application.
Here it is — simple.
Since there are no employees
in the database, we will create a new one named John Doe,
with an email address of [email protected]
We can save this new employee.
See the feedback message at
the top of the employee list window letting us know our
action was successful. Now let’s edit John’s details
to see if this is working.
There it is — a working
application in less than five minutes.
Thanks for watching.