Table of Contents
- About the Project
- Technologies and Frameworks
- Scrum Agile Methodologies
- Soft Skills in Action
- Authentication
- Payment Integration
- Additional Libraries and Services
- Developing the Website
- Entities Overview
- Controllers Overview
- Services Overview
- Conclusion
About the project
This project was the capstone for my Software Development Associate of Applied Science degree and was completed collaboratively with two other students. Our objective was to develop a comprehensive web application for a local fitness instructor, integrating the functionality needed to manage a service-oriented eCommerce business.
The application includes user registration and authentication, class and event management, newsletter functionality, subscription services, an online store, and administrative tools for managing business operations. Throughout development we held regular meetings with our client to refine requirements and ensure the system aligned with their workflow and goals.
From a technical perspective, the application was built with ASP.NET Core MVC, but the project evolved into a more layered architecture separating the user interface, business logic, and data access components of the system.
Scrum Agile Methodologies
To manage development effectively, our team adopted Scrum Agile methodologies, organizing work into sprints and holding regular stand-ups to track progress and address challenges.
Frequent client meetings allowed us to gather feedback, evaluate new requirements, and adapt development priorities. This iterative approach enabled us to deliver working functionality throughout two academic terms while continuously refining the application in response to client needs.
Soft Skills in Action
In addition to technical implementation, the project required strong collaboration and communication.
Each team member took responsibility for specific areas of the system while maintaining open communication about architectural decisions, feature implementation, and changing requirements. Working together under an iterative development process helped us adapt to evolving project complexity and ensured consistent progress toward a functional product.
Technologies and Frameworks
The application was built using ASP.NET Core MVC, which provides the web framework for handling HTTP requests, routing, and rendering Razor views for the user interface.
While MVC manages the web layer of the application, the project was structured using a layered architecture inspired by Clean Architecture principles, separating responsibilities into distinct parts of the system.
The solution was organized into three primary layers:
UI Layer
The ASP.NET Core MVC web application containing controllers, Razor views, view models, and static assets.
Core Layer
The domain and application logic of the system, including service contracts, domain models, and business logic.
Infrastructure Layer
Database access and persistence logic, including Entity Framework Core repositories and database configuration.
This separation allows the business logic to remain independent of the web framework and database implementation, improving maintainability and modularity.
For data access, we used Entity Framework Core (EF Core) with
Pomelo.EntityFrameworkCore.MySql to interact with a MySQL database.
EF Core’s ORM capabilities allowed the application to map domain entities to database tables and manage schema changes through migrations.
Authentication
User authentication and authorization were implemented using ASP.NET Core Identity, providing features such as:
• email confirmation
• strong password policies
• role-based access control
These features allowed the system to manage user accounts securely while supporting different permission levels for administrators and customers.
Payment Integration
To support secure online transactions, the application integrates the Braintree payment gateway.
This integration enables subscription payments and store purchases through a secure checkout process. The payment system handles token generation, transaction processing, and order updates, ensuring reliable transaction management.
Additional Libraries and Services
Several additional libraries were incorporated to extend the system’s capabilities.
Humanizer
Used to improve the readability of time-related data throughout the application.
CsvHelper and EPPlus
Used for CSV handling and Excel file generation, enabling administrative data export features.
MailKit and MimeKit
Used for sending transactional emails such as newsletter updates, registration confirmations, and subscription notifications.
These integrations allowed the application to support real-world business workflows beyond basic web functionality.
This project demonstrates our ability to integrate and manage diverse technologies and frameworks in a sophisticated, service-based eCommerce web application. By employing ASP.NET Core MVC, EF Core, and a range of essential libraries, we developed a robust, maintainable solution tailored to the needs of a fitness business. This experience not only strengthened our technical skills but also demonstrated our teamwork, our ability to manage complex requirements, and our commitment to delivering a high-quality, user-centric product.
Developing the Website
Domain Entities
Entities represent the core data structures used throughout the application and form the foundation of the system’s data model.
These entities are mapped to database tables using Entity Framework Core, with data annotations used to enforce validation rules and data integrity. Attributes such as [Required] ensure mandatory data fields, while [NotMapped] allows computed properties to exist without being persisted to the database.
These entities also define relationships between different parts of the system, enabling complex operations such as class registration, order management, and subscription tracking.
Below are several representative examples.
Address.cs
Purpose:
Stores address information used for billing and shipping.
Key Feature:
The FullAddress property provides a formatted representation of the address and is marked with [NotMapped], allowing it to be used within the application without being stored directly in the database.
Class.cs
Purpose:
Represents a fitness class or session available for registration.
Key Feature:
Defines relationships with Address and ClassRegistration to manage location and enrollment. The entity also supports virtual sessions through conditional logic that determines whether an address is required.
Order.cs
Purpose:
Represents a customer order within the system.
Key Feature:
Automatically initializes the order date and status when created and maintains relationships with OrderItems, allowing complex order structures with multiple purchased items.
OrderItem.cs
Purpose:
Represents an individual item within an order.
Key Feature:
Stores quantity and price information while linking to the associated Order and StoreItem, enabling detailed tracking of purchased products.
PrivateSession.cs
Purpose:
Handles private session requests submitted by users.
Key Feature:
Includes an approval workflow using the IsApproved flag, supporting asynchronous approval processes for session requests.
Controllers Overview
Controllers form the primary interface between the user and the application.
Within the MVC architecture, controllers process incoming HTTP requests, coordinate business logic through services, and return the appropriate views or responses to the client.
In this project, controllers were designed to focus on request handling while delegating business logic to the service layer.
Examples include:
AccountController: Handles user-specific interactions such as viewing orders and registered classes while enforcing identity-based permissions.
CartController: Manages the shopping cart, including item management and session purchases. The controller uses asynchronous operations to maintain responsive performance.
ClassController: Handles class registration workflows, including validation and capacity management, while providing administrative tools for managing user points.
PaymentController: Manages integration with the Braintree payment gateway, including token generation, payment confirmation, and order updates.
The controller also includes rollback logic to ensure system consistency if a transaction fails.
NewsletterController: Manages newsletter subscriptions and administrative export features.
Important to the NewsletterController is the SubscribersExcel method which allows administrators to export subscriber data to excel.
Services Overview
The Services layer encapsulates the application’s business logic.
Controllers interact with services rather than directly accessing the database. Services coordinate domain operations and use repository abstractions to retrieve or persist data.
This separation improves maintainability and keeps HTTP request handling independent from the deeper application logic.
Core services include:
AddressService: Handles address CRUD operations and data validation.
AppUserService: Manages user accounts, subscriptions, and administrative data export functionality.
ClassService: Handles class registration workflows, capacity management, and email notifications.
OrderService: Manages shopping cart operations, order processing, reward points, and integration with the payment system.
EmailSender: Handles transactional email notifications using MailKit.
Conclusion
Developing this application provided valuable experience working on a real client-oriented software project.
Although the web interface was built using ASP.NET Core MVC, the overall system evolved into a layered architecture that separated the user interface, business logic, and data access concerns. This structure exposed me to architectural concepts beyond basic MVC, including service layers, repository abstractions, and the use of Entity Framework Core within a modular system design.
Working collaboratively with my team while following Agile practices strengthened both my technical skills and my ability to communicate, adapt to changing requirements, and contribute effectively to a shared codebase.
This project represents an important step in my development as a full-stack developer and demonstrates the ability to build a functional, maintainable web application for a real business use case.
Let’s put ourselves out there
Let’s create your website, the possibilities are endless. With our collaboration, let’s go find those sales or views you’re looking for.