Sprint 1: Web App

Complete the tasks for Sprint 1 for development for web app for anxiety. It has two epics and 11 issues. Complete all tasks. Attached is UI design and service layer design.

Projects:

UI Development

Service Layer Development

Tasks Backlogs:

UI Development:

Design homepage layout

Design login/register page

Design mood tracking page

Design journal entry page

Design coping resources page

Design a community forum page

Service Layer Development:

Implement user authentication endpoints

Implement mood entry endpoints

Implement journal entry endpoints

Implement coping resources endpoints

Service Layer DesignAnxiety Journal Web Application
Chelsea Long
Maryville University
SWDV 691
Database Design
Justification of Database Choice:
For the Anxiety Journal web application, MongoDB, a NoSQL database, is chosen due to its
flexibility and scalability, which align well with the dynamic nature of the application’s data
and potential future growth.
Reasons for Choosing MongoDB:
1. Flexibility: MongoDB’s document-based model allows for flexible schema designs,
accommodating changes in data structure over time.
2. Scalability: MongoDB is horizontally scalable, enabling seamless handling of
increasing data volumes and user loads.
3. Performance: MongoDB’s efficient indexing and querying capabilities ensure fast and
responsive data access, which is crucial for real-time user interactions.
4. Ease of Development: MongoDB’s JSON-like documents are familiar to developers,
facilitating rapid development and iteration.
5. Community Support: MongoDB has a large and active community, providing
extensive documentation, tutorials, and support resources.
Data Structures:
The following Collections and Documents will be stored in the MongoDB database:
Users (Employee Records):
•Collection Name: Users
•Document Structure:
{
“_id”: string (auto-generated id by MongoDB),
“email”: string,
“salt”: string,
“hash”: string,
“fullName”: string,
“username”: string
}
•Purpose: Storing pre-existing employee records for essential login interaction.
•Implementation: Each document represents a user with email, salt, hash for password
security, full name, and username.
•Interaction: Basic login authentication.
Posts:
•Collection Name: Posts
•Document Structure:
{
“_id”: string (auto-generated id by MongoDB),
“title”: string,
“image”: string (reference URL to the cloud-stored image),
“content”: string,
“created”: string (used for sorting purposes),
“author”: string,
“spending”: boolean,
“approvedOn”: string,
“approvedBy”: string
}
•Purpose: Holding information about blog posts.
•Implementation: Each document represents a blog post with attributes including title,
image URL, content, author, and approval status.
•Interaction: Creating, reading, updating, and deleting blog posts.
Reviews:
•Collection Name: Reviews
•Document Structure:
{
“_id”: string (auto-generated id by MongoDB),
“age”: int,
“name”: string,
“email”: string,
“message”: string,
“created”: string,
“image”: string (reference URL to the cloud-stored image),
“isPending”: boolean,
“approvedOn”: string,
“approvedBy”: string
}
•Purpose: Storing information about reviews of the company.
•Implementation: Each document represents a review with attributes such as age, name,
email, message, and approval status.
•Interaction: Submitting, approving, and rejecting reviews.
Inquiries:
•Collection Name: Inquiries
•Document Structure:
{
“_id”: string (auto-generated id by MongoDB),
“userInfo”: {
“name”: string,
“email”: string
},
“message”: string
}
• Purpose: Holding information about inquiries submitted by end users.
• Implementation: Each document represents an inquiry with user information and a
message.
• Interaction: Submitting and managing inquiries.
Data Structure Usage:
•Users: Used for user authentication and profile management.
•Mood Entries: Used to track user moods over time.
•Journal Entries: Used for users to record their thoughts and experiences.
•Coping Resources: Provides users access to helpful resources for managing anxiety.
•Forum Posts/Replies: Facilitates user interaction and support within the community forum.
System Layer Design
Service Endpoints:
1. User Authentication:
/API/auth/login (POST): Users log in using their custom username and password.
/API/auth/register (POST): Users can register their account here.
2. Mood Entries:
/API/moods (GET): Fetches all mood entries concerning the authenticated user.
/API/moods (POST): Sets up a fresh mood entry for the logged-in user.
3. Journal Entries:
/API/journal (GET): Finds all journal entries with the authenticated user.
/API/journal (POST): A new entry for a specific authenticated user is made.
4. Coping Resources:
/API/resources (GET): Allows users to pinpoint and implement all available coping
mechanisms.
5. Forum Posts:
/API/forum/posts (GET): Retrieves all forum posts.
/API/forum/posts (POST): A new thread exists.
6. Forum Replies:
/API/forum/posts/{post_id}/replies (GET): Pulls in all replies to a specific forum post.
/API/forum/posts/{post_id}/replies (POST): Crafts a new message in response to a forum
thread.
Purpose of Endpoints:
• User Authentication: A user’s registration and login are provided.
• Mood Entries: Charting user’s moods over time.
• Journal Entries: Enable users to put down their thoughts and adventures.
• Coping Resources: Enables the consumers to have a point of reference for
managing anxiety.
Forum Posts/Replies: Encourages users to open the community forum to post their
questions and reply to other users.
Example Requests and Responses:
Login Request:
POST /API/auth/login
Request Body:
{
“username”: “example_user”,
“password”: “example_password”
}
Response (Success):
Status: 200 OK
Body:
{
“user_id”: 1,
“username”: “example_user”,
“token”: “example_token”
}
Response (Error – Invalid Credentials):
Status: 401 Unauthorized
Body:
{
“message”: “Invalid username or password.”
}
Create Mood Entry Request:
POST /API/moods
Request Body:
{
“mood_rating”: 7,
“entry_date”: “2024-03-25”,
“entry_content”: “Feeling calm and relaxed today.”
}
Response (Success):
Status: 201 Created
Body:
{
“entry_id”: 1,
“mood_rating”: 7,
“entry_date”: “2024-03-25”,
“entry_content”: “Feeling calm and relaxed today.”
}
Response (Error – Unauthorized):
Status: 401 Unauthorized
Body:
{
“message”: “Unauthorized. Please log in.”
}
Communication Diagram:
This diagram illustrates the flow of communication from the user interface pages to the
service endpoints, depicting how requests are made and responses are received.
Service Layer
User Interface
HTTP Request (GET)
HTTP Response
HTTP Request (POST)
HTTP Response
Log In Page
1/5
A Web Page
https://mentalhealthjournal.com/journal/new
Log In
Username
Password
Log In
Create Account Page
2/5
A Web Page
https://mentalhealthjournal.com/journal/new
Create Account
Full Name
Password
Confirm Password
Email
Create Account
Dashboard
3/5
Home Page
https://mentalhealthjournal.com
Mood Tracker for Past Week
How is your mood today?
1: Extremely Sad 10: Extremely Happy
5
Submit
Journal Entries
View More
Resources
View More
Create New Entry
Create Journal Entry
4/5
A Web Page
https://mentalhealthjournal.com/journal/new
New Journal Entry
Post Publicly in Community Forum
Save
Community forum
5/5
A Web Page
https://mentalhealthjournal.com/journal/new
Community Forum
Username
10 Comments
Username
10 Comments
Chelsea Long
SWDV 691
Storyboards
Storyboard 1
Objective: Sarah wants to track her mood and log her current mood.
1. Sarah logs in
2. From the dashboard, Sarah views her progress in the past week or month, then logs her
current mood using the dropdown and presses the submit button
Storyboard 2
Objective: Johnson wants to start journaling his experience
1. Johnson creates an account
2. John clicks on the create new Journal entry button in the dashboard.
3. Johnson fills in the text area and chooses whether to post publicly in the community
forum then presses the save button.
OUTLINE
Project Proposal for an Anxiety Journal Web Application
I.
Project Description Write-Up
a. Introduction
b. Problem to solve
c. User personas
d. Value proposition
e. User interaction
II.
Minimum Viable Product (MVP) Write-Up
a. High-Level Overview of Features
b. Minimal Set of Features
c. High-Level Architecture Picture
d. High-Level Description of Data Required