Reference no: EM132845580

COMP1610 Programming Enterprise Components - University of Greenwich

Learning Outcome 1. Design, develop and deploy reliable and secure enterprise applications using a variety of Jakarta EE technologies.

Learning Outcome 2. Critically evaluate and compare enterprise features in Jakarta EE and determine their applicability in the creation of enterprise applications.

Learning Outcome 3. Demonstrate in-depth knowledge and understanding of techniques and technologies for the development of distributed systems, including the use of service-oriented architectures.

A bank account management system using Jakarta EE technologies.

Coursework Specification

A financial institution (bank) has approached you to build an application for them to manage bank accounts for their customers. They emphasised on the reliability, scalability and easy extensibility aspects (if new features need to be added or existing ones might be modified) of the developed application.

The functional requirements of the system are outlined below in terms of operations [activities that the customer can perform on their accounts], and views [visualisation aspects]:

i) A customer can open three different types of accounts, e.g., savings, current/checking, and ISA (individual savings account). However, the developed application should keep provisions to add other types of accounts [e.g., investment, child, etc.] in future as well to be relevant in the face of changing banking sector. In other words, the developed code should be easily extensible if needed to incorporate more account types.

Keep the attributes of the bank accounts as compact as possible. For example, bank sort code, branch name, IBAN, and account number are necessary attributes for each account. Please add additional attributes only if they are required for addressing the functionalities which are mentioned below. Follow similar principle for the customer attributes too (name, passport/id, address, phone number, email, and his/her login credentials might be necessary).

ii) A customer should be able to transfer or move his/her money from one account to another via the application besides the usual deposit, withdraw and view balance operations. You should also keep provisions to pay from a customer's account to an external account [payee account], and via direct debit payment options.

iii) A few views are primarily required: 1) a summarised view of number of accounts held by a single customer and the balance of each account, and 2) A detailed view of his/her particular account with transactions for the current month,

iv) A user interface (UI) addressing all the above functionalities. It should be a Web application using Jakarta EE, which offers 1) customer log-in and 2) the execution of the above functionalities that are mentioned in i), ii) and iii) through the UI. The implementation should use entity classes and java beans for back-end functionality and JSP/JSF for the front- end (including HTML/CSS incorporation if it is required).

The whole coursework is divided into six tasks which you are required to carry out. The tasks are described in detail in the following. Please read and follow the instructions carefully. Task 2 should be attempted only after completing Task 1.

Task 1:
A complete working system addressing the functionalities required thus far. Remember, there are many provisions to utilise object-oriented (OO) design and programming for this case study. Make sure you outline them in your report - see Section 3 of Task 6 for more information.

You are free to draw any valid assumption that are not in conflict with the system's functional requirements. For example, the customers may already be loaded inside the system/database "offline". There is no need for a registration system for customers in this coursework. You may initialize the data in your database using an SQL script (or equivalent) so that it has some initial data in order to fully demonstrate the functionality that you have implemented. You can use any relational database management system that you prefer (e.g.,

JavaDB, MySQL, etc.). Make sure the database is normalised with primary/foreign key constraints.

You can assume a customer only need a login ID and password to access the system that you have implemented. In other words, your application's first page or window should be a login screen requiring only the login ID and password. You SHOULD have a default pre- existing account created [log ID: ha07, password: ha07] which will be used by your tutor for login while marking.

Task 2:
Suppose a new type of payment method (e.g., standing order) needs to be added on top of the existing ones as discussed in functionality (ii) [Page 3]. Also, there should be provisions to add joint accounts [another type of account] for customers.

Remember these tasks will only be attempted after you finish Task 1 - not at the same time. As a result, you will be able to identify and discuss the pros and cons of integrating this new type of payment method (and account type) to the already existing system which we are looking for here.

In your documentation (Section 2 of Task 6), you need to address the following under this task:
1) A list of files that you needed to change to incorporate
2) Screenshot of the code segments which were added or modified to achieve this.
3) A discussion of pros and cons of your followed approach. Reflect if there could have been any better approach. If yes, how?

Task 3:
Incorporate ORM Frameworks using a Java Persistence API (e.g., Hibernate) inside your application. You can adopt this from the beginning in Task 1 (might be easier) or can adopt it even after completing the above tasks.

Task 4:
Create a Web Service (SOAP or REST) which exposes this application's functionality to be consumed by other applications. The Web service will accept a date from a customer and his bank account detail and will return that day's number of transactions (+list of transactions).

Subsequently, create a small Java application [e.g., desktop client] that will retrieve the transactions of a given day from the server. For example, if a customer wants to retrieve the transactions of 1st January, 2021 of his/her particular bank account, the date (parameter) will be included inside the request together with the bank account details from this client. The reply from the server will consist of the number of transactions + the list of transactions on that day for that account. Keep your client application as simple as possible [any type of simple UI is accepted for this application - Graphical UI is not required but you are free to build one if you prefer]. Note that, you may also need to authorise this application with the server [customer's login credentials] to retrieve the transaction of his/her account on that day.

Task 5:
The above functionalities are the core requirements of the application. Additionally, there is an opportunity if you want to demonstrate additional skillset. You can integrate any relevant additional features (i.e., functionalities) making use of Jakarta EE technologies for this task. For example, if you can containerise the whole application using Jakarta EE, GitHub, Docker etc. (or even hosted from Cloud) to make it platform independent, that can enhance your development skills overall. This is just only an indication of the additional feature [not mandatory] - you are of course free to choose any feature here as long as they are Jakarta EE development related tools/techniques.

Task 6:
Prepare a final report which should contain the following sections:
Section 1: A concise table containing a checklist of the tasks that you have been able to implement. Please refer to the task list d discussed above. An example table may look like:

Task	Implementation Summary
1	Implemented. Only one view (summary of accounts) is addressed though.
2	Implemented but the joint account type could not be integrated with the existing system.
3	Fully implemented.
4	Implemented but only the server side (no client application)
5	No additional feature/functionality was implemented.

Section 2: Screenshots demonstrating each of the tasks that you have implemented. Create separate sub-sections for each task and give captions and/or annotations for the screenshots to explain which functionalities of the task are being demonstrated. Do not forget to address the specific documentation requirements mentioned for Task 2 in this part.

Section 3: Critically reflect (maximum: 500 words) on your experience of using the various design and coding techniques that you may have adopted in the context of building this system, especially:
1) If you have utilised any of the four pillars of OOP. Identify where and why [i.e., benefits]?
2) The relevant Jakarta EE technologies adopted and their relevance (or benefits) with respect to the coursework.

Attachment:- Programming Enterprise Components.rar