https://github.com/mscbuild/-e-commerce-app
🧱Building Ecommerce web application
https://github.com/mscbuild/-e-commerce-app
core development ecommerce framework net payment postgresql razor-pages server webapp website
Last synced: about 1 month ago
JSON representation
🧱Building Ecommerce web application
- Host: GitHub
- URL: https://github.com/mscbuild/-e-commerce-app
- Owner: mscbuild
- License: mit
- Created: 2025-05-10T16:15:40.000Z (about 1 year ago)
- Default Branch: main
- Last Pushed: 2025-08-08T13:18:50.000Z (10 months ago)
- Last Synced: 2025-08-15T18:03:36.517Z (10 months ago)
- Topics: core, development, ecommerce, framework, net, payment, postgresql, razor-pages, server, webapp, website
- Language: C#
- Homepage:
- Size: 54.7 KB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Building Ecommerce web application with C#
## 🔧 Core Functional Requirements.
### 1. Product Management.
### 2. Inventory Management.
### 3. Customer Management.
### 4. Order Management
### 5. Shopping Cart & Checkout
### 6. Payment Processing
## 📂 Optional (but valuable) Features
## 🧱 Technology Stack Suggestion (C#/.NET Core)
## 🗂️ Project Structure
Assuming you're building an ASP.NET Core Web API backend, your folder structure might look like this:
```ruby
EcommerceApp/
│
├── Controllers/ → API endpoints (ProductsController, OrdersController, etc.)
├── Models/ → Data models (Product, Customer, Order, etc.)
├── Data/ → DbContext and seed data
├── DTOs/ → Data Transfer Objects for requests/responses
├── Services/ → Business logic (e.g., OrderService, PaymentService)
├── Repositories/ → Data access layer (optional abstraction)
├── Migrations/ → EF Core migrations
├── wwwroot/ → Static files (if applicable)
├── Program.cs → App entry point
└── appsettings.json → Configuration (connection strings, etc.)
```
### 🧩 1. Database Schema
### 📦 2. Order
### 📄 3. OrderItem
### 👤 4. Customer
### 💳 5. Payment (Optional if using external gateway only)
### 🔗 6. AppDbContext.cs
### 🧾 7. ProductsController.cs
# 🧪 Example Test with curl or Postman.
### GET all products
```ruby
GET http://localhost:5000/api/products
```
### POST new product
```ruby
POST http://localhost:5000/api/products
Content-Type: application/json
{
"name": "Laptop",
"description": "High-performance laptop",
"price": 1200.00,
"stock": 15,
"sku": "LAP123",
"imageUrl": "https://example.com/laptop.jpg"
}
```
### 🧩 8. OrderService.cs
# ✅ How to Use OrderService
Example us
```ruby
[HttpPost("create")]
public async Task CreateOrder(CreateOrderRequest request)
{
var result = await _orderService.CreateOrderAsync(request.CustomerId, request.Items);
if (!result.Success)
return BadRequest(result.Message);
return Ok(result.Message);
}
```
### DTO
```ruby
public class CreateOrderRequest
{
public int CustomerId { get; set; }
public List Items { get; set; }
}
public class OrderItemRequest
{
public int ProductId { get; set; }
public int Quantity { get; set; }
}
```
# 💳 Step-by-Step: Stripe Integration for
### ✅ 1. Set Up Stripe in Your
Install the Stripe
```ruby
dotnet add package Stripe.net
```
In `appsettings.json`, add you
```ruby
"Stripe": {
"SecretKey": "sk_test_YourSecretKey",
"PublishableKey": "pk_test_YourPublicKey"
}
```
### Load Stripe configuration in Program.cs or Startup.cs:
```ruby
StripeConfiguration.ApiKey = builder.Configuration["Stripe:SecretKey"];
```
### 🧾 2. Create a PaymentService
This will handle creating a Stripe charge (or PaymentIntent for newer APIs):
### 🎯 3. Payment Controller Endpoint
### 🧪 4. Testing
You can now POST to /api/payments/create-checkout-session/{orderId} and redirect the user to the returned url
# 📡 Stripe Webhook Integration (Payment Confirmation)
### ✅ 1. Why Use Webhooks?
Stripe Checkout redirects users after payment, but the most secure way to confirm payment is by listening to Stripe’s server-side webhooks.
### 🛠️ 2. Add Webhook Endpoint to Your App
>📌 Note: When creating the Checkout Session earlier, you can add Metadata = new Dictionary { { "order_id", order.Id.ToString() } } to the SessionCreateOptions.
Stripe Checkout redirects users after payment, but the most secure way to confirm payment is by listening to Stripe’s server-side webhooks.
### 🧪 3. Expose Localhost for Stripe Testing
# ✅ Result
1.Now your app will:
2.Create Stripe Checkout sessions.
3.Send users to Stripe to pay.
4.Listen for successful payments via webhook.
5.Automatically mark the order as “Paid” in your database.
# 🖼️ Basic UI Components
### 📄 Pages/Products.razor
### 🛒 Services/CartService.cs
# 💳 Checkout Page
### 📄 Pages/Checkout.razor
### 🧪 Test Flow
1.Run your backend API and Blazor app
2.Visit /products
3.Add items to cart
4. /checkout
5.Click "Proceed to Payment" → redirects to Stripe
6.After successful payment, Stripe webhook marks order as "Paid"
# 🚀 Azure Deployment:
✅ Backend (ASP.NET Core Web API)
✅ Frontend
✅ SQL Databas
✅ Stripe Webhooks (via Stripe CLI or Azure F)
# 🚀 GitHub Ac
🧭 Y
✅ Automatic build and test on each push
✅ Publish to Azure App Servi (API and Blazor)
### 🔧 Step 1: Prep Your Azure App Services
### 🔑 Step 2: Create Azure Deployment Credentials
### 📁 Step 3: Create GitHub Workflow Files
### 🔐 Step 4: Add Secrets to GitHub
### 🧪 Step 5: Test CI/CD
# ✅ Result
Every time you push changes:
### Perfect — you're now fully set up with:
✅ A C# e-commerce backend (API)
✅ A Blazor Server frontend
✅ Stripe payment + webhook handling
✅ Azure SQL integration
✅ Fully automated CI/CD via GitHub Actions
This stack is solid for portfolio use, production trials, or job interviews.