Project Introduction

The Expense Tracker App is designed to assist users in managing their personal finances by providing a comprehensive platform to track income, expenses, and budgets. Built using ASP.NET and SQL Server, this application offers a user-friendly interface that allows individuals to monitor their financial activities, set budgets, and generate insightful reports. The goal is to empower users to make informed financial decisions and achieve their financial goals.

Project Objectives

• To create a secure user authentication system for managing user accounts and roles.
• To enable users to record and categorize their expenses effectively.
• To allow users to track their income from various sources.
• To facilitate budget creation and management for different expense categories.
• To generate detailed reports on income, expenses, and net savings over specified periods.
• To provide notifications for important financial events or reminders.
• To implement a backup system for user data to ensure data integrity and security.
• To collect user feedback for continuous improvement of the application.

Project Modules

1. User Management Module: Handles user registration, login, and role management.
2. Expense Management Module: Allows users to add, edit, and delete expenses, including categorization.
3. Income Management Module: Enables users to record and manage their income sources.
4. Budget Management Module: Facilitates the creation and tracking of budgets for different categories.
5. Reporting Module: Generates financial reports summarizing income, expenses, and savings.
6. Notification Module: Sends alerts and reminders to users regarding their financial activities.
7. Backup Module: Manages data backups to ensure user data is secure and recoverable.
8. Feedback Module: Collects user feedback and ratings to improve the application.

SQL Server Database Tables

-- Users Table
CREATE TABLE Users (
    UserId INT PRIMARY KEY IDENTITY(1,1),
    Username NVARCHAR(50) NOT NULL UNIQUE,
    PasswordHash NVARCHAR(255) NOT NULL,
    Email NVARCHAR(100) NOT NULL UNIQUE,
    Phone NVARCHAR(15),
    RoleId INT,
    CreatedAt DATETIME DEFAULT GETDATE(),
    UpdatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (RoleId) REFERENCES Roles(RoleId)
);
-- Roles Table
CREATE TABLE Roles (
    RoleId INT PRIMARY KEY IDENTITY(1,1),
    RoleName NVARCHAR(50) NOT NULL UNIQUE
);
-- Expenses Table
CREATE TABLE Expenses (
    ExpenseId INT PRIMARY KEY IDENTITY(1,1),
    UserId INT,
    Amount DECIMAL(10, 2) NOT NULL,
    Category NVARCHAR(50), -- e.g., Food, Transport, Utilities
    Description NVARCHAR(MAX),
    ExpenseDate DATETIME DEFAULT GETDATE(),
    CreatedAt DATETIME DEFAULT GETDATE(),
    UpdatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Income Table
CREATE TABLE Incomes (
    IncomeId INT PRIMARY KEY IDENTITY(1,1),
    UserId INT,
    Amount DECIMAL(10, 2) NOT NULL,
    Source NVARCHAR(50), -- e.g., Salary, Freelance
    Description NVARCHAR(MAX),
    IncomeDate DATETIME DEFAULT GETDATE(),
    CreatedAt DATETIME DEFAULT GETDATE(),
    UpdatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Budgets Table
CREATE TABLE Budgets (
    BudgetId INT PRIMARY KEY IDENTITY(1,1),
    UserId INT,
    Category NVARCHAR(50), -- e.g., Food, Transport
    Amount DECIMAL(10, 2) NOT NULL,
    StartDate DATETIME NOT NULL,
    EndDate DATETIME NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE(),
    UpdatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Reports Table
CREATE TABLE Reports (
    ReportId INT PRIMARY KEY IDENTITY(1,1),
    UserId INT,
    ReportDate DATETIME DEFAULT GETDATE(),
    TotalIncome DECIMAL(10, 2),
    TotalExpenses DECIMAL(10, 2),
    NetSavings AS (TotalIncome - TotalExpenses) PERSISTED,
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Notifications Table
CREATE TABLE Notifications (
    NotificationId INT PRIMARY KEY IDENTITY(1,1),
    UserId INT,
    Message NVARCHAR(MAX),
    IsRead BIT DEFAULT 0,
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Backup Table
CREATE TABLE Backups (
    BackupId INT PRIMARY KEY IDENTITY(1,1),
    UserId INT,
    BackupDate DATETIME DEFAULT GETDATE(),
    BackupFile NVARCHAR(255), -- Path to the backup file
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Feedback Table
CREATE TABLE Feedbacks (
    FeedbackId INT PRIMARY KEY IDENTITY(1,1),
    UserId INT,
    Comments NVARCHAR(MAX),
    Rating INT CHECK (Rating >= 1 AND Rating <= 5),
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);

Explanation of Tables

Users: Stores user information, including credentials and roles.

Roles: Defines different roles within the system (e.g., admin, user).

Expenses: Records user expenses, including amount, category, description, and date.

Incomes: Tracks user income, including amount, source, description, and date.

Budgets: Manages user budgets for different categories, including amounts and date ranges.

Reports: Generates reports for users, summarizing total income, expenses, and net savings.

Notifications: Manages notifications sent to users, tracking whether they have been read.

Backups: Stores information about backups made by users, including backup dates and file paths.

Feedback: Collects feedback from users regarding the application, including ratings and comments.

Creating a Model and Repository Pattern

To create a model and repository pattern using ADO.NET for the provided SQL Server tables in an ASP.NET application, we will follow these steps:

Step 1: Create Models

Define C# classes that represent each table.

Here are the C# model classes for each table:

public class User
{
    public int UserId { get; set; }
    public string Username { get; set; }
    public string PasswordHash { get; set; }
    public string Email { get; set; }
    public string Phone { get; set; }
    public int? RoleId { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}
public class Role
{
    public int RoleId { get; set; }
    public string RoleName { get; set; }
}
public class Expense
{
    public int ExpenseId { get; set; }
    public int UserId { get; set; }
    public decimal Amount { get; set; }
    public string Category { get; set; }
    public string Description { get; set; }
    public DateTime ExpenseDate { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}
public class Income
{
    public int IncomeId { get; set; }
    public int UserId { get; set; }
    public decimal Amount { get; set; }
    public string Source { get; set; }
    public string Description { get; set; }
    public DateTime IncomeDate { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}
public class Budget
{
    public int BudgetId { get; set; }
    public int UserId { get; set; }
    public string Category { get; set; }
    public decimal Amount { get; set; }
    public DateTime StartDate { get; set; }
    public DateTime EndDate { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}
public class Report
{
    public int ReportId { get; set; }
    public int UserId { get; set; }
    public DateTime ReportDate { get; set; }
    public decimal? TotalIncome { get; set; }
    public decimal? TotalExpenses { get; set; }
    public decimal NetSavings => (TotalIncome ?? 0) - (TotalExpenses ?? 0);
    public DateTime CreatedAt { get; set; }
}
public class Notification
{
    public int NotificationId { get; set; }
    public int UserId { get; set; }
    public string Message { get; set; }
    public bool IsRead { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class Backup
{
    public int BackupId { get; set; }
    public int UserId { get; set; }
    public DateTime BackupDate { get; set; }
    public string BackupFile { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class Feedback
{
    public int FeedbackId { get; set; }
    public int UserId { get; set; }
    public string Comments { get; set; }
    public int Rating { get; set; }
    public DateTime CreatedAt { get; set; }
}

Step 2: Create Repositories

Next, we will create a repository for each model. Below is an example of how to implement a repository for the User model. You can follow a similar pattern for the other models.

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
public class UserRepository
{
    private readonly string _connectionString;
    public UserRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<User> GetAllUsers()
    {
        var users = new List<User>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Users", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                users.Add(new User
                {
                    UserId = (int)reader["User Id"],
                    Username = reader["Username"].ToString(),
                    PasswordHash = reader["PasswordHash"].ToString(),
                    Email = reader["Email"].ToString(),
                    Phone = reader["Phone"] .ToString(),
                    RoleId = reader["RoleId"] as int?,
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    UpdatedAt = (DateTime)reader["UpdatedAt"]
                });
            }
        }
        return users;
    }
    public User GetUser ById(int userId)
    {
        User user = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Users WHERE UserId = @User Id", connection);
            command.Parameters.AddWithValue("@User Id", userId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                user = new User
                {
                    UserId = (int)reader["User Id"],
                    Username = reader["Username"].ToString(),
                    PasswordHash = reader["PasswordHash"].ToString(),
                    Email = reader["Email"].ToString(),
                    Phone = reader["Phone"].ToString(),
                    RoleId = reader["RoleId"] as int?,
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    UpdatedAt = (DateTime)reader["UpdatedAt"]
                };
            }
        }
        return user;
    }
    public void AddUser (User user)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Users (Username, PasswordHash, Email, Phone, RoleId) VALUES (@Username, @PasswordHash, @Email, @Phone, @RoleId)", connection);
            command.Parameters.AddWithValue("@Username", user.Username);
            command.Parameters.AddWithValue("@PasswordHash", user.PasswordHash);
            command.Parameters.AddWithValue("@Email", user.Email);
            command.Parameters.AddWithValue("@Phone", user.Phone);
            command.Parameters.AddWithValue("@RoleId", user.RoleId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateUser (User user)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Users SET Username = @Username, PasswordHash = @PasswordHash, Email = @Email, Phone = @Phone, RoleId = @RoleId, UpdatedAt = GETDATE() WHERE UserId = @User Id", connection);
            command.Parameters.AddWithValue("@User Id", user.UserId);
            command.Parameters.AddWithValue("@Username", user.Username);
            command.Parameters.AddWithValue("@PasswordHash", user.PasswordHash);
            command.Parameters.AddWithValue("@Email", user.Email);
            command.Parameters.AddWithValue("@Phone", user.Phone);
            command.Parameters.AddWithValue("@RoleId", user.RoleId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteUser (int userId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Users WHERE UserId = @User Id", connection);
            command.Parameters.AddWithValue("@User Id", userId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

This pattern can be replicated for the other models such as Role, Expense, Income, Budget, Report, Notification, Backup, and Feedback by creating corresponding repository classes with methods for CRUD operations. Each repository will follow a similar structure, adjusting the SQL commands and parameters as necessary for the specific model.

public class RoleRepository 
{ 
    private readonly string _connectionString;
public RoleRepository()
{
    _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
}
public IEnumerable<Role> GetAllRoles()
{
    var roles = new List<Role>();
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        SqlCommand command = new SqlCommand("SELECT * FROM Roles", connection);
        connection.Open();
        SqlDataReader reader = command.ExecuteReader();
        while (reader.Read())
        {
            roles.Add(new Role
            {
                RoleId = (int)reader["RoleId"],
                RoleName = reader["RoleName"].ToString()
            });
        }
    }
    return roles;
}
public Role GetRoleById(int roleId)
{
    Role role = null;
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        SqlCommand command = new SqlCommand("SELECT * FROM Roles WHERE RoleId = @RoleId", connection);
        command.Parameters.AddWithValue("@RoleId", roleId);
        connection.Open();
        SqlDataReader reader = command.ExecuteReader();
        if (reader.Read())
        {
            role = new Role
            {
                RoleId = (int)reader["RoleId"],
                RoleName = reader["RoleName"].ToString()
            };
        }
    }
    return role;
}
public void AddRole(Role role)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        SqlCommand command = new SqlCommand("INSERT INTO Roles (RoleName) VALUES (@RoleName)", connection);
        command.Parameters.AddWithValue("@RoleName", role.RoleName);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public void UpdateRole(Role role)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        SqlCommand command = new SqlCommand("UPDATE Roles SET RoleName = @RoleName WHERE RoleId = @RoleId", connection);
        command.Parameters.AddWithValue("@RoleId", role.RoleId);
        command.Parameters.AddWithValue("@RoleName", role.RoleName);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public void DeleteRole(int roleId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        SqlCommand command = new SqlCommand("DELETE FROM Roles WHERE RoleId = @RoleId", connection);
        command.Parameters.AddWithValue("@RoleId", roleId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
}

public class ExpenseRepository 
{     
    private readonly string _connectionString;
public ExpenseRepository()
{
    _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
}
public IEnumerable<Expense> GetAllExpenses()
{
    var expenses = new List<Expense>();
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        SqlCommand command = new SqlCommand("SELECT * FROM Expenses", connection);
        connection.Open();
        SqlDataReader reader = command.ExecuteReader();
        while (reader.Read())
        {
            expenses.Add(new Expense
            {
                ExpenseId = (int)reader["ExpenseId"],
                UserId = (int)reader["User Id"],
                Amount = (decimal)reader["Amount"],
                Category = reader["Category"].ToString(),
                Description = reader["Description"].ToString(),
                ExpenseDate = (DateTime)reader["ExpenseDate"],
                CreatedAt = (DateTime)reader["CreatedAt"],
                UpdatedAt = (DateTime)reader["UpdatedAt"]
            });
        }
    }
    return expenses;
}
public Expense GetExpenseById(int expenseId)
{
    Expense expense = null;
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        SqlCommand command = new SqlCommand("SELECT * FROM Expenses WHERE ExpenseId = @ExpenseId", connection);
        command.Parameters.AddWithValue("@ExpenseId", expenseId);
        connection.Open();
        SqlDataReader reader = command.ExecuteReader();
        if (reader.Read())
        {
            expense = new Expense
            {
                ExpenseId = (int)reader["ExpenseId"],
                UserId = (int)reader["User Id"],
                Amount = (decimal)reader["Amount"],
                Category = reader["Category"].ToString(),
                Description = reader["Description"].ToString(),
                ExpenseDate = (DateTime)reader["ExpenseDate"],
                CreatedAt = (DateTime)reader["CreatedAt"],
                UpdatedAt = (DateTime)reader["UpdatedAt"]
            };
        }
    }
    return expense;
}
public void AddExpense(Expense expense)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        SqlCommand command = new SqlCommand("INSERT INTO Expenses ( User Id, Amount, Category, Description) VALUES (@User Id, @Amount, @Category, @Description)", connection);
        command.Parameters.AddWithValue("@User Id", expense.UserId);
        command.Parameters.AddWithValue("@Amount", expense.Amount);
        command.Parameters.AddWithValue("@Category", expense.Category);
        command.Parameters.AddWithValue("@Description", expense.Description);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public void UpdateExpense(Expense expense)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        SqlCommand command = new SqlCommand("UPDATE Expenses SET UserId = @User Id, Amount = @Amount, Category = @Category, Description = @Description, UpdatedAt = GETDATE() WHERE ExpenseId = @ExpenseId", connection);
        command.Parameters.AddWithValue("@ExpenseId", expense.ExpenseId);
        command.Parameters.AddWithValue("@User Id", expense.UserId);
        command.Parameters.AddWithValue("@Amount", expense.Amount);
        command.Parameters.AddWithValue("@Category", expense.Category);
        command.Parameters.AddWithValue("@Description", expense.Description);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
public void DeleteExpense(int expenseId)
{
    using (SqlConnection connection = new SqlConnection(_connectionString))
    {
        SqlCommand command = new SqlCommand("DELETE FROM Expenses WHERE ExpenseId = @ExpenseId", connection);
        command.Parameters.AddWithValue("@ExpenseId", expenseId);
        connection.Open();
        command.ExecuteNonQuery();
    }
}
}

Similar repository classes can be created for Income, Budget, Report, Notification, Backup, and Feedback models following the same structure. Each repository will handle CRUD operations specific to its model, ensuring a clean separation of concerns and maintainability in the application.

Repository Implementations

Below are the repository classes for the remaining models: Income, Budget, Report, Notification, Backup, and Feedback. Each repository will follow a similar pattern to the User Repository and ExpenseRepository provided earlier.

Income Repository

public class IncomeRepository
{
    private readonly string _connectionString;
    public IncomeRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<Income> GetAllIncomes()
    {
        var incomes = new List<Income>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Incomes", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                incomes.Add(new Income
                {
                    IncomeId = (int)reader["IncomeId"],
                    UserId = (int)reader["User Id"],
                    Amount = (decimal)reader["Amount"],
                    Source = reader["Source"].ToString(),
                    Description = reader["Description"].ToString(),
                    IncomeDate = (DateTime)reader["IncomeDate"],
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    UpdatedAt = (DateTime)reader["UpdatedAt"]
                });
            }
        }
        return incomes;
    }
    public Income GetIncomeById(int incomeId)
    {
        Income income = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Incomes WHERE IncomeId = @IncomeId", connection);
            command.Parameters.AddWithValue("@IncomeId", incomeId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                income = new Income
                {
                    IncomeId = (int)reader["IncomeId"],
                    UserId = (int)reader["User Id"],
                    Amount = (decimal)reader["Amount"],
                    Source = reader["Source"].ToString(),
                    Description = reader["Description"].ToString(),
                    IncomeDate = (DateTime)reader["IncomeDate"],
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    UpdatedAt = (DateTime)reader["UpdatedAt"]
                };
            }
        }
        return income;
    }
    public void AddIncome(Income income)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Incomes (User Id, Amount, Source, Description) VALUES (@User Id, @Amount, @Source, @Description)", connection);
            command.Parameters.AddWithValue("@User Id", income.UserId);
            command.Parameters.AddWithValue("@Amount", income.Amount);
            command.Parameters.AddWithValue("@Source", income.Source);
            command.Parameters.AddWithValue("@Description", income.Description);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateIncome(Income income)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Incomes SET UserId = @User Id, Amount = @Amount, Source = @Source, Description = @Description, UpdatedAt = GETDATE() WHERE IncomeId = @IncomeId", connection);
            command.Parameters.AddWithValue("@IncomeId", income.IncomeId);
            command.Parameters.AddWithValue("@User Id", income.UserId);
            command.Parameters.AddWithValue("@Amount", income.Amount);
            command.Parameters.AddWithValue("@Source", income.Source);
            command.Parameters.AddWithValue("@Description", income.Description);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteIncome(int incomeId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Incomes WHERE IncomeId = @IncomeId", connection);
            command.Parameters.AddWithValue("@IncomeId", incomeId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

Budget Repository

public class BudgetRepository
{
    private readonly string _connectionString;
    public BudgetRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<Budget> GetAllBudgets()
    {
        var budgets = new List<Budget>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Budgets", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                budgets.Add(new Budget
                {
                    BudgetId = (int)reader["BudgetId"],
                    UserId = (int)reader["User Id"],
                    Category = reader["Category"].ToString(),
                    Amount = (decimal)reader["Amount"],
                    StartDate = (DateTime)reader["StartDate"],
                    EndDate = (DateTime)reader["EndDate"],
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    UpdatedAt = (DateTime)reader["UpdatedAt"]
                });
            }
        }
        return budgets;
    }
    public Budget GetBudgetById(int budgetId)
    {
        Budget budget = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Budgets WHERE BudgetId = @BudgetId", connection);
            command.Parameters.AddWithValue("@BudgetId", budgetId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                budget = new Budget
                {
                    BudgetId = (int)reader["BudgetId"],
                    UserId = (int)reader["User  Id"],
                    Category = reader["Category"].ToString(),
                    Amount = (decimal)reader["Amount"],
                    StartDate = (DateTime)reader["StartDate"],
                    EndDate = (DateTime)reader["EndDate"],
                    CreatedAt = (DateTime)reader["CreatedAt"],
                    UpdatedAt = (DateTime)reader["UpdatedAt"]
                };
            }
        }
        return budget;
    }
    public void AddBudget(Budget budget)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Budgets (User  Id, Category, Amount, StartDate, EndDate) VALUES (@User  Id, @Category, @Amount, @StartDate, @EndDate)", connection);
            command.Parameters.AddWithValue("@User  Id", budget.UserId);
            command.Parameters.AddWithValue("@Category", budget.Category);
            command.Parameters.AddWithValue("@Amount", budget.Amount);
            command.Parameters.AddWithValue("@StartDate", budget.StartDate);
            command.Parameters.AddWithValue("@EndDate", budget.EndDate);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateBudget(Budget budget)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Budgets SET UserId = @User  Id, Category = @Category, Amount = @Amount, StartDate = @StartDate, EndDate = @EndDate, UpdatedAt = GETDATE() WHERE BudgetId = @BudgetId", connection);
            command.Parameters.AddWithValue("@BudgetId", budget.BudgetId);
            command.Parameters.AddWithValue("@User  Id", budget.UserId);
            command.Parameters.AddWithValue("@Category", budget.Category);
            command.Parameters.AddWithValue("@Amount", budget.Amount);
            command.Parameters.AddWithValue("@StartDate", budget.StartDate);
            command.Parameters.AddWithValue("@EndDate", budget.EndDate);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteBudget(int budgetId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Budgets WHERE BudgetId = @BudgetId", connection);
            command.Parameters.AddWithValue("@BudgetId", budgetId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

Report Repository

public class ReportRepository
{
    private readonly string _connectionString;
    public ReportRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<Report> GetAllReports()
    {
        var reports = new List<Report>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Reports", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                reports.Add(new Report
                {
                    ReportId = (int)reader["ReportId"],
                    UserId = (int)reader["User  Id"],
                    ReportDate = (DateTime)reader["ReportDate"],
                    TotalIncome = reader["TotalIncome"] as decimal?,
                    TotalExpenses = reader["TotalExpenses"] as decimal?,
                    CreatedAt = (DateTime)reader["CreatedAt"]
                });
            }
        }
        return reports;
    }
    public Report GetReportById(int reportId)
    {
        Report report = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Reports WHERE ReportId = @ReportId", connection);
            command.Parameters.AddWithValue("@ReportId", reportId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                report = new Report
                {
                    ReportId = (int)reader["ReportId"],
                    UserId = (int)reader["User   Id"],
                    ReportDate = (DateTime)reader["ReportDate"],
                    TotalIncome = reader["TotalIncome"] as decimal?,
                    TotalExpenses = reader["TotalExpenses"] as decimal?,
                    CreatedAt = (DateTime)reader["CreatedAt"]
                };
            }
        }
        return report;
    }
    public void AddReport(Report report)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Reports (User   Id, ReportDate, TotalIncome, TotalExpenses) VALUES (@User   Id, @ReportDate, @TotalIncome, @TotalExpenses)", connection);
            command.Parameters.AddWithValue("@User   Id", report.UserId);
            command.Parameters.AddWithValue("@ReportDate", report.ReportDate);
            command.Parameters.AddWithValue("@TotalIncome", report.TotalIncome);
            command.Parameters.AddWithValue("@TotalExpenses", report.TotalExpenses);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateReport(Report report)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Reports SET UserId = @User   Id, ReportDate = @ReportDate, TotalIncome = @TotalIncome, TotalExpenses = @TotalExpenses, CreatedAt = GETDATE() WHERE ReportId = @ReportId", connection);
            command.Parameters.AddWithValue("@ReportId", report.ReportId);
            command.Parameters.AddWithValue("@User   Id", report.UserId);
            command.Parameters.AddWithValue("@ReportDate", report.ReportDate);
            command.Parameters.AddWithValue("@TotalIncome", report.TotalIncome);
            command.Parameters.AddWithValue("@TotalExpenses", report.TotalExpenses);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteReport(int reportId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Reports WHERE ReportId = @ReportId", connection);
            command.Parameters.AddWithValue("@ReportId", reportId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

Notification Repository

public class NotificationRepository
{
    private readonly string _connectionString;
    public NotificationRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<Notification> GetAllNotifications()
    {
        var notifications = new List<Notification>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Notifications", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                notifications.Add(new Notification
                {
                    NotificationId = (int)reader["NotificationId"],
                    UserId = (int)reader["User   Id"],
                    Message = reader["Message"].ToString(),
                    IsRead = (bool)reader["IsRead"],
                    CreatedAt = (DateTime)reader["CreatedAt"]
                });
            }
        }
        return notifications;
    }
    public Notification GetNotificationById(int notificationId)
    {
        Notification notification = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Notifications WHERE NotificationId = @NotificationId", connection);
            command.Parameters.AddWithValue("@NotificationId", notificationId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                notification = new Notification
                {
                    NotificationId = (int)reader["NotificationId"],
                    UserId = (int)reader["User   Id"],
                    Message = reader["Message"].ToString(),
                    IsRead = (bool)reader["IsRead"],
                    CreatedAt = (DateTime)reader["CreatedAt"]
                };
            }
        }
        return notification;
    }
    public void AddNotification(Notification notification)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Notifications (User   Id, Message, IsRead) VALUES (@User   Id, @Message, @IsRead)", connection);
            command.Parameters.AddWithValue("@User   Id", notification.UserId);
            command.Parameters.AddWithValue("@Message", notification.Message);
            command.Parameters.AddWithValue("@IsRead", notification.IsRead);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateNotification(Notification notification)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Notifications SET UserId = @User   Id, Message = @Message, IsRead = @IsRead, CreatedAt = GETDATE() WHERE NotificationId = @NotificationId", connection);
            command.Parameters.AddWithValue("@NotificationId", notification.NotificationId);
            command.Parameters.AddWithValue("@User    Id", notification.UserId);
            command.Parameters.AddWithValue("@Message", notification.Message);
            command.Parameters.AddWithValue("@IsRead", notification.IsRead);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteNotification(int notificationId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Notifications WHERE NotificationId = @NotificationId", connection);
            command.Parameters.AddWithValue("@NotificationId", notificationId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

Backup Repository

public class BackupRepository
{
    private readonly string _connectionString;
    public BackupRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<Backup> GetAllBackups()
    {
        var backups = new List<Backup>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Backups", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                backups.Add(new Backup
                {
                    BackupId = (int)reader["BackupId"],
                    UserId = (int)reader["User    Id"],
                    BackupDate = (DateTime)reader["BackupDate"],
                    BackupFile = reader["BackupFile"].ToString(),
                    CreatedAt = (DateTime)reader["CreatedAt"]
                });
            }
        }
        return backups;
    }
    public Backup GetBackupById(int backupId)
    {
        Backup backup = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Backups WHERE BackupId = @BackupId", connection);
            command.Parameters.AddWithValue("@BackupId", backupId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                backup = new Backup
                {
                    BackupId = (int)reader["BackupId"],
                    UserId = (int)reader["User    Id"],
                    BackupDate = (DateTime)reader["BackupDate"],
                    BackupFile = reader["BackupFile"].ToString(),
                    CreatedAt = (DateTime)reader["CreatedAt"]
                };
            }
        }
        return backup;
    }
    public void AddBackup(Backup backup)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Backups (User    Id, BackupDate, BackupFile) VALUES (@User    Id, @BackupDate, @BackupFile)", connection);
            command.Parameters.AddWithValue("@User    Id", backup.UserId);
            command.Parameters.AddWithValue("@BackupDate", backup.BackupDate);
            command.Parameters.AddWithValue("@BackupFile", backup.BackupFile);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateBackup(Backup backup)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Backups SET UserId = @User    Id, BackupDate = @BackupDate, BackupFile = @BackupFile, CreatedAt = GETDATE() WHERE BackupId = @BackupId", connection);
            command.Parameters.AddWithValue("@BackupId", backup.BackupId);
            command.Parameters.AddWithValue("@User    Id", backup.UserId);
            command.Parameters.AddWithValue("@BackupDate", backup.BackupDate);
            command.Parameters.AddWithValue("@BackupFile", backup.BackupFile);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteBackup(int backupId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Backups WHERE BackupId = @BackupId", connection);
            command.Parameters.AddWithValue("@BackupId", backupId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

Feedback Repository

public class FeedbackRepository
{
    private readonly string _connectionString;
    public FeedbackRepository()
    {
        _connectionString = ConfigurationManager.ConnectionStrings["YourConnectionStringName"].ConnectionString;
    }
    public IEnumerable<Feedback> GetAllFeedbacks()
    {
        var feedbacks = new List<Feedback>();
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Feedbacks ", connection);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                feedbacks.Add(new Feedback
                {
                    FeedbackId = (int)reader["FeedbackId"],
                    UserId = (int)reader["User     Id"],
                    Comments = reader["Comments"].ToString(),
                    Rating = (int)reader["Rating"],
                    CreatedAt = (DateTime)reader["CreatedAt"]
                });
            }
        }
        return feedbacks;
    }
    public Feedback GetFeedbackById(int feedbackId)
    {
        Feedback feedback = null;
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("SELECT * FROM Feedbacks WHERE FeedbackId = @FeedbackId", connection);
            command.Parameters.AddWithValue("@FeedbackId", feedbackId);
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();
            if (reader.Read())
            {
                feedback = new Feedback
                {
                    FeedbackId = (int)reader["FeedbackId"],
                    UserId = (int)reader["User     Id"],
                    Comments = reader["Comments"].ToString(),
                    Rating = (int)reader["Rating"],
                    CreatedAt = (DateTime)reader["CreatedAt"]
                };
            }
        }
        return feedback;
    }
    public void AddFeedback(Feedback feedback)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("INSERT INTO Feedbacks (User     Id, Comments, Rating) VALUES (@User     Id, @Comments, @Rating)", connection);
            command.Parameters.AddWithValue("@User     Id", feedback.UserId);
            command.Parameters.AddWithValue("@Comments", feedback.Comments);
            command.Parameters.AddWithValue("@Rating", feedback.Rating);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void UpdateFeedback(Feedback feedback)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("UPDATE Feedbacks SET UserId = @User     Id, Comments = @Comments, Rating = @Rating, CreatedAt = GETDATE() WHERE FeedbackId = @FeedbackId", connection);
            command.Parameters.AddWithValue("@FeedbackId", feedback.FeedbackId);
            command.Parameters.AddWithValue("@User     Id", feedback.UserId);
            command.Parameters.AddWithValue("@Comments", feedback.Comments);
            command.Parameters.AddWithValue("@Rating", feedback.Rating);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteFeedback(int feedbackId)
    {
        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            SqlCommand command = new SqlCommand("DELETE FROM Feedbacks WHERE FeedbackId = @FeedbackId", connection);
            command.Parameters.AddWithValue("@FeedbackId", feedbackId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

These repository classes provide a complete set of CRUD operations for the remaining models in your application. Each repository is designed to interact with the corresponding SQL Server table, ensuring a clean separation of concerns and maintainability in your ASP.NET application.

Creating Controllers

To create controllers for each repository in an ASP.NET MVC application, we will follow the standard pattern of creating a controller for each model. Each controller will handle HTTP requests, interact with the corresponding repository, and return views or data as needed.

Below are controllers for each of the repositories: User Controller, RoleController, ExpenseController, IncomeController, BudgetController, ReportController, NotificationController, BackupController, and FeedbackController.

UserController

using System.Web.Mvc;
public class UserController : Controller
{
    private readonly UserRepository _userRepository;
    public UserController()
    {
        _userRepository = new UserRepository();
    }
    public ActionResult Index()
    {
        var users = _userRepository.GetAllUsers();
        return View(users);
    }
    public ActionResult Details(int id)
    {
        var user = _userRepository.GetUser ById(id);
        return View(user);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(User user)
    {
        if (ModelState.IsValid)
        {
            _userRepository.AddUser (user);
            return RedirectToAction("Index");
        }
        return View(user);
    }
    public ActionResult Edit(int id)
    {
        var user = _userRepository.GetUser ById(id);
        return View(user);
    }
    [HttpPost]
    public ActionResult Edit(User user)
    {
        if (ModelState.IsValid)
        {
            _userRepository.UpdateUser (user);
            return RedirectToAction("Index");
        }
        return View(user);
    }
    public ActionResult Delete(int id)
    {
        var user = _userRepository.GetUser ById(id);
        return View(user);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _userRepository.DeleteUser (id);
        return RedirectToAction("Index");
    }
}

RoleController

using System.Web.Mvc;
public class RoleController : Controller
{
    private readonly RoleRepository _roleRepository;
    public RoleController()
    {
        _roleRepository = new RoleRepository();
    }
    public ActionResult Index()
    {
        var roles = _roleRepository.GetAllRoles();
        return View(roles);
    }
    public ActionResult Details(int id)
    {
        var role = _roleRepository.GetRoleById(id);
        return View(role);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Role role)
    {
        if (ModelState.IsValid)
        {
            _roleRepository.AddRole(role);
            return RedirectToAction("Index");
        }
        return View(role);
    }
    public ActionResult Edit(int id)
    {
        var role = _roleRepository.GetRoleById(id);
        return View(role);
    }
    [HttpPost]
    public ActionResult Edit(Role role)
    {
        if (ModelState.IsValid)
        {
            _roleRepository.UpdateRole(role);
            return RedirectToAction("Index");
        }
        return View(role);
    }
    public ActionResult Delete(int id)
    {
        var role = _roleRepository.GetRoleById(id);
        return View(role);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _roleRepository.DeleteRole(id);
        return RedirectToAction("Index");
    }
}

ExpenseController

using System.Web.Mvc;
public class ExpenseController : Controller
{
    private readonly ExpenseRepository _expenseRepository;
    public ExpenseController()
    {
        _expenseRepository = new ExpenseRepository();
    }
    public ActionResult Index()
    {
        var expenses = _expenseRepository.GetAllExpenses();
        return View(expenses);
    }
    public ActionResult Details(int id)
    {
        var expense = _expenseRepository.GetExpenseById(id);
        return View(expense);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Expense expense)
    {
        if (ModelState.IsValid)
        {
            _expenseRepository.AddExpense(expense);
            return RedirectToAction("Index");
        }
        return View(expense);
    }
    public ActionResult Edit(int id)
    {
        var expense = _expenseRepository.GetExpenseById(id);
        return View(expense);
    }
    [HttpPost]
    public ActionResult Edit(Expense expense)
    {
        if (ModelState.IsValid)
        {
            _expenseRepository.UpdateExpense(expense);
            return RedirectToAction("Index");
        }
        return View(expense);
    }
    public ActionResult Delete(int id)
    {
        var expense = _expenseRepository.GetExpenseById(id);
        return View(expense);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _expenseRepository.DeleteExpense(id);
        return RedirectToAction("Index");
    }
}

IncomeController

using System.Web.Mvc;
public class IncomeController : Controller
{
    private readonly IncomeRepository _incomeRepository;
    public IncomeController()
    {
        _incomeRepository = new IncomeRepository();
    }
    public ActionResult Index()
    {
        var incomes = _incomeRepository.GetAllIncomes();
        return View(incomes);
    }
    public ActionResult Details(int id)
    {
        var income = _incomeRepository.GetIncomeById(id);
        return View(income);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Income income)
    {
        if (ModelState.IsValid)
        {
            _incomeRepository.AddIncome(income);
            return RedirectToAction("Index");
        }
        return View(income);
    }
    public ActionResult Edit(int id)
    {
        var income = _incomeRepository.GetIncomeById(id);
        return View(income);
    }
    [HttpPost]
    public ActionResult Edit(Income income)
    {
        if (ModelState.IsValid)
        {
            _incomeRepository.UpdateIncome(income);
            return RedirectToAction("Index");
        }
        return View(income);
    }
    public ActionResult Delete(int id)
    {
        var income = _incomeRepository.GetIncomeById(id);
        return View(income);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _incomeRepository.DeleteIncome(id);
        return RedirectToAction("Index");
    }
}

BudgetController

using System.Web.Mvc;
public class BudgetController : Controller
{
    private readonly BudgetRepository _budgetRepository;
    public BudgetController()
    {
        _budgetRepository = new BudgetRepository();
    }
    public ActionResult Index()
    {
        var budgets = _budgetRepository.GetAllBudgets();
        return View(budgets);
    }
    public ActionResult Details(int id)
    {
        var budget = _budgetRepository.GetBudgetById(id);
        return View(budget);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Budget budget)
    {
        if (ModelState.IsValid)
        {
            _budgetRepository.AddBudget(budget);
            return RedirectToAction("Index");
        }
        return View(budget);
    }
    public ActionResult Edit(int id)
    {
        var budget = _budgetRepository.GetBudgetById(id);
        return View(budget);
    }
    [HttpPost]
    public ActionResult Edit(Budget budget)
    {
        if (ModelState.IsValid)
        {
            _budgetRepository.UpdateBudget(budget);
            return RedirectToAction("Index");
        }
        return View(budget);
    }
    public ActionResult Delete(int id)
    {
        var budget = _budgetRepository.GetBudgetById(id);
        return View(budget);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _budgetRepository.DeleteBudget(id);
        return RedirectToAction("Index");
    }
}

ReportController

using System.Web.Mvc;
public class ReportController : Controller
{
    private readonly ReportRepository _reportRepository;
    public ReportController()
    {
        _reportRepository = new ReportRepository();
    }
    public ActionResult Index()
    {
        var reports = _reportRepository.GetAllReports();
        return View(reports);
    }
    public ActionResult Details(int id)
    {
        var report = _reportRepository.GetReportById(id);
        return View(report);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Report report)
    {
        if (ModelState.IsValid)
        {
            _reportRepository.AddReport(report);
            return RedirectToAction("Index");
        }
        return View(report);
    }
    public ActionResult Edit(int id)
    {
        var report = _reportRepository.GetReportById(id);
        return View(report);
    }
    [HttpPost]
    public ActionResult Edit(Report report)
    {
        if (ModelState.IsValid)
        {
            _reportRepository.UpdateReport(report);
            return RedirectToAction("Index");
        }
        return View(report);
    }
    public ActionResult Delete(int id)
    {
        var report = _reportRepository.GetReportById(id);
        return View(report);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _reportRepository.DeleteReport(id);
        return RedirectToAction ("Index");
    }
}

NotificationController

using System.Web.Mvc;
public class NotificationController : Controller
{
    private readonly NotificationRepository _notificationRepository;
    public NotificationController()
    {
        _notificationRepository = new NotificationRepository();
    }
    public ActionResult Index()
    {
        var notifications = _notificationRepository.GetAllNotifications();
        return View(notifications);
    }
    public ActionResult Details(int id)
    {
        var notification = _notificationRepository.GetNotificationById(id);
        return View(notification);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Notification notification)
    {
        if (ModelState.IsValid)
        {
            _notificationRepository.AddNotification(notification);
            return RedirectToAction("Index");
        }
        return View(notification);
    }
    public ActionResult Edit(int id)
    {
        var notification = _notificationRepository.GetNotificationById(id);
        return View(notification);
    }
    [HttpPost]
    public ActionResult Edit(Notification notification)
    {
        if (ModelState.IsValid)
        {
            _notificationRepository.UpdateNotification(notification);
            return RedirectToAction("Index");
        }
        return View(notification);
    }
    public ActionResult Delete(int id)
    {
        var notification = _notificationRepository.GetNotificationById(id);
        return View(notification);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _notificationRepository.DeleteNotification(id);
        return RedirectToAction("Index");
    }
}

BackupController

using System.Web.Mvc;
public class BackupController : Controller
{
    private readonly BackupRepository _backupRepository;
    public BackupController()
    {
        _backupRepository = new BackupRepository();
    }
    public ActionResult Index()
    {
        var backups = _backupRepository.GetAllBackups();
        return View(backups);
    }
    public ActionResult Details(int id)
    {
        var backup = _backupRepository.GetBackupById(id);
        return View(backup);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Backup backup)
    {
        if (ModelState.IsValid)
        {
            _backupRepository.AddBackup(backup);
            return RedirectToAction("Index");
        }
        return View(backup);
    }
    public ActionResult Edit(int id)
    {
        var backup = _backupRepository.GetBackupById(id);
        return View(backup);
    }
    [HttpPost]
    public ActionResult Edit(Backup backup)
    {
        if (ModelState.IsValid)
        {
            _backupRepository.UpdateBackup(backup);
            return RedirectToAction("Index");
        }
        return View(backup);
    }
    public ActionResult Delete(int id)
    {
        var backup = _backupRepository.GetBackupById(id);
        return View(backup);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _backupRepository.DeleteBackup(id);
        return RedirectToAction("Index");
    }
}

FeedbackController

using System.Web.Mvc;
public class FeedbackController : Controller
{
    private readonly FeedbackRepository _feedbackRepository;
    public FeedbackController()
    {
        _feedbackRepository = new FeedbackRepository();
    }
    public ActionResult Index()
    {
        var feedbacks = _feedbackRepository.GetAllFeedbacks();
        return View(feedbacks);
    }
    public ActionResult Details(int id)
    {
        var feedback = _feedbackRepository.GetFeedbackById(id);
        return View(feedback);
    }
    public ActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public ActionResult Create(Feedback feedback)
    {
        if (ModelState.IsValid)
        {
            _feedbackRepository.AddFeedback(feedback);
            return RedirectToAction("Index");
        }
        return View(feedback);
    }
    public ActionResult Edit(int id)
    {
        var feedback = _feedbackRepository.GetFeedbackById(id);
        return View(feedback);
    }
    [HttpPost]
    public ActionResult Edit(Feedback feedback)
    {
        if (ModelState.IsValid)
        {
            _feedbackRepository.UpdateFeedback(feedback);
            return RedirectToAction("Index");
        }
        return View(feedback);
    }
    public ActionResult Delete(int id)
    {
        var feedback = _feedbackRepository.GetFeedbackById(id);
        return View(feedback);
    }
    [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed(int id)
    {
        _feedbackRepository.DeleteFeedback(id);
        return RedirectToAction("Index");
    }
}

These controllers provide a complete set of actions for managing the respective models, allowing for the creation, reading, updating, and deletion of records.

Creating Views

Creating views for each controller in an ASP.NET MVC application involves creating Razor view files that correspond to the actions in the controllers. Below, I will provide a basic structure for the views for each controller: User, Role, Expense, Income, Budget, Report, Notification, Backup, and Feedback.

Directory Structure

Assuming you have a standard ASP.NET MVC project structure, the views will be placed in the Views folder under their respective controller names. For example, views for the User Controller will be in Views/User.

User Views

1. Index.cshtml

@model IEnumerable<User>
<h2>Users</h2>
<a href='@Url.Action("Create")'>Create New User</a>
<table>
    <thead>
        <tr>
            <th>Username</th>
            <th>Email</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var user in Model)
        {
            <tr>
                <td>@user.Username</td>
                <td>@user.Email</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = user.UserId }) |
                    @Html.ActionLink("Details", "Details", new { id = user.UserId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = user.UserId })
                </td>
            </tr>
        }
    </tbody>
</table>

2. Create.cshtml

@model User
<h2>Create User</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.Username)
    @Html.TextBoxFor(m => m.Username)
    @Html.ValidationMessageFor(m => m.Username)
    @Html.LabelFor(m => m.PasswordHash)
    @Html.TextBoxFor(m => m.PasswordHash)
    @Html.ValidationMessageFor(m => m.PasswordHash)
    @Html.LabelFor(m => m.Email)
    @Html.TextBoxFor(m => m.Email)
    @Html.ValidationMessageFor(m => m.Email)
    @Html.LabelFor(m => m.Phone)
    @Html.TextBoxFor(m => m.Phone)
    @Html.ValidationMessageFor(m => m.Phone)
    <input type="submit" value="Create" />
}

3. Edit.cshtml

@model User
<h2>Edit User</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.UserId)
    @Html.LabelFor(m => m.Username)
    @Html.TextBoxFor(m => m.Username)
    @Html.ValidationMessageFor(m => m.Username)
    @Html.LabelFor(m => m.PasswordHash)
    @Html.TextBoxFor(m => m.PasswordHash)
    @Html.ValidationMessageFor(m => m.PasswordHash)
    @Html.LabelFor(m => m.Email)
    @Html.TextBoxFor(m => m.Email)
    @Html.ValidationMessageFor(m => m.Email)
    @Html.LabelFor(m => m.Phone)
    @Html.TextBoxFor(m => m.Phone)
    @Html.ValidationMessageFor(m => m.Phone)
    <input type="submit" value="Save" />
}

4. Details.cshtml

@model User
<h2>User Details</h2>
<p>
    <strong>Username:</strong> @Model.Username<br />
    <strong>Email:</strong> @Model.Email<br />
    <strong>Phone:</strong> @Model.Phone<br />
</p>
<a href='@Url.Action("Edit", new { id = Model.UserId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>

5. Delete.cshtml

@model User
<h2>Delete User</h2>
<p>Are you sure you want to delete this user?</p>
<p>
    <strong>Username:</strong> @Model.Username<br />
    <strong>Email:</strong> @Model.Email<br />
</p>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.UserId)
    <input type="submit" value="Delete" />
}
<a href='@Url.Action("Index")'>Cancel</a>

Role Views

1. Index.cshtml

@model IEnumerable<Role>
<h2>Roles</h2>
<a href='@Url.Action("Create")'>Create New Role</a>
<table>
    <thead>
        <tr>
            <th>Role Name</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var role in Model)
        {
            <tr>
                <td>@role.RoleName</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = role.RoleId }) |
                    @Html.ActionLink("Details", "Details", new { id = role.RoleId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = role.RoleId })
                </td>
            </tr>
        }
    </tbody>
</table>

2. Create.cshtml

@model Role
<h2>Create Role</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.RoleName)
    @Html.TextBoxFor(m => m.RoleName)
    @Html.ValidationMessageFor(m => m.RoleName)
    <input type="submit" value="Create" />
}

3. Edit.cshtml

@model Role
<h2>Edit Role</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.RoleId)
    @Html.LabelFor(m => m.RoleName)
    @Html.TextBoxFor(m => m.RoleName)
    @Html.ValidationMessageFor(m => m.RoleName)
    <input type="submit" value="Save" />
}

4. Details.cshtml

@model Role
<h2>Role Details</h2>
<p>
    <strong>Role Name:</strong> @Model.RoleName<br />
</p>
<a href='@Url.Action("Edit", new { id = Model.RoleId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>

5. Delete.cshtml

@model Role
<h2>Delete Role</h2>
<p>Are you sure you want to delete this role?</p>
<p>
    <strong>Role Name:</strong> @Model.RoleName<br />
</p>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.RoleId)
    <input type="submit" value="Delete" />
}
<a href='@Url.Action("Index")'>Cancel</a>

Expense Views

1. Index.cshtml

@model IEnumerable<Expense>
<h2>Expenses</h2>
<a href='@Url.Action("Create")'>Create New Expense</a>
<table>
    <thead>
        <tr>
            <th>Description</th>
            <th>Amount</th>
            <th>Date</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var expense in Model)
        {
            <tr>
                <td>@expense.Description</td>
                <td>@expense.Amount</td>
                <td>@expense.Date.ToShortDateString()</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = expense.ExpenseId }) |
                    @Html.ActionLink("Details", "Details", new { id = expense.ExpenseId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = expense.ExpenseId })
                </td>
            </tr>
        }
    </tbody>
</table>

2. Create.cshtml

@model Expense
<h2>Create Expense</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.Description)
    @Html.TextBoxFor(m => m.Description)
    @Html.ValidationMessageFor(m => m.Description)
    @Html.LabelFor(m => m.Amount)
    @Html.TextBoxFor(m => m.Amount)
    @Html.ValidationMessageFor(m => m.Amount)
    @Html.LabelFor(m => m.Date)
    @Html.TextBoxFor(m => m.Date, "{0:yyyy-MM-dd}", new { @type = "date" })
    @Html.ValidationMessageFor(m => m.Date)
    <input type="submit" value="Create" />
}

3. Edit.cshtml

@model Expense
<h2>Edit Expense</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.ExpenseId)
    @Html.LabelFor(m => m.Description)
    @Html.TextBoxFor(m => m.Description)
    @Html.ValidationMessageFor(m => m.Description)
    @Html.LabelFor(m => m.Amount)
    @Html.TextBoxFor(m => m.Amount)
    @Html.ValidationMessageFor(m => m.Amount)
    @Html.LabelFor(m => m.Date)
    @Html.TextBoxFor(m => m.Date, "{0:yyyy-MM-dd}", new { @type = "date" })
    @Html.ValidationMessageFor(m => m.Date)
    <input type="submit" value="Save" />
}

4. Details.cshtml

@model Expense
<h2>Expense Details</h2>
<p>
    <strong>Description:</strong> @Model.Description<br />
    <strong>Amount:</strong> @Model.Amount<br <strong>Date:</strong> @Model.Date.ToShortDateString()<br />
</p>
<a href='@Url.Action("Edit", new { id = Model.ExpenseId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>

5. Delete.cshtml

@model Expense
<h2>Delete Expense</h2>
<p>Are you sure you want to delete this expense?</p>
<p>
    <strong>Description:</strong> @Model.Description<br />
    <strong>Amount:</strong> @Model.Amount<br />
    <strong>Date:</strong> @Model.Date.ToShortDateString()<br />
</p>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.ExpenseId)
    <input type="submit" value="Delete" />
}
<a href='@Url.Action("Index")'>Cancel</a>

Income Views

1. Index.cshtml

@model IEnumerable<Income>
<h2>Incomes</h2>
<a href='@Url.Action("Create")'>Create New Income</a>
<table>
    <thead>
        <tr>
            <th>Description</th>
            <th>Amount</th>
            <th>Date</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var income in Model)
        {
            <tr>
                <td>@income.Description</td>
                <td>@income.Amount</td>
                <td>@income.Date.ToShortDateString()</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = income.IncomeId }) |
                    @Html.ActionLink("Details", "Details", new { id = income.IncomeId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = income.IncomeId })
                </td>
            </tr>
        }
    </tbody>
</table>

2. Create.cshtml

@model Income
<h2>Create Income</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.Description)
    @Html.TextBoxFor(m => m.Description)
    @Html.ValidationMessageFor(m => m.Description)
    @Html.LabelFor(m => m.Amount)
    @Html.TextBoxFor(m => m.Amount)
    @Html.ValidationMessageFor(m => m.Amount)
    @Html.LabelFor(m => m.Date)
    @Html.TextBoxFor(m => m.Date, "{0:yyyy-MM-dd}", new { @type = "date" })
    @Html.ValidationMessageFor(m => m.Date)
    <input type="submit" value="Create" />
}

3. Edit.cshtml

@model Income
<h2>Edit Income</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.IncomeId)
    @Html.LabelFor(m => m.Description)
    @Html.TextBoxFor(m => m.Description)
    @Html.ValidationMessageFor(m => m.Description)
    @Html.LabelFor(m => m.Amount)
    @Html.TextBoxFor(m => m.Amount)
    @Html.ValidationMessageFor(m => m.Amount)
    @Html.LabelFor(m => m.Date)
    @Html.TextBoxFor(m => m.Date, "{0:yyyy-MM-dd}", new { @type = "date" })
    @Html.ValidationMessageFor(m => m.Date)
    <input type="submit" value="Save" />
}

4. Details.cshtml

@model Income
<h2>Income Details</h2>
<p>
    <strong>Description:</strong> @Model.Description<br />
    <strong>Amount:</strong> @Model.Amount<br />
    <strong>Date:</strong> @Model.Date.ToShortDateString()<br />
</p>
<a href='@Url.Action("Edit", new { id = Model.IncomeId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>

5. Delete.cshtml

@model Income
<h2>Delete Income</h2>
<p>Are you sure you want to delete this income?</p>
<p>
    <strong>Description:</strong> @Model.Description<br />
    <strong>Amount:</strong> @Model.Amount<br />
    <strong>Date:</strong> @Model.Date.ToShortDateString()<br />
</p>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.IncomeId)
    <input type="submit" value="Delete" />
}
<a href='@Url.Action("Index")'>Cancel</a>

Budget Views

1. Index.cshtml

@model IEnumerable<Budget>
<h2>Budgets</h2>
<a href='@Url.Action("Create") ">Create New Budget</a>
<table>
    <thead>
        <tr>
            <th>Budget Name</th>
            <th>Amount</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var budget in Model)
        {
            <tr>
                <td>@budget.BudgetName</td>
                <td>@budget.Amount</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = budget.BudgetId }) |
                    @Html.ActionLink("Details", "Details", new { id = budget.BudgetId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = budget.BudgetId })
                </td>
            </tr>
        }
    </tbody>
</table>

2. Create.cshtml

@model Budget
<h2>Create Budget</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.BudgetName)
    @Html.TextBoxFor(m => m.BudgetName)
    @Html.ValidationMessageFor(m => m.BudgetName)
    @Html.LabelFor(m => m.Amount)
    @Html.TextBoxFor(m => m.Amount)
    @Html.ValidationMessageFor(m => m.Amount)
    <input type="submit" value="Create" />
}

3. Edit.cshtml

@model Budget
<h2>Edit Budget</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.BudgetId)
    @Html.LabelFor(m => m.BudgetName)
    @Html.TextBoxFor(m => m.BudgetName)
    @Html.ValidationMessageFor(m => m.BudgetName)
    @Html.LabelFor(m => m.Amount)
    @Html.TextBoxFor(m => m.Amount)
    @Html.ValidationMessageFor(m => m.Amount)
    <input type="submit" value="Save" />
}

4. Details.cshtml

@model Budget
<h2>Budget Details</h2>
<p>
    <strong>Budget Name:</strong> @Model.BudgetName<br />
    <strong>Amount:</strong> @Model.Amount<br />
</p>
<a href='@Url.Action("Edit", new { id = Model.BudgetId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>

5. Delete.cshtml

@model Budget
<h2>Delete Budget</h2>
<p>Are you sure you want to delete this budget?</p>
<p>
    <strong>Budget Name:</strong> @Model.BudgetName<br />
    <strong>Amount:</strong> @Model.Amount<br />
</p>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.BudgetId)
    <input type="submit" value="Delete" />
}
<a href='@Url.Action("Index")'>Cancel</a>

Report Views

1. Index.cshtml

@model IEnumerable<Report>
<h2>Reports</h2>
<a href='@Url.Action("Create")'>Create New Report</a>
<table>
    <thead>
        <tr>
            <th>Report Title</th>
            <th>Date</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var report in Model)
        {
            <tr>
                <td>@report.Title</td>
                <td>@report.Date.ToShortDateString()</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = report.ReportId }) |
                    @Html.ActionLink("Details", "Details", new { id = report.ReportId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = report.ReportId })
                </td>
            </tr>
        }
    </tbody>
</table>

2. Create.cshtml

@model Report
<h2>Create Report</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.Title)
    @Html.TextBoxFor(m => m.Title)
    @Html.ValidationMessageFor(m => m.Title)
    @Html.LabelFor(m => m.Date)
    @Html.TextBoxFor(m => m.Date, "{0:yyyy-MM-dd}", new { @type = "date" })
    @Html.ValidationMessageFor(m => m.Date)
    <input type="submit" value="Create" />
}

3. Edit.cshtml

@model Report
<h2>Edit Report</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.ReportId)
    @Html.LabelFor(m => m.Title)
    @Html.TextBoxFor(m => m.Title)
    @Html.ValidationMessageFor(m => m.Title)
    @Html.LabelFor(m => m.Date)
    @Html.TextBoxFor(m => m.Date, "{0:yyyy-MM-dd}", new { @type = "date" })
    @Html.ValidationMessageFor(m => m.Date)
    <input type="submit" value="Save" />
}

4. Details.cshtml

@model Report
<h2>Report Details</h2>
<p>
    <strong>Title:</strong> @Model.Title<br />
    <strong>Date:</strong> @Model.Date.ToShortDateString()<br />
</p>
<a href='@Url.Action("Edit", new { id = Model.ReportId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>

5. Delete.cshtml

@model Report
<h2>Delete Report</h2>
<p>Are you sure you want to delete this report?</p>
<p>
    <strong>Title:</strong> @Model.Title<br />
    <strong>Date:</strong> @Model.Date.ToShortDateString()<br />
</p>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.ReportId)
    <input type="submit" value="Delete" />
}
<a href='@Url.Action("Index")'>Cancel</a>

Notification Views

1. Index.cshtml

@model IEnumerable<Notification>
<h2>Notifications</h2>
<a href='@Url.Action("Create")'>Create New Notification</a>
<table>
    <thead>
        <tr>
            <th>Message</th>
            <th>Date</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var notification in Model)
        {
            <tr>
                <td>@notification.Message</td>
                <td>@notification.Date.ToShortDateString()</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = notification.NotificationId }) |
                    @Html.ActionLink("Details", "Details", new { id = notification.NotificationId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = notification.NotificationId })
                </td>
            </tr>
        }
    </tbody>
</table>

2. Create.cshtml

@model Notification
<h2>Create Notification</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.Message)
    @Html.TextBoxFor(m => m.Message)
    @Html.ValidationMessageFor(m => m.Message)
    @Html.LabelFor(m => m.Date)
    @Html.TextBoxFor(m => m.Date, "{0:yyyy-MM-dd}", new { @type = "date" })
    @Html.ValidationMessageFor(m => m.Date)
    <input type="submit" value="Create" />
}

3. Edit.cshtml

@model Notification
<h2>Edit Notification</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.NotificationId)
    @Html.LabelFor(m => m.Message)
    @Html.TextBoxFor(m => m.Message)
    @Html.ValidationMessageFor(m => m.Message)
    @Html.LabelFor(m => m.Date)
    @Html.TextBoxFor(m => m.Date, "{0:yyyy-MM-dd}", new { @type = "date" })
    @Html.ValidationMessageFor(m => m.Date)
    <input type="submit" value="Save" />
}

4. Details.cshtml

@model Notification
<h2>Notification Details</h2>
<p>
    <strong>Message:</strong> @Model.Message<br />
    <strong>Date:</strong> @Model.Date.ToShortDateString()<br />
</p>
<a href='@Url.Action("Edit", new { id = Model.NotificationId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>

5. Delete.cshtml

@model Notification
<h2>Delete Notification</h2>
<p>Are you sure you want to delete this notification?</p>
<p>
    <strong>Message:</strong> @Model.Message<br />
    <strong>Date:</strong> @Model.Date.ToShortDateString()<br />
</p>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.NotificationId)
    <input type="submit" value="Delete" />
}
<a href='@Url.Action("Index")'>Cancel</a>

Backup Views

1. Index.cshtml

@model IEnumerable<Backup>
<h2>Backups</h2>
<a href='@Url.Action("Create")'>Create New Backup</a>
<table>    
    <thead>
        <tr>
            <th>Backup Name</th>
            <th>Date</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var backup in Model)
        {
            <tr>
                <td>@backup.BackupName</td>
                <td>@backup.Date.ToShortDateString()</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = backup.BackupId }) |
                    @Html.ActionLink("Details", "Details", new { id = backup.BackupId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = backup.BackupId })
                </td>
            </tr>
        }
    </tbody>
</table>

2. Create.cshtml

@model Backup
<h2>Create Backup</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.BackupName)
    @Html.TextBoxFor(m => m.BackupName)
    @Html.ValidationMessageFor(m => m.BackupName)
    @Html.LabelFor(m => m.Date)
    @Html.TextBoxFor(m => m.Date, "{0:yyyy-MM-dd}", new { @type = "date" })
    @Html.ValidationMessageFor(m => m.Date)
    <input type="submit" value="Create" />
}

3. Edit.cshtml

@model Backup
<h2>Edit Backup</h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.BackupId)
    @Html.LabelFor(m => m.BackupName)
    @Html.TextBoxFor(m => m.BackupName)
    @Html.ValidationMessageFor(m => m.BackupName)
    @Html.LabelFor(m => m.Date)
    @Html.TextBoxFor(m => m.Date, "{0:yyyy-MM-dd}", new { @type = "date" })
    @Html.ValidationMessageFor(m => m.Date)
    <input type="submit" value="Save" />
}

4. Details.cshtml

@model Backup
<h2>Backup Details</h2>
<p>
    <strong>Backup Name:</strong> @Model.BackupName<br />
    <strong>Date:</strong> @Model.Date.ToShortDateString()<br />
</p>
<a href='@Url.Action("Edit", new { id = Model.BackupId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>

5. Delete.cshtml

@model Backup
<h2>Delete Backup</h2>
<p>Are you sure you want to delete this backup?</p>
<p>
    <strong>Backup Name:</strong> @Model.BackupName<br />
    <strong>Date:</strong> @Model.Date.ToShortDateString()<br />
</p>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.BackupId)
    <input type="submit" value="Delete" />
}
<a href='@Url.Action("Index")'>Cancel</a>

Feedback Views

1. Index.cshtml

@model IEnumerable<Feedback>
<h2>Feedbacks</h2>
<a href='@Url.Action("Create")'>Create New Feedback</a>
<table>
    <thead>
        <tr>
            <th>Feedback Message</th>
            <th>Date</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var feedback in Model)
        {
            <tr>
                <td>@feedback.Message</td>
                <td>@feedback.Date.ToShortDateString()</td>
                <td>
                    @Html.ActionLink("Edit", "Edit", new { id = feedback.FeedbackId }) |
                    @Html.ActionLink("Details", "Details", new { id = feedback.FeedbackId }) |
                    @Html.ActionLink("Delete", "Delete", new { id = feedback.FeedbackId })
                </td>
            </tr>
        }
    </tbody>
</table>

2. Create.cshtml

@model Feedback
<h2>Create Feedback</h2>
@using (Html.BeginForm())
{
    @Html.LabelFor(m => m.Message)
    @Html.TextBoxFor(m => m.Message)
    @Html.ValidationMessageFor(m => m.Message)
    @Html.LabelFor(m => m.Date)
    @Html.TextBoxFor(m => m.Date, "{0:yyyy-MM-dd}", new { @type = "date" })
    @Html.ValidationMessageFor(m => m.Date)
    <input type="submit" value="Create" />
}

3. Edit.cshtml

@model Feedback
<h2>Edit Feedback </h2>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.FeedbackId)
    @Html.LabelFor(m => m.Message)
    @Html.TextBoxFor(m => m.Message)
    @Html.ValidationMessageFor(m => m.Message)
    @Html.LabelFor(m => m.Date)
    @Html.TextBoxFor(m => m.Date, "{0:yyyy-MM-dd}", new { @type = "date" })
    @Html.ValidationMessageFor(m => m.Date)
    <input type="submit" value="Save" />
}

4. Details.cshtml

@model Feedback
<h2>Feedback Details</h2>
<p>
    <strong>Message:</strong> @Model.Message<br />
    <strong>Date:</strong> @Model.Date.ToShortDateString()<br />
</p>
<a href='@Url.Action("Edit", new { id = Model.FeedbackId })'>Edit</a> |
<a href='@Url.Action("Index")">Back to List</a>

5. Delete.cshtml

@model Feedback
<h2>Delete Feedback</h2>
<p>Are you sure you want to delete this feedback?</p>
<p>
    <strong>Message:</strong> @Model.Message<br />
    <strong>Date:</strong> @Model.Date.ToShortDateString()<br />
</p>
@using (Html.BeginForm())
{
    @Html.HiddenFor(m => m.FeedbackId)
    <input type="submit" value="Delete" />
}
<a href='@Url.Action("Index")'>Cancel</a>

This completes the basic view structure for all controllers in the ASP.NET MVC application. Each view corresponds to the actions defined in the respective controllers, allowing for a full CRUD (Create, Read, Update, Delete) interface for each model.

Creating a Dashboard Page

Creating a dashboard page in an ASP.NET MVC application involves aggregating data from various models and presenting it in a user-friendly format. Below, I will outline how to create a simple dashboard that displays consolidated data related to users, expenses, incomes, budgets, reports, notifications, backups, and feedback.

Step 1: Create a Dashboard ViewModel

First, we need to create a ViewModel that will hold the consolidated data for the dashboard.

public class DashboardViewModel
{
    public int TotalUsers { get; set; }
    public decimal TotalExpenses { get; set; }
    public decimal TotalIncomes { get; set; }
    public decimal TotalBudgets { get; set; }
    public int TotalReports { get; set; }
    public int TotalNotifications { get; set; }
    public int TotalBackups { get; set; }
    public int TotalFeedbacks { get; set; }
}

Step 2: Create a Dashboard Controller

Next, we will create a DashboardController that will fetch the necessary data and pass it to the view.

using System.Web.Mvc;
public class DashboardController : Controller
{
    private readonly UserRepository _userRepository;
    private readonly ExpenseRepository _expenseRepository;
    private readonly IncomeRepository _incomeRepository;
    private readonly BudgetRepository _budgetRepository;
    private readonly ReportRepository _reportRepository;
    private readonly NotificationRepository _notificationRepository;
    private readonly BackupRepository _backupRepository;
    private readonly FeedbackRepository _feedbackRepository;
    public DashboardController()
    {
        _userRepository = new UserRepository();
        _expenseRepository = new ExpenseRepository();
        _incomeRepository = new IncomeRepository();
        _budgetRepository = new BudgetRepository();
        _reportRepository = new ReportRepository();
        _notificationRepository = new NotificationRepository();
        _backupRepository = new BackupRepository();
        _feedbackRepository = new FeedbackRepository();
    }
    public ActionResult Index()
    {
        var model = new DashboardViewModel
        {
            TotalUsers = _userRepository.GetAllUsers().Count(),
            TotalExpenses = _expenseRepository.GetAllExpenses().Sum(e => e.Amount),
            TotalIncomes = _incomeRepository.GetAllIncomes().Sum(i => i.Amount),
            TotalBudgets = _budgetRepository.GetAllBudgets().Sum(b => b.Amount),
            TotalReports = _reportRepository.GetAllReports().Count(),
            TotalNotifications = _notificationRepository.GetAllNotifications().Count(),
            TotalBackups = _backupRepository.GetAllBackups().Count(),
            TotalFeedbacks = _feedbackRepository.GetAllFeedbacks().Count()
        };
        return View(model);
    }
}

Step 3: Create the Dashboard View

Now, we will create the view for the dashboard. This view will display the consolidated data in a user-friendly format.

Views/Dashboard/Index.cshtml

@model DashboardViewModel
@{
    ViewBag.Title = "Dashboard";
}
<h2>Dashboard</h2>
<div class="dashboard">
    <div class="card">
        <h3>Total Users</h3>
        <p>@Model.TotalUsers</p>
    </div>
    <div class="card">
        <h3>Total Expenses</h3>
        <p>@Model.TotalExpenses.ToString("C")</p>
    </div>
    <div class="card">
        <h3>Total Incomes</h3>
        <p>@Model.TotalIncomes.ToString("C")</p>
    </div>
    <div class="card">
        <h3>Total Budgets</h3>
        <p>@Model.TotalBudgets.ToString("C")</p>
    </div>
    <div class="card">
        <h3>Total Reports</h3>
        <p>@Model.TotalReports</p>
    </div>
    <div class="card">
        <h3>Total Notifications</h3>
        <p>@Model.TotalNotifications</p>
    </div>
    <div class="card">
        <h3>Total Backups</h3>
        <p>@Model.TotalBackups</p>
    </div>
    <div class="card">
        <h3>Total Feedbacks</h3>
        <p>@Model.TotalFeedbacks</p>
    </div>
</div>
<style>
    .dashboard {
        display: grid;
        grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
        gap: 20px;
    }
    .card {
        border: 1px solid #ccc;
        padding: 20px;
        border-radius: 5px;
        text-align: center;
    }
</style>

Step 4: Update the Route Configuration

Make sure to add a route for the dashboard in your RouteConfig.cs file if you want to access it directly.

 routes.MapRoute(
    name: "Dashboard",
    url: "Dashboard",
    defaults: new { controller = "Dashboard", action = "Index" }
);

Step 5: Accessing the Dashboard

You can now access the dashboard by navigating to /Dashboard in your web application. This page will display the consolidated data related to users, expenses, incomes, budgets, reports, notifications, backups, and feedbacks in a visually appealing format.