Project Introduction

The Stock Market Prediction System is designed to provide users with insights and predictions regarding stock prices based on historical data and economic indicators. Built using ASP.NET and SQL Server, this application allows users to analyze stock market trends, create and manage investment portfolios, and receive alerts based on specific criteria. The system leverages predictive models to forecast stock prices, helping users make informed investment decisions.

Project Objectives

• To create a secure user authentication system for managing user accounts and roles.
• To enable the storage and management of historical stock data, including prices and trading volumes.
• To track and manage economic indicators that may influence stock prices.
• To generate predictions for stock prices based on historical data and models used.
• To allow users to create and manage investment portfolios, including tracking individual stock holdings.
• To implement a performance reporting system that evaluates portfolio performance over time.
• To provide alerts to users based on specific stock price movements or trading volumes.
• To offer various trading strategies that users can adopt for their investments.
• To collect user feedback to continuously improve the system's functionality and user experience.

Project Modules

1. User Management Module: Handles user registration, login, and role management.
2. Stock Data Management Module: Manages the storage and retrieval of historical stock data.
3. Economic Indicators Module: Tracks and manages economic indicators relevant to stock performance.
4. Prediction Module: Generates stock price predictions based on historical data and models.
5. Portfolio Management Module: Allows users to create and manage their investment portfolios.
6. Performance Reporting Module: Generates reports on portfolio performance and returns.
7. Alerts Module: Sends alerts to users based on predefined criteria for stocks.
8. Trading Strategies Module: Provides users with various trading strategies to enhance their investment decisions.
9. Feedback Module: Collects user feedback to improve the application.

SQL Server Database Tables

-- Create Users Table
CREATE TABLE Users (
    UserId INT PRIMARY KEY IDENTITY(1,1),
    Username NVARCHAR(50) NOT NULL UNIQUE,
    PasswordHash NVARCHAR(256) NOT NULL,
    Email NVARCHAR(100) NOT NULL UNIQUE,
    CreatedAt DATETIME DEFAULT GETDATE()
);
-- Create StockData Table
CREATE TABLE StockData (
    StockDataId INT PRIMARY KEY IDENTITY(1,1),
    StockSymbol NVARCHAR(10) NOT NULL,
    Date DATE NOT NULL,
    OpenPrice DECIMAL(18, 2) NOT NULL,
    ClosePrice DECIMAL(18, 2) NOT NULL,
    HighPrice DECIMAL(18, 2) NOT NULL,
    LowPrice DECIMAL(18, 2) NOT NULL,
    Volume BIGINT NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE()
);
-- Create EconomicIndicators Table
CREATE TABLE EconomicIndicators (
    IndicatorId INT PRIMARY KEY IDENTITY(1,1),
    IndicatorName NVARCHAR(100) NOT NULL,
    Value DECIMAL(18, 2) NOT NULL,
    Date DATE NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE()
);
-- Create Predictions Table
CREATE TABLE Predictions (
    PredictionId INT PRIMARY KEY IDENTITY(1,1),
    StockSymbol NVARCHAR(10) NOT NULL,
    PredictedPrice DECIMAL(18, 2) NOT NULL,
    PredictionDate DATE NOT NULL,
    ModelUsed NVARCHAR(100),
    CreatedAt DATETIME DEFAULT GETDATE()
);
-- Create TradingStrategies Table
CREATE TABLE TradingStrategies (
    StrategyId INT PRIMARY KEY IDENTITY(1,1),
    StrategyName NVARCHAR(100) NOT NULL,
    Description NVARCHAR(MAX),
    CreatedAt DATETIME DEFAULT GETDATE()
);
-- Create Portfolios Table
CREATE TABLE Portfolios (
    PortfolioId INT PRIMARY KEY IDENTITY(1,1),
    UserId INT,
    PortfolioName NVARCHAR(100) NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);
-- Create PortfolioStocks Table (Many-to-Many relationship between Portfolios and StockData)
CREATE TABLE PortfolioStocks (
    PortfolioStockId INT PRIMARY KEY IDENTITY(1,1),
    PortfolioId INT,
    StockSymbol NVARCHAR(10) NOT NULL,
    Quantity INT NOT NULL,
    PurchasePrice DECIMAL(18, 2) NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (PortfolioId) REFERENCES Portfolios(PortfolioId)
);
-- Create PerformanceReports Table
CREATE TABLE PerformanceReports (
    ReportId INT PRIMARY KEY IDENTITY(1,1),
    PortfolioId INT,
    ReportDate DATE NOT NULL,
    TotalValue DECIMAL(18, 2) NOT NULL,
    TotalReturn DECIMAL(18, 2) NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (PortfolioId) REFERENCES Portfolios(PortfolioId)
);
-- Create Alerts Table
CREATE TABLE Alerts (
    AlertId INT PRIMARY KEY IDENTITY(1,1),
    UserId INT,
    StockSymbol NVARCHAR(10) NOT NULL,
    AlertType NVARCHAR(50) NOT NULL, -- e.g., Price Alert, Volume Alert
    Threshold DECIMAL(18, 2) NOT NULL,
    IsActive BIT DEFAULT 1,
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (User Id) REFERENCES Users(UserId)
);

Explanation of the Tables

Users: Stores user information, including username, password hash, email, and creation date.

StockData: Contains historical stock data, including stock symbol, date, open price, close price, high price, low price, and volume.

EconomicIndicators: Stores economic indicators that may affect stock prices, including the indicator name, value, and date.

Predictions: Contains predictions made by the system, including the stock symbol, predicted price, prediction date, and model used.

TradingStrategies: Stores different trading strategies that can be applied, including strategy name and description.

Portfolios: Manages user portfolios, linking them to users and storing portfolio names.

PortfolioStocks: A junction table to manage the many-to-many relationship between portfolios and stock data, including quantity and purchase price.

PerformanceReports: Stores performance reports for portfolios, including total value and total return.

Alerts: Manages alerts set by users for specific stocks, including alert type, threshold, and status.

To create models and repositories using ADO.NET for the provided SQL Server tables in an ASP.NET application

We will follow these steps:

Create Models

Define C# classes that represent 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 DateTime CreatedAt { get; set; }
}
public class StockData
{
    public int StockDataId { get; set; }
    public string StockSymbol { get; set; }
    public DateTime Date { get; set; }
    public decimal OpenPrice { get; set; }
    public decimal ClosePrice { get; set; }
    public decimal HighPrice { get; set; }
    public decimal LowPrice { get; set; }
    public long Volume { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class EconomicIndicator
{
    public int IndicatorId { get; set; }
    public string IndicatorName { get; set; }
    public decimal Value { get; set; }
    public DateTime Date { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class Prediction
{
    public int PredictionId { get; set; }
    public string StockSymbol { get; set; }
    public decimal PredictedPrice { get; set; }
    public DateTime PredictionDate { get; set; }
    public string ModelUsed { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class TradingStrategy
{
    public int StrategyId { get; set; }
    public string StrategyName { get; set; }
    public string Description { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class Portfolio
{
    public int PortfolioId { get; set; }
    public int UserId { get; set; }
    public string PortfolioName { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class PortfolioStock
{
    public int PortfolioStockId { get; set; }
    public int PortfolioId { get; set; }
    public string StockSymbol { get; set; }
    public int Quantity { get; set; }
    public decimal PurchasePrice { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class PerformanceReport
{
    public int ReportId { get; set; }
    public int PortfolioId { get; set; }
    public DateTime ReportDate { get; set; }
    public decimal TotalValue { get; set; }
    public decimal TotalReturn { get; set; }
    public DateTime CreatedAt { get; set; }
}
public class Alert
{
    public int AlertId { get; set; }
    public int UserId { get; set; }
    public string StockSymbol { get; set; }
    public string AlertType { get; set; }
    public decimal Threshold { get; set; }
    public bool IsActive { get; set; }
    public DateTime CreatedAt { get; set; }
}

Create Repositories

Next, we will create repository classes for each model. Each repository will implement basic CRUD operations using ADO.NET.

User Repository Implementation

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
public class UserRepository
{
    private readonly string _connectionString;
    public UserRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<User> GetAll()
    {
        var users = new List<User>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Users", connection);
            connection.Open();
            using (var 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(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return users;
    }
    public User GetById(int id)
    {
        User user = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Users WHERE UserId = @User Id", connection);
            command.Parameters.AddWithValue("@User  Id", id);
            connection.Open();
            using (var 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(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return user;
    }
    public void Add(User user)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Users (Username, PasswordHash, Email) VALUES (@Username, @PasswordHash, @Email)", connection);
            command.Parameters.AddWithValue("@Username", user.Username);
            command.Parameters.AddWithValue("@PasswordHash", user.PasswordHash);
            command.Parameters.AddWithValue("@Email", user.Email);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(User user)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Users SET Username = @Username, PasswordHash = @PasswordHash, Email = @Email WHERE UserId = @User  Id", connection);
            command.Parameters.AddWithValue("@Username", user.Username);
            command.Parameters.AddWithValue("@PasswordHash", user.PasswordHash);
            command.Parameters.AddWithValue("@Email", user.Email);
            command.Parameters.AddWithValue("@User  Id", user.UserId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Users WHERE UserId = @User  Id", connection);
            command.Parameters.AddWithValue("@User  Id", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

StockData Repository Implementation

public class StockDataRepository
{
    private readonly string _connectionString;
    public StockDataRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<StockData> GetAll()
    {
        var stockDataList = new List<StockData>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM StockData", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    stockDataList.Add(new StockData
                    {
                        StockDataId = (int)reader["StockDataId"],
                        StockSymbol = reader["StockSymbol"].ToString(),
                        Date = (DateTime)reader["Date"],
                        OpenPrice = (decimal)reader["OpenPrice"],
                        ClosePrice = (decimal)reader["ClosePrice"],
                        HighPrice = (decimal)reader["HighPrice"],
                        LowPrice = (decimal)reader["LowPrice"],
                        Volume = (long)reader["Volume"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return stockDataList;
    }
    public StockData GetById(int id)
    {
        StockData stockData = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM StockData WHERE StockDataId = @StockDataId", connection);
            command.Parameters.AddWithValue("@StockDataId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    stockData = new StockData
                    {
                        StockDataId = (int)reader["StockDataId"],
                        StockSymbol = reader["StockSymbol"].ToString(),
                        Date = (DateTime)reader["Date"],
                        OpenPrice = (decimal)reader["OpenPrice"],
                        ClosePrice = (decimal)reader["ClosePrice"],
                        HighPrice = (decimal)reader["HighPrice"],
                        LowPrice = (decimal)reader["LowPrice"],
                        Volume = (long)reader["Volume"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return stockData;
    }
    public void Add(StockData stockData)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO StockData (StockSymbol, Date, OpenPrice, ClosePrice, HighPrice, LowPrice, Volume) VALUES (@StockSymbol, @Date, @OpenPrice, @ClosePrice, @HighPrice, @LowPrice, @Volume)", connection);
            command.Parameters.AddWithValue("@StockSymbol", stockData.StockSymbol);
            command.Parameters.Add WithValue("@Date", stockData.Date);
            command.Parameters.AddWithValue("@OpenPrice", stockData.OpenPrice);
            command.Parameters.AddWithValue("@ClosePrice", stockData.ClosePrice);
            command.Parameters.AddWithValue("@HighPrice", stockData.HighPrice);
            command.Parameters.AddWithValue("@LowPrice", stockData.LowPrice);
            command.Parameters.AddWithValue("@Volume", stockData.Volume);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(StockData stockData)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE StockData SET StockSymbol = @StockSymbol, Date = @Date, OpenPrice = @OpenPrice, ClosePrice = @ClosePrice, HighPrice = @HighPrice, LowPrice = @LowPrice, Volume = @Volume WHERE StockDataId = @StockDataId", connection);
            command.Parameters.AddWithValue("@StockSymbol", stockData.StockSymbol);
            command.Parameters.AddWithValue("@Date", stockData.Date);
            command.Parameters.AddWithValue("@OpenPrice", stockData.OpenPrice);
            command.Parameters.AddWithValue("@ClosePrice", stockData.ClosePrice);
            command.Parameters.AddWithValue("@HighPrice", stockData.HighPrice);
            command.Parameters.AddWithValue("@LowPrice", stockData.LowPrice);
            command.Parameters.AddWithValue("@Volume", stockData.Volume);
            command.Parameters.AddWithValue("@StockDataId", stockData.StockDataId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM StockData WHERE StockDataId = @StockDataId", connection);
            command.Parameters.AddWithValue("@StockDataId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

Additional Repositories

You can follow a similar pattern to create repositories for the other models: EconomicIndicator, Prediction, TradingStrategy, Portfolio, PortfolioStock, PerformanceReport, and Alert. Each repository will implement methods for GetAll, GetById, Add, Update, and Delete using ADO.NET.

Summary

This setup provides a structured way to manage data access for your ASP.NET application using ADO.NET. Each model corresponds to a database table, and the repositories encapsulate the logic for interacting with the database, allowing for clean separation of concerns and easier maintenance.

Now create remaining Repositories.

Sure! Below are the implementations for the remaining repositories based on the models we defined earlier: EconomicIndicator, Prediction, TradingStrategy, Portfolio, PortfolioStock, PerformanceReport, and Alert. Each repository will follow the same pattern as the User Repository and StockDataRepository.

1. EconomicIndicator Repository Implementation

public class EconomicIndicatorRepository
{
    private readonly string _connectionString;
    public EconomicIndicatorRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<EconomicIndicator> GetAll()
    {
        var indicators = new List<EconomicIndicator>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM EconomicIndicators", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    indicators.Add(new EconomicIndicator
                    {
                        IndicatorId = (int)reader["IndicatorId"],
                        IndicatorName = reader["IndicatorName"].ToString(),
                        Value = (decimal)reader["Value"],
                        Date = (DateTime)reader["Date"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return indicators;
    }
    public EconomicIndicator GetById(int id)
    {
        EconomicIndicator indicator = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM EconomicIndicators WHERE IndicatorId = @IndicatorId", connection);
            command.Parameters.AddWithValue("@IndicatorId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    indicator = new EconomicIndicator
                    {
                        IndicatorId = (int)reader["IndicatorId"],
                        IndicatorName = reader["IndicatorName"].ToString(),
                        Value = (decimal)reader["Value"],
                        Date = (DateTime)reader["Date"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return indicator;
    }
    public void Add(EconomicIndicator indicator)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO EconomicIndicators (IndicatorName, Value, Date) VALUES (@IndicatorName, @Value, @Date)", connection);
            command.Parameters.AddWithValue("@IndicatorName", indicator.IndicatorName);
            command.Parameters.AddWithValue("@Value", indicator.Value);
            command.Parameters.AddWithValue("@Date", indicator.Date);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(EconomicIndicator indicator)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE EconomicIndicators SET IndicatorName = @IndicatorName, Value = @Value, Date = @Date WHERE IndicatorId = @IndicatorId", connection);
            command.Parameters.AddWithValue("@IndicatorId", indicator.IndicatorId);
            command.Parameters.AddWithValue("@IndicatorName", indicator.IndicatorName);
            command.Parameters.AddWithValue("@Value", indicator.Value);
            command.Parameters.AddWithValue("@Date", indicator.Date);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM EconomicIndicators WHERE IndicatorId = @IndicatorId", connection);
            command.Parameters.AddWithValue("@IndicatorId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

2. Prediction Repository Implementation

public class PredictionRepository
{
    private readonly string _connectionString;
    public PredictionRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<Prediction> GetAll()
    {
        var predictions = new List<Prediction>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Predictions", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    predictions.Add(new Prediction
                    {
                        PredictionId = (int)reader["PredictionId"],
                        StockSymbol = reader["StockSymbol"].ToString(),
                        PredictedPrice = (decimal)reader["PredictedPrice"],
                        PredictionDate = (DateTime)reader["PredictionDate"],
                        ModelUsed = reader["ModelUsed"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return predictions;
    }
    public Prediction GetById(int id)
    {
        Prediction prediction = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Predictions WHERE PredictionId = @PredictionId", connection);
            command.Parameters.AddWithValue("@PredictionId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    prediction = new Prediction
                    {
                        PredictionId = (int)reader["PredictionId"],
                        StockSymbol = reader["StockSymbol"].ToString(),
                        PredictedPrice = (decimal)reader["PredictedPrice"],
                        PredictionDate = (DateTime)reader["PredictionDate"],
                        ModelUsed = reader["ModelUsed"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return prediction;
    }
    public void Add(Prediction prediction)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Predictions (StockSymbol, PredictedPrice, PredictionDate, ModelUsed) VALUES (@StockSymbol, @PredictedPrice, @PredictionDate, @ModelUsed)", connection);
            command.Parameters.AddWithValue("@StockSymbol", prediction.StockSymbol);
            command.Parameters.AddWithValue("@PredictedPrice", prediction.PredictedPrice);
            command.Parameters.AddWithValue("@PredictionDate", prediction.PredictionDate);
            command.Parameters.AddWithValue("@ModelUsed", prediction.ModelUsed);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(Prediction prediction)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Predictions SET StockSymbol = @StockSymbol, PredictedPrice = @PredictedPrice, PredictionDate = @PredictionDate, ModelUsed = @ModelUsed WHERE PredictionId = @PredictionId", connection);
            command.Parameters.AddWithValue("@PredictionId", prediction.PredictionId);
            command.Parameters.AddWithValue("@StockSymbol", prediction.StockSymbol);
            command.Parameters.AddWithValue("@PredictedPrice", prediction.PredictedPrice);
            command.Parameters.AddWithValue("@PredictionDate", prediction.PredictionDate);
            command.Parameters.AddWithValue("@ModelUsed", prediction.ModelUsed);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Predictions WHERE PredictionId = @PredictionId", connection);
            command.Parameters.AddWithValue("@PredictionId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

3. TradingStrategy Repository Implementation

public class TradingStrategyRepository
{
    private readonly string _connectionString;
    public TradingStrategyRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<TradingStrategy> GetAll()
    {
        var strategies = new List<TradingStrategy>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM TradingStrategies", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    strategies.Add(new TradingStrategy
                    {
                        StrategyId = (int)reader["StrategyId"],
                        StrategyName = reader["StrategyName"].ToString(),
                        Description = reader["Description"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return strategies;
    }
    public TradingStrategy GetById(int id)
    {
        TradingStrategy strategy = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM TradingStrategies WHERE StrategyId = @StrategyId", connection);
            command.Parameters.AddWithValue("@StrategyId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    strategy = new TradingStrategy
                    {
                        StrategyId = (int)reader["StrategyId"],
                        StrategyName = reader["StrategyName"].ToString(),
                        Description = reader["Description"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return strategy;
    }
    public void Add(TradingStrategy strategy)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO TradingStrategies (StrategyName, Description) VALUES (@StrategyName, @Description)", connection);
            command.Parameters.AddWithValue("@StrategyName", strategy.StrategyName);
            command.Parameters.AddWithValue("@Description", strategy.Description);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(TradingStrategy strategy)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE TradingStrategies SET StrategyName = @StrategyName, Description = @Description WHERE StrategyId = @StrategyId", connection);
            command.Parameters.AddWithValue("@StrategyId", strategy.StrategyId);
            command.Parameters.AddWithValue("@StrategyName", strategy.StrategyName);
            command.Parameters.AddWithValue("@Description", strategy.Description);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM TradingStrategies WHERE StrategyId = @StrategyId", connection);
            command.Parameters.AddWithValue("@StrategyId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

4. Portfolio Repository Implementation

public class PortfolioRepository
{
    private readonly string _connectionString;
    public PortfolioRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<Portfolio> GetAll()
    {
        var portfolios = new List<Portfolio>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Portfolios", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    portfolios.Add(new Portfolio
                    {
                        PortfolioId = (int)reader["PortfolioId"],
                        UserId = (int)reader["User Id"],
                        PortfolioName = reader["PortfolioName"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return portfolios;
    }
    public Portfolio GetById(int id)
    {
        Portfolio portfolio = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Portfolios WHERE PortfolioId = @PortfolioId", connection);
            command.Parameters.AddWithValue("@PortfolioId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    portfolio = new Portfolio
                    {
                        PortfolioId = (int)reader["PortfolioId"],
                        UserId = (int)reader["User Id"],
                        PortfolioName = reader["PortfolioName"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return portfolio;
    }
    public void Add(Portfolio portfolio)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Portfolios (User Id, PortfolioName) VALUES (@User Id, @PortfolioName)", connection);
            command.Parameters.AddWithValue("@User Id", portfolio.UserId);
            command.Parameters.AddWithValue("@PortfolioName", portfolio.PortfolioName);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(Portfolio portfolio)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Portfolios SET UserId = @User Id, PortfolioName = @PortfolioName WHERE PortfolioId = @PortfolioId", connection);
            command.Parameters.AddWithValue("@PortfolioId", portfolio.PortfolioId);
            command.Parameters.AddWithValue("@User Id", portfolio.UserId);
            command.Parameters.AddWithValue("@PortfolioName", portfolio.PortfolioName);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Portfolios WHERE PortfolioId = @PortfolioId", connection);
            command.Parameters.AddWithValue("@PortfolioId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

5. PortfolioStock Repository Implementation

public class PortfolioStockRepository
{
    private readonly string _connectionString;
    public PortfolioStockRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<PortfolioStock> GetAll()
    {
        var portfolioStocks = new List<PortfolioStock>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM PortfolioStocks", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    portfolioStocks.Add(new PortfolioStock
                    {
                        PortfolioStockId = (int)reader["PortfolioStockId"],
                        PortfolioId = (int)reader["PortfolioId"],
                        StockSymbol = reader["StockSymbol"].ToString(),
                        Quantity = (int)reader["Quantity"],
                        PurchasePrice = (decimal)reader["PurchasePrice"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return portfolioStocks;
    }
    
    public PortfolioStock GetById(int id)
    {
        PortfolioStock portfolioStock = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM PortfolioStocks WHERE PortfolioStockId = @PortfolioStockId", connection);
            command.Parameters.AddWithValue("@PortfolioStockId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    portfolioStock = new PortfolioStock
                    {
                        PortfolioStockId = (int)reader["PortfolioStockId"],
                        PortfolioId = (int)reader["PortfolioId"],
                        StockSymbol = reader["StockSymbol"].ToString(),
                        Quantity = (int)reader["Quantity"],
                        PurchasePrice = (decimal)reader["PurchasePrice"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return portfolioStock;
    }
    public void Add(PortfolioStock portfolioStock)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO PortfolioStocks (PortfolioId, StockSymbol, Quantity, PurchasePrice) VALUES (@PortfolioId, @StockSymbol, @Quantity, @PurchasePrice)", connection);
            command.Parameters.AddWithValue("@PortfolioId", portfolioStock.PortfolioId);
            command.Parameters.AddWithValue("@StockSymbol", portfolioStock.StockSymbol);
            command.Parameters.AddWithValue("@Quantity", portfolioStock.Quantity);
            command.Parameters.AddWithValue("@PurchasePrice", portfolioStock.PurchasePrice);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(PortfolioStock portfolioStock)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE PortfolioStocks SET PortfolioId = @PortfolioId, StockSymbol = @StockSymbol, Quantity = @Quantity, PurchasePrice = @PurchasePrice WHERE PortfolioStockId = @PortfolioStockId", connection);
            command.Parameters.AddWithValue("@PortfolioStockId", portfolioStock.PortfolioStockId);
            command.Parameters.AddWithValue("@PortfolioId", portfolioStock.PortfolioId);
            command.Parameters.AddWithValue("@StockSymbol", portfolioStock.StockSymbol);
            command.Parameters.AddWithValue("@Quantity", portfolioStock.Quantity);
            command.Parameters.AddWithValue("@PurchasePrice", portfolioStock.PurchasePrice);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM PortfolioStocks WHERE PortfolioStockId = @PortfolioStockId", connection);
            command.Parameters.AddWithValue("@PortfolioStockId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

6. PerformanceReport Repository Implementation

public class PerformanceReportRepository
{
    private readonly string _connectionString;
    public PerformanceReportRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<PerformanceReport> GetAll()
    {
        var reports = new List<PerformanceReport>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM PerformanceReports", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    reports.Add(new PerformanceReport
                    {
                        ReportId = (int)reader["ReportId"],
                        PortfolioId = (int)reader["PortfolioId"],
                        ReportDate = (DateTime)reader["ReportDate"],
                        TotalValue = (decimal)reader["TotalValue"],
                        TotalReturn = (decimal)reader["TotalReturn"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return reports;
    }
    public PerformanceReport GetById(int id)
    {
        PerformanceReport report = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM PerformanceReports WHERE ReportId = @ReportId", connection);
            command.Parameters.AddWithValue("@ReportId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    report = new PerformanceReport
                    {
                        ReportId = (int)reader["ReportId"],
                        PortfolioId = (int)reader["PortfolioId"],
                        ReportDate = (DateTime)reader["ReportDate"],
                        TotalValue = (decimal)reader["TotalValue"],
                        TotalReturn = (decimal)reader["TotalReturn"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return report;
    }
    public void Add(PerformanceReport report)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO PerformanceReports (PortfolioId, ReportDate, TotalValue, TotalReturn) VALUES (@PortfolioId, @ReportDate, @TotalValue, @TotalReturn)", connection);
            command.Parameters.AddWithValue("@PortfolioId", report.PortfolioId);
            command.Parameters.AddWithValue("@ReportDate", report.ReportDate);
            command.Parameters.AddWithValue("@TotalValue", report.TotalValue);
            command.Parameters.AddWithValue("@TotalReturn", report.TotalReturn);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(PerformanceReport report)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE PerformanceReports SET PortfolioId = @PortfolioId, ReportDate = @ReportDate, TotalValue = @TotalValue, TotalReturn = @TotalReturn WHERE ReportId = @ReportId", connection);
            command.Parameters.AddWithValue("@ReportId", report.ReportId);
            command.Parameters.AddWithValue("@PortfolioId", report.PortfolioId);
            command.Parameters.AddWithValue("@ReportDate", report.ReportDate);
            command.Parameters.AddWithValue("@TotalValue", report.TotalValue);
            command.Parameters.AddWithValue("@TotalReturn", report.TotalReturn);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM PerformanceReports WHERE ReportId = @ReportId", connection);
            command.Parameters.AddWithValue("@ReportId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

7. Alert Repository Implementation

public class AlertRepository
{
    private readonly string _connectionString;
    public AlertRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public IEnumerable<Alert> GetAll()
    {
        var alerts = new List<Alert>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Alerts", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    alerts.Add(new Alert
                    {
                        AlertId = (int)reader["AlertId"],
                        UserId = (int)reader["User  Id"],
                        StockSymbol = reader["StockSymbol"].ToString(),
                        AlertType = reader["AlertType"].ToString(),
                        Threshold = (decimal)reader["Threshold"],
                        IsActive = (bool)reader["IsActive"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return alerts;
    }
    public Alert GetById(int id)
    {
        Alert alert = null;
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Alerts WHERE AlertId = @AlertId", connection);
            command.Parameters.AddWithValue("@AlertId", id);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    alert = new Alert
                    {
                        AlertId = (int)reader["AlertId"],
                        UserId = (int)reader["User  Id"],
                        StockSymbol = reader["StockSymbol"].ToString(),
                        AlertType = reader["AlertType"].ToString(),
                        Threshold = (decimal)reader["Threshold"],
                        IsActive = (bool)reader["IsActive"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return alert;
    }
    public void Add(Alert alert)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Alerts (User  Id, StockSymbol, AlertType, Threshold, IsActive) VALUES (@User  Id, @StockSymbol, @AlertType, @Threshold, @IsActive)", connection);
            command.Parameters.AddWithValue("@User  Id", alert.UserId);
            command.Parameters.AddWithValue("@StockSymbol", alert.StockSymbol);
            command.Parameters.AddWithValue("@AlertType", alert.AlertType);
            command.Parameters.AddWithValue("@Threshold", alert.Threshold);
            command.Parameters.AddWithValue("@IsActive", alert.IsActive);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Update(Alert alert)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Alerts SET UserId = @User  Id, StockSymbol = @StockSymbol, AlertType = @AlertType, Threshold = @Threshold, IsActive = @IsActive WHERE AlertId = @AlertId", connection);
            command.Parameters.AddWithValue("@AlertId", alert.AlertId);
            command .Parameters.AddWithValue("@User   Id", alert.UserId);
            command.Parameters.AddWithValue("@StockSymbol", alert.StockSymbol);
            command.Parameters.AddWithValue("@AlertType", alert.AlertType);
            command.Parameters.AddWithValue("@Threshold", alert.Threshold);
            command.Parameters.AddWithValue("@IsActive", alert.IsActive);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void Delete(int id)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Alerts WHERE AlertId = @AlertId", connection);
            command.Parameters.AddWithValue("@AlertId", id);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

With these implementations

You now have a complete set of repository classes for all the models defined earlier. Each repository provides methods for basic CRUD operations, allowing you to interact with the database effectively using ADO.NET in your ASP.NET application. This structure promotes clean code and separation of concerns, making it easier to maintain and extend your application in the future.

To create controllers for each repository in an ASP.NET MVC application

We will follow the standard MVC pattern. Each controller will handle HTTP requests, interact with the corresponding repository, and return views or data as needed.

Below are example controllers for each of the repositories we created earlier

User, StockData, EconomicIndicator, Prediction, TradingStrategy, Portfolio, PortfolioStock, PerformanceReport, and Alert. Each controller will include basic CRUD actions (Create, Read, Update, Delete) and will use dependency injection to access the repositories.

1. UserController

using Microsoft.AspNetCore.Mvc;
public class UserController : Controller
{
    private readonly UserRepository _userRepository;
    public UserController(UserRepository userRepository)
    {
        _userRepository = userRepository;
    }
    public IActionResult Index()
    {
        var users = _userRepository.GetAll();
        return View(users);
    }
    public IActionResult Details(int id)
    {
        var user = _userRepository.GetById(id);
        return View(user);
    }
    public IActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public IActionResult Create(User user)
    {
        if (ModelState.IsValid)
        {
            _userRepository.Add(user);
            return RedirectToAction(nameof(Index));
        }
        return View(user);
    }
    public IActionResult Edit(int id)
    {
        var user = _userRepository.GetById(id);
        return View(user);
    }
    [HttpPost]
    public IActionResult Edit(User user)
    {
        if (ModelState.IsValid)
        {
            _userRepository.Update(user);
            return RedirectToAction(nameof(Index));
        }
        return View(user);
    }
    public IActionResult Delete(int id)
    {
        var user = _userRepository.GetById(id);
        return View(user);
    }
    [HttpPost, ActionName("Delete")]
    public IActionResult DeleteConfirmed(int id)
    {
        _userRepository.Delete(id);
        return RedirectToAction(nameof(Index));
    }
}

2. StockDataController

using Microsoft.AspNetCore.Mvc;
public class StockDataController : Controller
{
    private readonly StockDataRepository _stockDataRepository;
    public StockDataController(StockDataRepository stockDataRepository)
    {
        _stockDataRepository = stockDataRepository;
    }
    public IActionResult Index()
    {
        var stockDataList = _stockDataRepository.GetAll();
        return View(stockDataList);
    }
    public IActionResult Details(int id)
    {
        var stockData = _stockDataRepository.GetById(id);
        return View(stockData);
    }
    public IActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public IActionResult Create(StockData stockData)
    {
        if (ModelState.IsValid)
        {
            _stockDataRepository.Add(stockData);
            return RedirectToAction(nameof(Index));
        }
        return View(stockData);
    }
    public IActionResult Edit(int id)
    {
        var stockData = _stockDataRepository.GetById(id);
        return View(stockData);
    }
    [HttpPost]
    public IActionResult Edit(StockData stockData)
    {
        if (ModelState.IsValid)
        {
            _stockDataRepository.Update(stockData);
            return RedirectToAction(nameof(Index));
        }
        return View(stockData);
    }
    public IActionResult Delete(int id)
    {
        var stockData = _stockDataRepository.GetById(id);
        return View(stockData);
    }
    [HttpPost, ActionName("Delete")]
    public IActionResult DeleteConfirmed(int id)
    {
        _stockDataRepository.Delete(id);
        return RedirectToAction(nameof(Index));
    }
}

3. EconomicIndicatorController

using Microsoft.AspNetCore.Mvc;
public class EconomicIndicatorController : Controller
{
    private readonly EconomicIndicatorRepository _economicIndicatorRepository;
    public EconomicIndicatorController(EconomicIndicatorRepository economicIndicatorRepository)
    {
        _economicIndicatorRepository = economicIndicatorRepository;
    }
    public IActionResult Index()
    {
        var indicators = _economicIndicatorRepository.GetAll();
        return View(indicators);
    }
    public IActionResult Details(int id)
    {
        var indicator = _economicIndicatorRepository.GetById(id);
        return View(indicator);
    }
    public IActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public IActionResult Create(EconomicIndicator indicator)
    {
        if (ModelState.IsValid)
        {
            _economicIndicatorRepository.Add(indicator);
            return RedirectToAction(nameof(Index));
        }
        return View(indicator);
    }
    public IActionResult Edit(int id)
    {
        var indicator = _economicIndicatorRepository.GetById(id);
        return View(indicator);
    }
    [HttpPost]
    public IAction Result Edit(EconomicIndicator indicator)
    {
        if (ModelState.IsValid)
        {
            _economicIndicatorRepository.Update(indicator);
            return RedirectToAction(nameof(Index));
        }
        return View(indicator);
    }
    public IActionResult Delete(int id)
    {
        var indicator = _economicIndicatorRepository.GetById(id);
        return View(indicator);
    }
    [HttpPost, ActionName("Delete")]
    public IActionResult DeleteConfirmed(int id)
    {
        _economicIndicatorRepository.Delete(id);
        return RedirectToAction(nameof(Index));
    }
}

4. PredictionController

using Microsoft.AspNetCore.Mvc;
public class PredictionController : Controller
{
    private readonly PredictionRepository _predictionRepository;
    public PredictionController(PredictionRepository predictionRepository)
    {
        _predictionRepository = predictionRepository;
    }
    public IActionResult Index()
    {
        var predictions = _predictionRepository.GetAll();
        return View(predictions);
    }
    public IActionResult Details(int id)
    {
        var prediction = _predictionRepository.GetById(id);
        return View(prediction);
    }
    public IActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public IActionResult Create(Prediction prediction)
    {
        if (ModelState.IsValid)
        {
            _predictionRepository.Add(prediction);
            return RedirectToAction(nameof(Index));
        }
        return View(prediction);
    }
    public IActionResult Edit(int id)
    {
        var prediction = _predictionRepository.GetById(id);
        return View(prediction);
    }
    [HttpPost]
    public IActionResult Edit(Prediction prediction)
    {
        if (ModelState.IsValid)
        {
            _predictionRepository.Update(prediction);
            return RedirectToAction(nameof(Index));
        }
        return View(prediction);
    }
    public IActionResult Delete(int id)
    {
        var prediction = _predictionRepository.GetById(id);
        return View(prediction);
    }
    [HttpPost, ActionName("Delete")]
    public IActionResult DeleteConfirmed(int id)
    {
        _predictionRepository.Delete(id);
        return RedirectToAction(nameof(Index));
    }
}

5. TradingStrategyController

using Microsoft.AspNetCore.Mvc;
public class TradingStrategyController : Controller
{
    private readonly TradingStrategyRepository _tradingStrategyRepository;
    public TradingStrategyController(TradingStrategyRepository tradingStrategyRepository)
    {
        _tradingStrategyRepository = tradingStrategyRepository;
    }
    public IActionResult Index()
    {
        var strategies = _tradingStrategyRepository.GetAll();
        return View(strategies);
    }
    public IActionResult Details(int id)
    {
        var strategy = _tradingStrategyRepository.GetById(id);
        return View(strategy);
    }
    public IActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public IActionResult Create(TradingStrategy strategy)
    {
        if (ModelState.IsValid)
        {
            _tradingStrategyRepository.Add(strategy);
            return RedirectToAction(nameof(Index));
        }
        return View(strategy);
    }
    public IActionResult Edit(int id)
    {
        var strategy = _tradingStrategyRepository.GetById(id);
        return View(strategy);
    }
    [HttpPost]
    public IActionResult Edit(TradingStrategy strategy)
    {
        if (ModelState.IsValid)
        {
            _tradingStrategyRepository.Update(strategy);
            return RedirectToAction(nameof(Index));
        }
        return View(strategy);
    }
    public IActionResult Delete(int id)
    {
        var strategy = _tradingStrategyRepository.GetById(id);
        return View(strategy);
    }
    [HttpPost, ActionName("Delete")]
    public IActionResult DeleteConfirmed(int id)
    {
        _tradingStrategyRepository.Delete(id);
        return RedirectToAction(nameof(Index));
    }
}

6. PortfolioController

using Microsoft.AspNetCore.Mvc;
public class PortfolioController : Controller
{
    private readonly PortfolioRepository _portfolioRepository;
    public PortfolioController(PortfolioRepository portfolioRepository)
    {
        _portfolioRepository = portfolioRepository;
    }
    public IActionResult Index()
    {
        var portfolios = _portfolioRepository.GetAll();
        return View(portfolios);
    }
    public IActionResult Details(int id)
    {
        var portfolio = _portfolioRepository.GetById(id);
        return View(portfolio);
    }
    public IActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public IActionResult Create(Portfolio portfolio)
    {
        if (ModelState.IsValid)
        {
            _portfolioRepository.Add(portfolio);
            return RedirectToAction(nameof(Index));
        }
        return View(portfolio);
    }
    public IActionResult Edit(int id)
    {
        var portfolio = _portfolioRepository.GetById(id);
        return View(portfolio);
    }
    [HttpPost]
    public IAction Result Edit(Portfolio portfolio)
    {
        if (ModelState.IsValid)
        {
            _portfolioRepository.Update(portfolio);
            return RedirectToAction(nameof(Index));
        }
        return View(portfolio);
    }
    public IActionResult Delete(int id)
    {
        var portfolio = _portfolioRepository.GetById(id);
        return View(portfolio);
    }
    [HttpPost, ActionName("Delete")]
    public IActionResult DeleteConfirmed(int id)
    {
        _portfolioRepository.Delete(id);
        return RedirectToAction(nameof(Index));
    }
}

7. PortfolioStockController

using Microsoft.AspNetCore.Mvc;
public class PortfolioStockController : Controller
{
    private readonly PortfolioStockRepository _portfolioStockRepository;
    public PortfolioStockController(PortfolioStockRepository portfolioStockRepository)
    {
        _portfolioStockRepository = portfolioStockRepository;
    }
    public IActionResult Index()
    {
        var portfolioStocks = _portfolioStockRepository.GetAll();
        return View(portfolioStocks);
    }
    public IActionResult Details(int id)
    {
        var portfolioStock = _portfolioStockRepository.GetById(id);
        return View(portfolioStock);
    }
    public IActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public IActionResult Create(PortfolioStock portfolioStock)
    {
        if (ModelState.IsValid)
        {
            _portfolioStockRepository.Add(portfolioStock);
            return RedirectToAction(nameof(Index));
        }
        return View(portfolioStock);
    }
    public IActionResult Edit(int id)
    {
        var portfolioStock = _portfolioStockRepository.GetById(id);
        return View(portfolioStock);
    }
    [HttpPost]
    public IActionResult Edit(PortfolioStock portfolioStock)
    {
        if (ModelState.IsValid)
        {
            _portfolioStockRepository.Update(portfolioStock);
            return RedirectToAction(nameof(Index));
        }
        return View(portfolioStock);
    }
    public IActionResult Delete(int id)
    {
        var portfolioStock = _portfolioStockRepository.GetById(id);
        return View(portfolioStock);
    }
    [HttpPost, ActionName("Delete")]
    public IActionResult DeleteConfirmed(int id)
    {
        _portfolioStockRepository.Delete(id);
        return RedirectToAction(nameof(Index));
    }
}

8. PerformanceReportController

using Microsoft.AspNetCore.Mvc;
public class PerformanceReportController : Controller
{
    private readonly PerformanceReportRepository _performanceReportRepository;
    public PerformanceReportController(PerformanceReportRepository performanceReportRepository)
    {
        _performanceReportRepository = performanceReportRepository;
    }
    public IActionResult Index()
    {
        var reports = _performanceReportRepository.GetAll();
        return View(reports);
    }
    public IActionResult Details(int id)
    {
        var report = _performanceReportRepository.GetById(id);
        return View(report);
    }
    public IActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public IActionResult Create(PerformanceReport report)
    {
        if (ModelState.IsValid)
        {
            _performanceReportRepository.Add(report);
            return RedirectToAction(nameof(Index));
        }
        return View(report);
    }
    public IActionResult Edit(int id)
    {
        var report = _performanceReportRepository.GetById(id);
        return View(report);
    }
    [HttpPost]
    public IActionResult Edit(PerformanceReport report)
    {
        if (ModelState.IsValid)
        {
            _performanceReportRepository.Update(report);
            return RedirectToAction(nameof(Index));
        }
        return View(report);
    }
    public IActionResult Delete(int id)
    {
        var report = _performanceReportRepository.GetById(id);
        return View(report);
    }
    [HttpPost, ActionName("Delete")]
    public IActionResult DeleteConfirmed(int id)
    {
        _performanceReportRepository.Delete(id);
        return RedirectToAction(nameof(Index));
    }
}

9. AlertController

using Microsoft.AspNetCore.Mvc;
public class AlertController : Controller
{
    private readonly AlertRepository _alertRepository;
    public AlertController(AlertRepository alertRepository)
    {
        _alertRepository = alertRepository;
    }
    public IActionResult Index()
    {
        var alerts = _alertRepository.GetAll();
        return View(alerts);
    }
    public IActionResult Details(int id)
    {
        var alert = _alertRepository.GetById(id);
        return View(alert);
    }
    public IActionResult Create()
    {
        return View();
    }
    [HttpPost]
    public IActionResult Create(Alert alert)
    {
        if (ModelState.IsValid)
        {
            _alertRepository.Add(alert);
            return RedirectToAction(nameof(Index));
        }
        return View(alert);
    }
    public IActionResult Edit(int id)
    {
        var alert = _alertRepository.GetById(id);
        return View(alert);
    }
    [HttpPost]
    public IActionResult Edit(Alert alert)
    {
        if (ModelState.IsValid)
        {
            _alertRepository.Update(alert);
            return RedirectToAction(nameof(Index));
        }
        return View(alert);
    }
    public IActionResult Delete(int id)
    {
        var alert = _alertRepository.GetById(id);
        return View(alert);
    }
    [HttpPost, ActionName("Delete")]
    public IActionResult DeleteConfirmed(int id)
    {
        _alertRepository.Delete(id);
        return RedirectToAction(nameof(Index));
    }
}

With these controllers

You now have a complete set of MVC controllers for each repository. Each controller provides the necessary actions to handle CRUD operations, allowing users to interact with the data through views. This structure adheres to the MVC pattern, promoting separation of concerns and making the application easier to maintain and extend.

To create the view files for each of the controllers in an ASP.NET MVC application

We will create Razor view files that correspond to the actions in the controllers. Each view will provide a user interface for managing the respective entities, allowing users to create, read, update, and delete records.

Below are the view files for each controller

User, StockData, EconomicIndicator, Prediction, TradingStrategy, Portfolio, PortfolioStock, PerformanceReport, and Alert.

1. User Views

Views/User/Index.cshtml

@model IEnumerable<User>
<h2>Users</h2>
<a asp-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>
                    <a asp-action="Edit" asp-route-id="@user.UserId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@user.UserId">Delete</a> |
                    <a asp-action="Details" asp-route-id="@user.UserId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/User/Create.cshtml

@model User
<h2>Create User</h2>
<form asp-action="Create">
    <div>
        <label asp-for="Username"></label>
        <input asp-for="Username" />
    </div>
    <div>
        <label asp-for="PasswordHash"></label>
        <input asp-for="PasswordHash" type="password" />
    </div>
    <div>
        <label asp-for="Email"></label>
        <input asp-for="Email" />
    </div>
    <button type="submit">Create</button>
</form>

Views/User/Edit.cshtml

@model User
<h2>Edit User</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="User Id" />
    <div>
        <label asp-for="Username"></label>
        <input asp-for="Username" />
    </div>
    <div>
        <label asp-for="PasswordHash"></label>
        <input asp-for="PasswordHash" type="password" />
    </div>
    <div>
        <label asp-for="Email"></label>
        <input asp-for="Email" />
    </div>
    <button type="submit">Save</button>
</form>

Views/User/Delete.cshtml

@model User
<h2>Delete User</h2>
<h3>Are you sure you want to delete this user?</h3>
<div>
    <h4>@Model.Username</h4>
    <p>Email: @Model.Email</p>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="User Id" />
    <button type="submit">Delete</button>
    <a asp-action="Index">Cancel</a>
</form>

Views/User/Details.cshtml

@model User
<h2>User Details</h2>
<div>
    <h4>@Model.Username</h4>
    <p>Email: @Model.Email</p>
    <p>Created At: @Model.CreatedAt</p>
</div>
<a asp-action="Edit" asp-route-id="@Model.UserId">Edit</a> |
<a asp-action="Index">Back to List</a>
2. StockData Views

Views/StockData/Index.cshtml

@model IEnumerable<StockData>
<h2>Stock Data</h2>
<a asp-action="Create">Add New Stock Data</a>
<table>
    <thead>
        <tr>
            <th>Stock Symbol</th>
            <th>Date</th>
            <th>Open Price</th>
            <th>Close Price</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var stock in Model)
        {
            <tr>
                <td>@stock.StockSymbol</td>
                <td>@stock.Date.ToShortDateString()</td>
                <td>@stock.OpenPrice</td>
                <td>@stock.ClosePrice</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@stock.StockDataId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@stock.StockDataId">Delete</a> |
                    <a asp-action="Details" asp-route -id="@stock.StockDataId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/StockData/Create.cshtml

@model StockData
<h2>Create Stock Data</h2>
<form asp-action="Create">
    <div>
        <label asp-for="StockSymbol"></label>
        <input asp-for="StockSymbol" />
    </div>
    <div>
        <label asp-for="Date"></label>
        <input asp-for="Date" type="date" />
    </div>
    <div>
        <label asp-for="OpenPrice"></label>
        <input asp-for="OpenPrice" />
    </div>
    <div>
        <label asp-for="ClosePrice"></label>
        <input asp-for="ClosePrice" />
    </div>
    <button type="submit">Create</button>
</form>

Views/StockData/Edit.cshtml

@model StockData
<h2>Edit Stock Data</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="StockDataId" />
    <div>
        <label asp-for="StockSymbol"></label>
        <input asp-for="StockSymbol" />
    </div>
    <div>
        <label asp-for="Date"></label>
        <input asp-for="Date" type="date" />
    </div>
    <div>
        <label asp-for="OpenPrice"></label>
        <input asp-for="OpenPrice" />
    </div>
    <div>
        <label asp-for="ClosePrice"></label>
        <input asp-for="ClosePrice" />
    </div>
    <button type="submit">Save</button>
</form>

Views/StockData/Delete.cshtml

@model StockData
<h2>Delete Stock Data</h2>
<h3>Are you sure you want to delete this stock data?</h3>
<div>
    <h4>Stock Symbol: @Model.StockSymbol</h4>
    <p>Date: @Model.Date.ToShortDateString()</p>
    <p>Open Price: @Model.OpenPrice</p>
    <p>Close Price: @Model.ClosePrice</p>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="StockDataId" />
    <button type="submit">Delete</button>
    <a asp-action="Index">Cancel</a>
</form>

Views/StockData/Details.cshtml

@model StockData
<h2>Stock Data Details</h2>
<div>
    <h4>Stock Symbol: @Model.StockSymbol</h4>
    <p>Date: @Model.Date.ToShortDateString()</p>
    <p>Open Price: @Model.OpenPrice</p>
    <p>Close Price: @Model.ClosePrice</p>
</div>
<a asp-action="Edit" asp-route-id="@Model.StockDataId">Edit</a> |
<a asp-action="Index">Back to List</a>
3. EconomicIndicator Views

Views/EconomicIndicator/Index.cshtml

@model IEnumerable<EconomicIndicator>
<h2>Economic Indicators</h2>
<a asp-action="Create">Add New Indicator</a>
<table>
    <thead>
        <tr>
            <th>Name</th>
            <th>Value</th>
            <th>Date</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var indicator in Model)
        {
            <tr>
                <td>@indicator.Name</td>
                <td>@indicator.Value</td>
                <td>@indicator.Date.ToShortDateString()</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@indicator.EconomicIndicatorId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@indicator.EconomicIndicatorId">Delete</a> |
                    <a asp-action="Details" asp-route-id="@indicator.EconomicIndicatorId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/EconomicIndicator/Create.cshtml

@model EconomicIndicator
<h2>Create Economic Indicator</h2>
<form asp-action="Create">
    <div>
        <label asp-for="Name"></label>
        <input asp-for="Name" />
    </div>
    <div>
        <label asp-for="Value"></label>
        <input asp-for="Value" />
    </div>
    <div>
        <label asp-for="Date"></label>
        <input asp-for="Date" type="date" />
    </div>
    <button type="submit">Create </button>
</form>

Views/EconomicIndicator/Edit.cshtml

@model EconomicIndicator
<h2>Edit Economic Indicator</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="EconomicIndicatorId" />
    <div>
        <label asp-for="Name"></label>
        <input asp-for="Name" />
    </div>
    <div>
        <label asp-for="Value"></label>
        <input asp-for="Value" />
    </div>
    <div>
        <label asp-for="Date"></label>
        <input asp-for="Date" type="date" />
    </div>
    <button type="submit">Save</button>
</form>

Views/EconomicIndicator/Delete.cshtml

@model EconomicIndicator
<h2>Delete Economic Indicator</h2>
<h3>Are you sure you want to delete this indicator?</h3>
<div>
    <h4>@Model.Name</h4>
    <p>Value: @Model.Value</p>
    <p>Date: @Model.Date.ToShortDateString()</p>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="EconomicIndicatorId" />
    <button type="submit">Delete</button>
    <a asp-action="Index">Cancel</a>
</form>

Views/EconomicIndicator/Details.cshtml

@model EconomicIndicator
<h2>Economic Indicator Details</h2>
<div>
    <h4>@Model.Name</h4>
    <p>Value: @Model.Value</p>
    <p>Date: @Model.Date.ToShortDateString()</p>
</div>
<a asp-action="Edit" asp-route-id="@Model.EconomicIndicatorId">Edit</a> |
<a asp-action="Index">Back to List</a>
4. Prediction Views

Views/Prediction/Index.cshtml

@model IEnumerable<Prediction>
<h2>Predictions</h2>
<a asp-action="Create">Add New Prediction</a>
<table>
    <thead>
        <tr>
            <th>Prediction Name</th>
            <th>Value</th>
            <th>Date</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var prediction in Model)
        {
            <tr>
                <td>@prediction.Name</td>
                <td>@prediction.Value</td>
                <td>@prediction.Date.ToShortDateString()</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@prediction.PredictionId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@prediction.PredictionId">Delete</a> |
                    <a asp-action="Details" asp-route-id="@prediction.PredictionId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Prediction/Create.cshtml

@model Prediction
<h2>Create Prediction</h2>
<form asp-action="Create">
    <div>
        <label asp-for="Name"></label>
        <input asp-for="Name" />
    </div>
    <div>
        <label asp-for="Value"></label>
        <input asp-for="Value" />
    </div>
    <div>
        <label asp-for="Date"></label>
        <input asp-for="Date" type="date" />
    </div>
    <button type="submit">Create</button>
</form>

Views/Prediction/Edit.cshtml

@model Prediction
<h2>Edit Prediction</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="PredictionId" />
    <div>
        <label asp-for="Name"></label>
        <input asp-for="Name" />
    </div>
    <div>
        <label asp-for="Value"></label>
        <input asp-for="Value" />
    </div>
    <div>
        <label asp-for="Date"></label>
        <input asp-for="Date" type="date" />
    </div>
    <button type="submit">Save</button>
</form>

Views/Prediction/Delete.cshtml

@model Prediction
<h2>Delete Prediction</h2>
<h3>Are you sure you want to delete this prediction?</h3>
<div>
    <h4>@Model.Name</h4>
    <p>Value: @Model.Value</p>
    <p>Date: @Model.Date.ToShortDateString()</p>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="PredictionId" />
    <button type="submit">Delete</button>
 <a asp-action="Index">Cancel</a>
</form>

Views/Prediction/Details.cshtml

@model Prediction
<h2>Prediction Details</h2>
<div>
    <h4>@Model.Name</h4>
    <p>Value: @Model.Value</p>
    <p>Date: @Model.Date.ToShortDateString()</p>
</div>
<a asp-action="Edit" asp-route-id="@Model.PredictionId">Edit</a> |
<a asp-action="Index">Back to List</a>
5. TradingStrategy Views

Views/TradingStrategy/Index.cshtml

@model IEnumerable<TradingStrategy>
<h2>Trading Strategies</h2>
<a asp-action="Create">Add New Strategy</a>
<table>
    <thead>
        <tr>
            <th>Name</th>
            <th>Description</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var strategy in Model)
        {
            <tr>
                <td>@strategy.Name</td>
                <td>@strategy.Description</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@strategy.TradingStrategyId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@strategy.TradingStrategyId">Delete</a> |
                    <a asp-action="Details" asp-route-id="@strategy.TradingStrategyId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/TradingStrategy/Create.cshtml

@model TradingStrategy
<h2>Create Trading Strategy</h2>
<form asp-action="Create">
    <div>
        <label asp-for="Name"></label>
        <input asp-for="Name" />
    </div>
    <div>
        <label asp-for="Description"></label>
        <textarea asp-for="Description"></textarea>
    </div>
    <button type="submit">Create</button>
</form>

Views/TradingStrategy/Edit.cshtml

@model TradingStrategy
<h2>Edit Trading Strategy</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="TradingStrategyId" />
    <div>
        <label asp-for="Name"></label>
        <input asp-for="Name" />
    </div>
    <div>
        <label asp-for="Description"></label>
        <textarea asp-for="Description"></textarea>
    </div>
    <button type="submit">Save</button>
</form>

Views/TradingStrategy/Delete.cshtml

@model TradingStrategy
<h2>Delete Trading Strategy</h2>
<h3>Are you sure you want to delete this strategy?</h3>
<div>
    <h4>@Model.Name</h4>
    <p>Description: @Model.Description</p>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="TradingStrategyId" />
    <button type="submit">Delete</button>
    <a asp-action="Index">Cancel</a>
</form>

Views/TradingStrategy/Details.cshtml

@model TradingStrategy
<h2>Trading Strategy Details</h2>
<div>
    <h4>@Model.Name</h4>
    <p>Description: @Model.Description</p>
</div>
<a asp-action="Edit" asp-route-id="@Model.TradingStrategyId">Edit</a> |
<a asp-action="Index">Back to List</a>
6. Portfolio Views

Views/Portfolio/Index.cshtml

@model IEnumerable<Portfolio>
<h2>Portfolios</h2>
<a asp-action="Create">Add New Portfolio</a>
<table>
    <thead>
        <tr>
            <th>Name</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var portfolio in Model)
        {
            <tr>
                <td>@portfolio.Name</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@portfolio.PortfolioId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@portfolio.PortfolioId">Delete</a> |
                    <a asp-action="Details" asp-route-id="@portfolio.PortfolioId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Portfolio/Create.cshtml

@model Portfolio
<h2>Create Portfolio</h2>
<form asp-action="Create">
    <div>
        <label asp-for="Name"></label>
        <input asp-for="Name" />
    </div>
    <button type=" submit">Create</button>
</form>

Views/Portfolio/Edit.cshtml

@model Portfolio
<h2>Edit Portfolio</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="PortfolioId" />
    <div>
        <label asp-for="Name"></label>
        <input asp-for="Name" />
    </div>
    <button type="submit">Save</button>
</form>

Views/Portfolio/Delete.cshtml

@model Portfolio
<h2>Delete Portfolio</h2>
<h3>Are you sure you want to delete this portfolio?</h3>
<div>
    <h4>@Model.Name</h4>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="PortfolioId" />
    <button type="submit">Delete</button>
    <a asp-action="Index">Cancel</a>
</form>

Views/Portfolio/Details.cshtml

@model Portfolio
<h2>Portfolio Details</h2>
<div>
    <h4>@Model.Name</h4>
</div>
<a asp-action="Edit" asp-route-id="@Model.PortfolioId">Edit</a> |
<a asp-action="Index">Back to List</a>
7. PortfolioStock Views

Views/PortfolioStock/Index.cshtml

@model IEnumerable<PortfolioStock>
<h2>Portfolio Stocks</h2>
<a asp-action="Create">Add New Portfolio Stock</a>
<table>
    <thead>
        <tr>
            <th>Portfolio Name</th>
            <th>Stock Symbol</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var portfolioStock in Model)
        {
            <tr>
                <td>@portfolioStock.Portfolio.Name</td>
                <td>@portfolioStock.StockSymbol</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@portfolioStock.PortfolioStockId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@portfolioStock.PortfolioStockId">Delete</a> |
                    <a asp-action="Details" asp-route-id="@portfolioStock.PortfolioStockId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/PortfolioStock/Create.cshtml

@model PortfolioStock
<h2>Create Portfolio Stock</h2>
<form asp-action="Create">
    <div>
        <label asp-for="PortfolioId"></label>
        <select asp-for="PortfolioId" asp-items="ViewBag.PortfolioList"></select>
    </div>
    <div>
        <label asp-for="StockSymbol"></label>
        <input asp-for="StockSymbol" />
    </div>
    <button type="submit">Create</button>
</form>

Views/PortfolioStock/Edit.cshtml

@model PortfolioStock
<h2>Edit Portfolio Stock</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="PortfolioStockId" />
    <div>
        <label asp-for="PortfolioId"></label>
        <select asp-for="PortfolioId" asp-items="ViewBag.PortfolioList"></select>
    </div>
    <div>
        <label asp-for="StockSymbol"></label>
        <input asp-for="StockSymbol" />
    </div>
    <button type="submit">Save</button>
</form>

Views/PortfolioStock/Delete.cshtml

@model PortfolioStock
<h2>Delete Portfolio Stock</h2>
<h3>Are you sure you want to delete this portfolio stock?</h3>
<div>
    <h4>Portfolio: @Model.Portfolio.Name</h4>
    <p>Stock Symbol: @Model.StockSymbol</p>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="PortfolioStockId" />
    <button type="submit">Delete</button>
    <a asp-action="Index">Cancel</a>
</form>

Views/PortfolioStock/Details.cshtml

@model PortfolioStock
<h2>Portfolio Stock Details</h2>
<div>
    <h4>Portfolio: @Model.Portfolio.Name</h4>
    <p>Stock Symbol: @Model.StockSymbol</p>
</div>
<a asp-action="Edit" asp-route-id="@Model.PortfolioStockId">Edit</a> |
<a asp-action="Index">Back to List</a>
8. PerformanceReport Views

Views/PerformanceReport/Index.cshtml

@model IEnumerable<PerformanceReport>
<h2>Performance Reports</h2>
<a asp-action="Create ">Add New Report</a>
<table>
    <thead>
        <tr>
            <th>Report Name</th>
            <th>Date</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var report in Model)
        {
            <tr>
                <td>@report.Name</td>
                <td>@report.Date.ToShortDateString()</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@report.PerformanceReportId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@report.PerformanceReportId">Delete</a> |
                    <a asp-action="Details" asp-route-id="@report.PerformanceReportId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/PerformanceReport/Create.cshtml

@model PerformanceReport
<h2>Create Performance Report</h2>
<form asp-action="Create">
    <div>
        <label asp-for="Name"></label>
        <input asp-for="Name" />
    </div>
    <div>
        <label asp-for="Date"></label>
        <input asp-for="Date" type="date" />
    </div>
    <button type="submit">Create</button>
</form>

Views/PerformanceReport/Edit.cshtml

@model PerformanceReport
<h2>Edit Performance Report</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="PerformanceReportId" />
    <div>
        <label asp-for="Name"></label>
        <input asp-for="Name" />
    </div>
    <div>
        <label asp-for="Date"></label>
        <input asp-for="Date" type="date" />
    </div>
    <button type="submit">Save</button>
</form>

Views/PerformanceReport/Delete.cshtml

@model PerformanceReport
<h2>Delete Performance Report</h2>
<h3>Are you sure you want to delete this report?</h3>
<div>
    <h4>@Model.Name</h4>
    <p>Date: @Model.Date.ToShortDateString()</p>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="PerformanceReportId" />
    <button type="submit">Delete</button>
    <a asp-action="Index">Cancel</a>
</form>

Views/PerformanceReport/Details.cshtml

@model PerformanceReport
<h2>Performance Report Details</h2>
<div>
    <h4>@Model.Name</h4>
    <p>Date: @Model.Date.ToShortDateString()</p>
</div>
<a asp-action="Edit" asp-route-id="@Model.PerformanceReportId">Edit</a> |
<a asp-action="Index">Back to List</a>
9. Alert Views

Views/Alert/Index.cshtml

@model IEnumerable<Alert>
<h2>Alerts</h2>
<a asp-action="Create">Add New Alert</a>
<table>
    <thead>
        <tr>
            <th>Alert Name</th>
            <th>Condition</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var alert in Model)
        {
            <tr>
                <td>@alert.Name</td>
                <td>@alert.Condition</td>
                <td>
                    <a asp-action="Edit" asp-route-id="@alert.AlertId">Edit</a> |
                    <a asp-action="Delete" asp-route-id="@alert.AlertId">Delete</a> |
                    <a asp-action="Details" asp-route-id="@alert.AlertId">Details</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Alert/Create.cshtml

@model Alert
<h2>Create Alert</h2>
<form asp-action="Create">
    <div>
        <label asp-for="Name"></label>
        <input asp-for="Name" />
    </div>
    <div>
        <label asp-for="Condition"></label>
        <input asp-for="Condition" />
    </div>
    <button type="submit">Create</button>
</form>

Views/Alert/Edit.cshtml

@model Alert
<h2>Edit Alert</h2>
<form asp-action="Edit">
    <input type="hidden" asp-for="AlertId" />
    <div>
        <label asp-for="Name"></label>
        <input asp-for="Name" />
    </div>
    <div>
        <label asp-for="Condition"></label>
        <input asp-for ="Condition" />
    </div>
    <button type="submit">Save</button>
</form>

Views/Alert/Delete.cshtml

@model Alert
<h2>Delete Alert</h2>
<h3>Are you sure you want to delete this alert?</h3>
<div>
    <h4>@Model.Name</h4>
    <p>Condition: @Model.Condition</p>
</div>
<form asp-action="DeleteConfirmed">
    <input type="hidden" asp-for="AlertId" />
    <button type="submit">Delete</button>
    <a asp-action="Index">Cancel</a>
</form>

Views/Alert/Details.cshtml

@model Alert
<h2>Alert Details</h2>
<div>
    <h4>@Model.Name</h4>
    <p>Condition: @Model.Condition</p>
</div>
<a asp-action="Edit" asp-route-id="@Model.AlertId">Edit</a> |
<a asp-action="Index">Back to List</a>

With these view files

You now have a complete set of Razor views for each controller. Each view provides a user interface for managing the respective entities, allowing users to create, read, update, and delete records. This structure follows the MVC pattern, ensuring a clear separation between the application's logic and presentation layers.

To create a dashboard page that displays consolidated data related to your project

We will follow these steps:

Create a Dashboard ViewModel

This will hold the consolidated data.

Models/DashboardViewModel.cs
public class DashboardViewModel
{
    public int TotalUsers { get; set; }
    public int TotalStockData { get; set; }
    public int TotalEconomicIndicators { get; set; }
    public int TotalPredictions { get; set; }
    public int TotalTradingStrategies { get; set; }
    public int TotalPortfolios { get; set; }
    public int TotalPortfolioStocks { get; set; }
    public int TotalPerformanceReports { get; set; }
    public int TotalAlerts { get; set; }
}

Create a Dashboard Controller

Create a new controller named DashboardController that will handle the logic for fetching the consolidated data.

Controllers/DashboardController.cs

using Microsoft.AspNetCore.Mvc;
public class DashboardController : Controller
{
    private readonly UserRepository _userRepository;
    private readonly StockDataRepository _stockDataRepository;
    private readonly EconomicIndicatorRepository _economicIndicatorRepository;
    private readonly PredictionRepository _predictionRepository;
    private readonly TradingStrategyRepository _tradingStrategyRepository;
    private readonly PortfolioRepository _portfolioRepository;
    private readonly PortfolioStockRepository _portfolioStockRepository;
    private readonly PerformanceReportRepository _performanceReportRepository;
    private readonly AlertRepository _alertRepository;
    public DashboardController(
        UserRepository userRepository,
        StockDataRepository stockDataRepository,
        EconomicIndicatorRepository economicIndicatorRepository,
        PredictionRepository predictionRepository,
        TradingStrategyRepository tradingStrategyRepository,
        PortfolioRepository portfolioRepository,
        PortfolioStockRepository portfolioStockRepository,
        PerformanceReportRepository performanceReportRepository,
        AlertRepository alertRepository)
    {
        _userRepository = userRepository;
        _stockDataRepository = stockDataRepository;
        _economicIndicatorRepository = economicIndicatorRepository;
        _predictionRepository = predictionRepository;
        _tradingStrategyRepository = tradingStrategyRepository;
        _portfolioRepository = portfolioRepository;
        _portfolioStockRepository = portfolioStockRepository;
        _performanceReportRepository = performanceReportRepository;
        _alertRepository = alertRepository;
    }
    public IActionResult Index()
    {
        var model = new DashboardViewModel
        {
            TotalUsers = _userRepository.GetAll().Count(),
            TotalStockData = _stockDataRepository.GetAll().Count(),
            TotalEconomicIndicators = _economicIndicatorRepository.GetAll().Count(),
            TotalPredictions = _predictionRepository.GetAll().Count(),
            TotalTradingStrategies = _tradingStrategyRepository.GetAll().Count(),
            TotalPortfolios = _portfolioRepository.GetAll().Count(),
            TotalPortfolioStocks = _portfolioStockRepository.GetAll().Count(),
            TotalPerformanceReports = _performanceReportRepository.GetAll().Count(),
            TotalAlerts = _alertRepository.GetAll().Count()
        };
        return View(model);
    }
}

Create the Dashboard View

Create a new view named Index.cshtml under the Views/Dashboard folder to display the consolidated data.

Views/Dashboard/Index.cshtml

@model DashboardViewModel
<h2>Dashboard</h2>
<div class="dashboard">
    <div class="card">
        <h3>Total Users</h3>
        <p>@Model.TotalUsers</p>
    </div>
    <div class="card">
        <h3>Total Stock Data</h3>
        <p>@Model.TotalStockData</p>
    </div>
    <div class="card">
        <h3>Total Economic Indicators</h3>
        <p>@Model.TotalEconomicIndicators</p>
    </div>
    <div class="card">
        <h3>Total Predictions</h3>
        <p>@Model.TotalPredictions</p>
    </div>
    <div class="card">
        <h3>Total Trading Strategies</h3>
        <p>@Model.TotalTradingStrategies</p>
    </div>
    <div class="card">
        <h3>Total Portfolios</h3>
        <p>@Model.TotalPortfolios</p>
    </div>
    <div class="card">
        <h3>Total Portfolio Stocks</h3>
        <p>@Model.TotalPortfolioStocks</p>
    </div>
    <div class="card">
        <h3>Total Performance Reports</h3>
        <p>@Model.TotalPerformanceReports</p>
    </div>
    <div class="card">
        <h3>Total Alerts</h3>
        <p>@Model.TotalAlerts</p>
    </div>
</div>
<style>
    .dashboard {
        display: flex;
        flex-wrap: wrap;
        gap: 20px;
    }
    .card {
        border: 1px solid #ccc;
        padding: 20px;
        border-radius: 5px;
        width: 200px;
        text-align: center;
    }
</style>