Full-Stack Health Care App: Spring Boot & Angular

Kick off the back end by creating a Spring Boot project with Spring Initializr, adding web, JPA, security, validation, Lombok, Thymeleaf, and mail dependencies, then configure Java and database.

Connect a Spring Boot app to a database using spring data source properties and a dot env file, with ddl-auto set to update for development and validate for production.

Add external dependencies for JSON Web Token authentication and model mapper, update pom.xml with JWT API and Jackson, then synchronize Maven projects.

Structure the project into modular packages to enhance manageability. Create packages for appointment, consultation, doctor, patient, users, notifications, session, config, security, and rules, plus a response class and enums.

Configure app config to set up a template engine and loader that scans the templates folder for HTML files with UTF-8, and configure a model mapper with standard field matching.

Create enums for appointment status, blood group, genotype, notification type, and doctor specialization to standardize data in the telemed app. Include values like scheduled, no show, email, and general practice.

Create custom exception classes and a global exception handler using controller advice to return a unified json response for bad requests (400), not found errors (404), and other exceptions.

Implement a custom authentication entry point and a custom access denied handler in Spring Security. Return JSON error responses with an object mapper and use 401 and 403 statuses.

Create a role module with controller, entity, repo, and service; define a JPA role entity with an auto-generated id and unique name mapped to rows, plus a repository.

Define the user entity with name, email, password, and profile picture, and a many-to-many relation to roles via user_rows join table; implement a user dto and a jpa repo.

Designs a password reset system by implementing a password reset code entity and repository, with unique codes, expiration, and a one-to-one user relationship, plus reset password DTOs and login tokens.

Create the notification entity, dto, and repository; define id, subject, recipient, message, and type as an enum type string, plus createdat timestamp and a user relation with user_id.

Define a patient entity with a one-to-one user link and one-to-many appointments, including dob, phone number, allergies, blood group, genotype; provide patient and user DTOs and a find-by-user repository.

Create a doctor entity with JPA mappings, a doctor DTO, and a doctor repository to manage doctors linked to users and their appointments, including queries by user and specialization.

Build an appointment entity, its dto, and a repository to manage doctor and patient links. Include fields like start time, end time, meeting link, purpose, symptoms, status, and consultation.

Build the consultation module with a detail entity, capturing id, date, subjective notes, findings, assessment, plan, and appointment reference, plus a repo for finding by id, appointment, or patient history.

Clean up entity imports across consultation, notifications, patients, appointments, and users; build the project to spot and fix import errors, then prepare for the upcoming security implementation.

Create an auth user class implementing Spring Security user details, mapping user roles to authorities. Use the user's email as the username and the password for authentication.

Implement a custom user details service in Spring Security by loading users by email from the user repository, handling not found errors, and building an auth user for JWT integration.

Develop and validate a json web token with a jwt service that uses a secret and 30-day expiry, configured via application properties and environment variables, signing with sha-256.

Implement a spring security jwt auth filter to intercept requests, extract bearer tokens from the authorization header, load user details via a custom user details service, and set security context.

Configure a security filter chain in Spring Security to expose auth and doctors routes, enforce authentication for others, and use jwt-based authentication, bcrypt, and entry point and access denied handlers.

Configure cors in the full-stack health care app by defining a url-based configuration, specifying allowed origins, headers, and methods, and registering the course config.

Configure smtp settings in spring boot using smtp.gmail.com:587, enable smtp auth and tls, and source credentials from env vars mail user and mail pass.

Implement a notification service that sends emails asynchronously using a mail sender and template engine, handling notification details and user data with logging and persistence.

Use a command line runner to trigger a dummy email via the notification service, building a notification dto with recipient, subject, and message, and verify the email was sent.

Build and integrate email templates for a telemedicine app using spring boot and angular. Cover welcome, appointment confirmation, password reset, and cancellation emails with variables like name and login link.

Design and implement a rule service in the full-stack telemed app, providing create, update, list, and delete operations for rule entities with a standardized response wrapper.

Define a rest controller for rule management with pre-authorization for admin. Expose endpoints to create, update, fetch all, and delete rules using a rule service and response entities.

Run the app on port 8086 and use Postman to create and retrieve rows via /rows. Validate that admin-only routes require authentication and that admin, doctor, and patient roles exist.

Implement user registration, login, and password reset flows in a Spring Boot and Angular telemed app by building an auth service, handling roles, and creating patient or doctor profiles.

Showcases a patient and doctor profile creation flow in a telemed app, building patient and doctor entities, saving them, and sending a welcome registration email with a login link.

Develop and test the registration endpoint in a Spring Boot app, validating registration requests for patients and doctors at /api/auth/register. Verify welcome emails and database entries for new users.

Implement a secure login flow that validates email and password, authenticates the user, generates a jwt token, and returns a login response with user roles and status.

Implement and test the login api by adding a login endpoint in the auth controller, validating login requests, and verifying token generation for patient and doctor logins via postman.

Generate a five-character alphanumeric code for forgot password requests. Ensure code uniqueness by checking the password reset repository and integrate with the auth service to email a reset link.

validating the user email, deleting old reset codes, regenerating a new five-hour reset code, saving it, and emailing a reset link with a template.

Test the forgot password api in the auth controller using a post mapping, sending a reset password request with an email, and verify the reset code delivery.

Extract the reset code and password from the request, validate the code and its expiration, encode and set the password, delete the code, and send a password updated email.

Test the OT API to reset a password via a reset code using a post request, sending the code and new password, and validate success or invalid code responses.

Develop a Spring Boot user service with methods to get current user, get a user by id, list all users, update password, and update profile picture, using a model mapper.

Securely update passwords and upload profile pictures with a server-side workflow that validates the old password, encodes and saves the new one, notifies the user, and manages profile picture files.

Define a spring boot users controller with endpoints to get my user details, get user by id, list users admin only, update password, and upload profile picture via multipart.

Test the users API with bearer token authentication, including get my profile and get user by id endpoints, plus password updates and profile picture uploads.

Develop a spring boot patient service with get, update, and by-id profile operations, plus blood group and genotype enums, using a repository, user service, and model mapper.

Explore the patient controller endpoints for managing profiles, including get and update profile, get by id, and listing blood group and genotype enums, with role-based access controls.

Learn to test the patient API using Postman, including authenticating as a patient, retrieving the patient profile, updating the profile via put /patient/me, and validating blood group and genotype endpoints.

Build a doctor service in Spring Boot, covering interface and implementation, profile retrieval and updates, search by specialization, and listing all specializations with DTO mappings.

Create a doctor controller with endpoints to get all doctors, get a doctor by id, update a doctor profile, and search by specialization, plus expose specialization enums.

Test the doctor API end-to-end using Postman, authenticate with a bearer token, retrieve and update doctor profiles, list all doctors, and filter by specialization and enum values.

Develop an appointment service to book, retrieve, cancel, and complete patient-doctor appointments. Validate start times, avoid conflicts, generate a unique meeting link, and email notifications to both parties.

Develop a private send confirmation email method that formats dates, builds patient and doctor notification data via template variables and a notification DTO, then dispatches emails with logging.

Create an appointment controller with a post endpoint at /api/appointments to book appointments using a validated JSON body and bearer authorization. Test end-to-end, including email confirmations and join meeting links.

Fetches current user appointments by role (doctor or patient), returns the latest appointments as DTOs, and supports cancellation with ownership checks and email notifications, enabling doctor-first prioritization and completion flows.

Define the appointment controller with endpoints to get my appointments, cancel an appointment, and complete an appointment, using appointment IDs and returning response entities via the appointment service.

Test the appointment api end-to-end using Postman, validating get, cancel, and complete endpoints with proper authorization tokens from patient and doctor. Prepare for the upcoming consultation module.