1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
|
---
geometry: margin=1in
---
# PROJECT Design Documentation
## Team Information
* Team name: Jelly Solutions
* Team members
* Ben Almstead
* Tyler Ferrari
* Hayden Hartman
* Akash Keshav
* Angelina Zhen
## Executive Summary
Our project is intended to create a space to fund aquatic conservation, from physical ecosystems such as coral reefs to aquatic creatures such as jellyfish. Users will be able to donate funds, both physical and monetary, to individal 'needs', and see how close to reaching a funding goal each need is.
### Purpose
The purpose of this project is to provide an avenue for companies to crowd-fund and for users to contribute to funds of their choosing.
> _**[Sprint 2 & 4]** Provide a very brief statement about the project and the most
> important user group and user goals._
### Glossary and Acronyms
> _**[Sprint 2 & 4]** Provide a table of terms and acronyms._
| Term | Definition |
|------|-------------|
| SPA | Single Page |
## Requirements
This section describes the features of the application.
The requirements for this u-fund project to be functional include a system for organizations (administrators) to create funding goals (needs) that can be satisfied by clients (users).
> _In this section you do not need to be exhaustive and list every
> story. Focus on top-level features from the Vision document and
> maybe Epics and critical Stories._
### Definition of MVP
> _**[Sprint 2 & 4]** Provide a simple description of the Minimum Viable Product._
Users are able to login to the Ufund, either as a manager or helper. Helpers are able to go to the cupboard and can view needs, search for needs, add/remove needs to their funding basket, and check out and fund needs. Managers can add, remove, and edit needs in the cupboard. Needs are saved so users and managers will see when they are updated.
### MVP Features
> _**[Sprint 4]** Provide a list of top-level Epics and/or Stories of the MVP._
### Enhancements
> _**[Sprint 4]** Describe what enhancements you have implemented for the project._
Security
- We have implemented a set of security features to enhance the security of the application
- We have added an authentication system, which verifies a user can access the correct pages, and keeps them logged in after they have logged in once
- We have also added a number of password requirements to our signup page, guaranteeing users have strong passwords to keep their accounts secure
Sort filters
- We have implemented a number of sorting filters in the cupboard, allowing users and managers to easily sort through needs with different priorities
- You can sort by funding goal
- You can sort by Location
- You can sort by name
- You can sort by an urgency tag on needs
- You can sort by type of need
- You can sort by most completed
## Application Domain
This section describes the application domain.
> _**[Sprint 2 & 4]** Provide a high-level overview of the domain for this application. You
> can discuss the more important domain entities and their relationship
> to each other._
Each user views 1 cupboard which can contain 0 or more needs. They can take 1 or more needs and put them in their funding basket which they can then check out. 1 or more managers will manaager the 1 cupboard, add, removing, and editing needs within it.
## Architecture and Design
This section describes the application architecture.
### Summary
The following Tiers/Layers model shows a high-level view of the webapp's architecture.
**NOTE**: detailed diagrams are required in later sections of this document.
> _**[Sprint 1]** (Augment this diagram with your **own** rendition and representations of sample system classes, placing them into the appropriate M/V/VM (orange rectangle) tier section. Focus on what is currently required to support **Sprint 1 - Demo requirements**. Make sure to describe your design choices in the corresponding _**Tier Section**_ and also in the _**OO Design Principles**_ section below.)_
The web application is built using the Model–View–ViewModel (MVVM) architecture pattern.
The Model section contains our back-end structure, split into three sections: Model, Persistence, and Controller. Each of the files contained for each section are below each item.
The View is the client-side SPA built with Angular utilizing HTML, CSS and TypeScript. The ViewModel provides RESTful APIs to the client (View) as well as any logic required to manipulate the data objects from the Model.
Both the ViewModel and Model are built using Java and Spring Framework. Details of the components within these tiers are supplied below.
### Overview of User Interface
This section describes the web interface flow; this is how the user views and interacts with the web application.
> _Provide a summary of the application's user interface. Describe, from the user's perspective, the flow of the pages/navigation in the web application.
> (Add low-fidelity mockups prior to initiating your **[Sprint 2]** work so you have a good idea of the user interactions.) Eventually replace with representative screen shots of your high-fidelity results as these become available and finally include future recommendations improvement recommendations for your **[Sprint 4]** )_
Home Page:
Login Page:
Signup Page:
Dashboard:
Cupboard:
Need page:
Funding basket:
### View Tier
> _**[Sprint 4]** Provide a summary of the View Tier UI of your architecture.
> Describe the types of components in the tier and describe their
> responsibilities. This should be a narrative description, i.e. it has
> a flow or "story line" that the reader can follow._
> _**[Sprint 4]** You must provide at least **2 sequence diagrams** as is relevant to a particular aspects
> of the design that you are describing. (**For example**, in a shopping experience application you might create a
> sequence diagram of a customer searching for an item and adding to their cart.)
> As these can span multiple tiers, be sure to include an relevant HTTP requests from the client-side to the server-side
> to help illustrate the end-to-end flow._
> _**[Sprint 4]** To adequately show your system, you will need to present the **class diagrams** where relevant in your design. Some additional tips:_
>* _Class diagrams only apply to the **ViewModel** and **Model** Tier_
>* _A single class diagram of the entire system will not be effective. You may start with one, but will be need to break it down into smaller sections to account for requirements of each of the Tier static models below._
>* _Correct labeling of relationships with proper notation for the relationship type, multiplicities, and navigation information will be important._
>* _Include other details such as attributes and method signatures that you think are needed to support the level of detail in your discussion._
### ViewModel Tier
> _**[Sprint 1]** List the classes supporting this tier and provide a description of their purpose._
The ViewModel contains the SpringBoot framework, which can be run on any modern operating system. This framework handles the REST API requests for the needs, incuding the creation, deletion, and search for needs stored on the system. Additionally, jackson is used for JSON serialization.
> _**[Sprint 4]** Provide a summary of this tier of your architecture. This
> section will follow the same instructions that are given for the View
> Tier above._
> _At appropriate places as part of this narrative provide **one** or more updated and **properly labeled**
> static models (UML class diagrams) with some details such as associations (connections) between classes, and critical attributes and methods. (**Be sure** to revisit the Static **UML Review Sheet** to ensure your class diagrams are using correct format and syntax.)_
>
### Model Tier
> _**[Sprint 1]** List the classes supporting this tier and provide a description of there purpose._
The Model Tier contains the classes responsible for handling and serving Need data. In the model subsection is our Need.java, which handles the Need class itself and provides helper functions to get and set Need data. The persistence subjection handles stored data, using Data Access Objects (DAOs). The Controller section connects the two previous ones, handling the transfer of Needs to persistent storage.
> _**[Sprint 2, 3 & 4]** Provide a summary of this tier of your architecture. This
> section will follow the same instructions that are given for the View
> Tier above._
In our model tier we have a Need class, a User class, and a UserAuth class. The Need class represents needs and has fields for all of their values. Users have a passwordHash field, storing a hashed version of their password, an List of integers, representing the ID's of needs in the basket, and the userType which determines their privileges. The UserAuth class stores a key, a username, and expiration. A key is generated for a user and is used to authenticate the user. The username is the name associated with the key and the expiration is how long until the user must login again.
> _At appropriate places as part of this narrative provide **one** or more updated and **properly labeled**
> static models (UML class diagrams) with some details such as associations (connections) between classes, and critical attributes and methods. (**Be sure** to revisit the Static **UML Review Sheet** to ensure your class diagrams are using correct format and syntax.)_
>
## OO Design Principles
> _**[Sprint 1]** Name and describe the initial OO Principles that your team has considered in support of your design (and implementation) for this first Sprint._
- Law of Demeter: Classes only talk to nearby classes.
- This principle is used to ensure that unintended behavior is minimal, by making each class only talk to others that make sense in the scope of the application. For example, the `dashboard` component interacts with the `need-list` and `funding-basket` components because they are needed to display needs on the dashboard, but it does not interact with the `login` or `signup` components, as they are not needed in order to ensure the functionality of the dashboard. These are located in the ViewModel and Model Tiers.
- Low Coupling: Limit the number of classes connected to each individual class.
- We use Low Coupling principles to ensure that only classes related in function are actually interacting with each other. In our Angular setup, classes interact with their respective services instead of sharing the data with other classes. `NeedService` connects to `need-page`, `need-list`, `funding-basket`, and `cupboard`, but the components themselves do not interact with each other. This is more efficient and prevents one component from stalling if another errors. Because the service exclusively handles CRUD operations, it will not cause the connected components to stall if it encounters an error. These examples are located in the ViewModel Tier.
- Pure Fabrication: Using helper functions to split up larger classes into more managable chunks.
- For example, this principle is showcased in our `AuthService`. Instead of having the `UserService` handle user management and user authorization at the same time, we have split the authorization part into a new AuthService class to handle login, while the UserService handles just the CRUD operations pertaining to the user. These classes are located in the ViewModel Tier.
- Single Responsibility: Each function should only have one function to prevent unintended errors.
- This principle is used in our `CupboardController`, as it's only functionality is to connect the front-end and back-end through our REST API. This means that cupboard-related operations are not backlogged by any other classes, which is efficient and prevents unintended behavior in the application. This can be seen in the Model Tier.
> _**[Sprint 2, 3 & 4]** Will eventually address upto **4 key OO Principles** in your final design. Follow guidance in augmenting those completed in previous Sprints as indicated to you by instructor. Be sure to include any diagrams (or clearly refer to ones elsewhere in your Tier sections above) to support your claims._
> _**[Sprint 3 & 4]** OO Design Principles should span across **all tiers.**_
## Static Code Analysis/Future Design Improvements
> _**[Sprint 4]** With the results from the Static Code Analysis exercise,
> **Identify 3-4** areas within your code that have been flagged by the Static Code
> Analysis Tool (SonarQube) and provide your analysis and recommendations.
> Include any relevant screenshot(s) with each area._
> _**[Sprint 4]** Discuss **future** refactoring and other design improvements your team would explore if the team had additional time._
## Testing
> _This section will provide information about the testing performed
> and the results of the testing._
Currently around 2,200 tests, with roughly 90% coverage overall. Model tier is above 95% individually.
### Acceptance Testing
We have 24 passing Acceptance Tests and 5 failing Acceptance Tests. 4 of these failures are unable to be tested because of a missing feature, as it is not a requirement for our sprint backlog. All issues that have been found are easily fixable during the next sprint.
> _**[Sprint 2 & 4]** Report on the number of user stories that have passed all their
> acceptance criteria tests, the number that have some acceptance
> criteria tests failing, and the number of user stories that
> have not had any testing yet. Highlight the issues found during
> acceptance testing and if there are any concerns._
### Unit Testing and Code Coverage
> _**[Sprint 4]** Discuss your unit testing strategy. Report on the code coverage
> achieved from unit testing of the code base. Discuss the team's
> coverage targets, why you selected those values, and how well your
> code coverage met your targets._
>_**[Sprint 2, 3 & 4]** **Include images of your code coverage report.** If there are any anomalies, discuss
> those._
## Ongoing Rationale
>_**[Sprint 1, 2, 3 & 4]** Throughout the project, provide a time stamp **(yyyy/mm/dd): Sprint # and description** of any _**major**_ team decisions or design milestones/changes and corresponding justification._
**(2025/02/12): Sprint #1: Decided on the U-fund theme as Aquatic / Coral Reef.**
**(2025/02/15): Sprint #1: Outlined structure of Back-End Application.**
**(2025/03/17): Sprint #2: Decided on Important Stories for Sprint 2 Backlog, and reworked Design Architecture.**
**(2025/04/03): Sprint #3: Unanimously decided on enhancements, while narrowing focus on what needs to be finished for the sprint.**
|
