Project Introduction

The Hotel Management System is designed to streamline the operations of hotels by providing a comprehensive platform for managing reservations, guest information, room availability, and billing. Built using ASP.NET and SQL Server, this application aims to enhance the efficiency of hotel administration and improve the overall guest experience. The system will facilitate various aspects of hotel management, including user roles, room bookings, invoicing, housekeeping tasks, and guest feedback, ensuring a seamless experience for both hotel staff and guests.

Project Objectives

• To create a secure user authentication system for managing user accounts and roles within the hotel.
• To enable efficient management of guest reservations, including check-in and check-out processes.
• To manage room details, including availability, pricing, and status.
• To facilitate invoicing and payment processing for guest stays and services.
• To track housekeeping tasks and ensure rooms are maintained to a high standard.
• To collect and manage guest feedback to improve service quality.
• To provide a menu management system for food and beverage services.
• To handle event bookings and manage promotions for guests.
• To generate reports on reservations, occupancy rates, and financial performance.

Project Modules

1. User Management Module: Handles user registration, login, and role management.
2. Reservation Management Module: Manages guest reservations, including booking and cancellation.
3. Room Management Module: Facilitates the management of room details, availability, and pricing.
4. Invoice Management Module: Handles invoicing and payment processing for guests.
5. Housekeeping Management Module: Tracks housekeeping tasks and room maintenance status.
6. Guest Management Module: Manages guest information and preferences.
7. Feedback Management Module: Collects and analyzes guest feedback and ratings.
8. Menu Management Module: Manages food and beverage menu items and pricing.
9. Event Management Module: Facilitates event bookings and management.
10. Promotion Management Module: Manages promotional codes and discounts for guests.
11. Reporting Module: Generates reports on reservations, occupancy, and financial metrics.

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,
    RoleId INT,
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (RoleId) REFERENCES Roles(RoleId)
);
-- Create Roles Table
CREATE TABLE Roles (
    RoleId INT PRIMARY KEY IDENTITY(1,1),
    RoleName NVARCHAR(50) NOT NULL UNIQUE
);
-- Create Reservations Table
CREATE TABLE Reservations (
    ReservationId INT PRIMARY KEY IDENTITY(1,1),
    GuestId INT,
    RoomId INT,
    CheckInDate DATETIME NOT NULL,
    CheckOutDate DATETIME NOT NULL,
    NumberOfGuests INT NOT NULL,
    Status NVARCHAR(50) NOT NULL, -- e.g., Confirmed, Cancelled
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (GuestId) REFERENCES Guests(GuestId),
    FOREIGN KEY (RoomId) REFERENCES Rooms(RoomId)
);
-- Create Rooms Table
CREATE TABLE Rooms (
    RoomId INT PRIMARY KEY IDENTITY(1,1),
    RoomNumber NVARCHAR(10) NOT NULL UNIQUE,
    RoomType NVARCHAR(50) NOT NULL, -- e.g., Single, Double, Suite
    Price DECIMAL(18, 2) NOT NULL,
    Status NVARCHAR(50) NOT NULL, -- e.g., Available, Occupied, Maintenance
    CreatedAt DATETIME DEFAULT GETDATE()
);
-- Create Invoices Table
CREATE TABLE Invoices (
    InvoiceId INT PRIMARY KEY IDENTITY(1,1),
    ReservationId INT,
    Amount DECIMAL(18, 2) NOT NULL,
    PaymentStatus NVARCHAR(50) NOT NULL, -- e.g., Paid, Unpaid
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (ReservationId) REFERENCES Reservations(ReservationId)
);
-- Create HousekeepingTasks Table
CREATE TABLE HousekeepingTasks (
    TaskId INT PRIMARY KEY IDENTITY(1,1),
    RoomId INT,
    TaskDescription NVARCHAR(256) NOT NULL,
    Status NVARCHAR(50) NOT NULL, -- e.g., Pending, Completed
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (RoomId) REFERENCES Rooms(RoomId)
);
-- Create Guests Table
CREATE TABLE Guests (
    GuestId INT PRIMARY KEY IDENTITY(1,1),
    FirstName NVARCHAR(50) NOT NULL,
    LastName NVARCHAR(50) NOT NULL,
    Email NVARCHAR(100) NOT NULL UNIQUE,
    Phone NVARCHAR(15),
    CreatedAt DATETIME DEFAULT GETDATE()
);
-- Create Feedback Table
CREATE TABLE Feedback (
    FeedbackId INT PRIMARY KEY IDENTITY(1,1),
    GuestId INT,
    Rating INT CHECK (Rating >= 1 AND Rating <= 5),
    Comments NVARCHAR(MAX),
    CreatedAt DATETIME DEFAULT GETDATE(),
    FOREIGN KEY (GuestId) REFERENCES Guests(GuestId)
);
-- Create MenuItems Table
CREATE TABLE MenuItems (
    MenuItemId INT PRIMARY KEY IDENTITY(1,1),
    Name NVARCHAR(100) NOT NULL,
    Description NVARCHAR(MAX),
    Price DECIMAL(18, 2) NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE()
);
-- Create EventBookings Table
CREATE TABLE EventBookings (
    EventBookingId INT PRIMARY KEY IDENTITY(1,1),
    EventName NVARCHAR(100) NOT NULL,
    BookingDate DATETIME NOT NULL,
    NumberOfGuests INT NOT NULL,
    CreatedAt DATETIME DEFAULT GETDATE()
);
-- Create Promotions Table
CREATE TABLE Promotions (
    PromotionId INT PRIMARY KEY IDENTITY(1,1),
    Code NVARCHAR(50) NOT NULL UNIQUE,
    DiscountAmount DECIMAL(18, 2) NOT NULL,
    ExpirationDate DATETIME NOT NULL,
    IsActive BIT DEFAULT 1
);

Explanation of the Tables

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

Roles: Defines user roles (e.g., Admin, Staff).

Reservations: Contains reservation details, including guest information, room details, check-in and check-out dates, and status.

Rooms: Stores room details, including room number, type, price, and status.

Invoices: Manages billing information related to reservations, including amount and payment status.

HousekeepingTasks: Tracks housekeeping tasks for rooms, including task description and status.

Guests: Contains guest information, including first name, last name, email, and phone number.

Feedback: Stores feedback from guests, including ratings and comments.

MenuItems: Manages menu items available in the hotel’s restaurant, including descriptions and prices.

EventBookings: Contains details about events booked at the hotel, including event name, booking date, and number of guests.

Promotions: Manages promotional codes, including discount amounts and expiration dates.

Creating Models and Repositories

To create models and repositories using ADO.NET for your ASP.NET application based on the provided SQL Server queries, we will follow these steps:

Create Models

Define C# classes that represent the database tables.

Here are the C# models corresponding to the SQL tables you provided:

//Models/User.cs
public class User
{
    public int UserId { get; set; }
    public string Username { get; set; }
    public string PasswordHash { get; set; }
    public string Email { get; set; }
    public int RoleId { get; set; }
    public DateTime CreatedAt { get; set; }
}
//Models/Role.cs
public class Role
{
    public int RoleId { get; set; }
    public string RoleName { get; set; }
}
//Models/Reservation.cs
public class Reservation
{
    public int ReservationId { get; set; }
    public int GuestId { get; set; }
    public int RoomId { get; set; }
    public DateTime CheckInDate { get; set; }
    public DateTime CheckOutDate { get; set; }
    public int NumberOfGuests { get; set; }
    public string Status { get; set; }
    public DateTime CreatedAt { get; set; }
}
//Models/Room.cs
public class Room
{
    public int RoomId { get; set; }
    public string RoomNumber { get; set; }
    public string RoomType { get; set; }
    public decimal Price { get; set; }
    public string Status { get; set; }
    public DateTime CreatedAt { get; set; }
}
//Models/Invoice.cs
public class Invoice
{
    public int InvoiceId { get; set; }
    public int ReservationId { get; set; }
    public decimal Amount { get; set; }
    public string PaymentStatus { get; set; }
    public DateTime CreatedAt { get; set; }
}
//Models/HousekeepingTask.cs
public class HousekeepingTask
{
    public int TaskId { get; set; }
    public int RoomId { get; set; }
    public string TaskDescription { get; set; }
    public string Status { get; set; }
    public DateTime CreatedAt { get; set; }
}
//Models/Guest.cs
public class Guest
{
    public int GuestId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Email { get; set; }
    public string Phone { get; set; }
    public DateTime CreatedAt { get; set; }
}
//Models/Feedback.cs
public class Feedback
{
    public int FeedbackId { get; set; }
    public int GuestId { get; set; }
    public int Rating { get; set; }
    public string Comments { get; set; }
    public DateTime CreatedAt { get; set; }
}
//Models/MenuItem.cs
public class MenuItem
{
    public int MenuItemId { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public decimal Price { get; set; }
    public DateTime CreatedAt { get; set; }
}
//Models/EventBooking.cs
public class EventBooking
{
    public int EventBookingId { get; set; }
    public string EventName { get; set; }
    public DateTime BookingDate { get; set; }
    public int NumberOfGuests { get; set; }
    public DateTime CreatedAt { get; set; }
}
//Models/Promotion.cs
public class Promotion
{
    public int PromotionId { get; set; }
    public string Code { get; set; }
    public decimal DiscountAmount { get; set; }
    public DateTime ExpirationDate { get; set; }
    public bool IsActive { get; set; }
}

Repository Implementation

Below is a complete implementation of the repository classes for all the models in your Online Ticket Booking System using ADO.NET. Each repository will include methods for adding, retrieving, updating, and deleting records from the database.

1. UserRepository.cs

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 void AddUser (User user)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Users (Username, PasswordHash, Email, RoleId) VALUES (@Username, @PasswordHash, @Email, @RoleId)", connection);
            command.Parameters.AddWithValue("@Username", user.Username);
            command.Parameters.AddWithValue("@PasswordHash", user.PasswordHash);
            command.Parameters.AddWithValue("@Email", user.Email);
            command.Parameters.AddWithValue("@RoleId", user.RoleId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public User GetUser ById(int userId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Users WHERE UserId = @User Id", connection);
            command.Parameters.AddWithValue("@User Id", userId);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    return new User
                    {
                        UserId = (int)reader["User Id"],
                        Username = reader["Username"].ToString(),
                        PasswordHash = reader["PasswordHash"].ToString(),
                        Email = reader["Email"].ToString(),
                        RoleId = (int)reader["RoleId"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return null;
    }
    public List<User> GetAllUsers()
    {
        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(),
                        RoleId = (int)reader["RoleId"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return users;
    }
    public void UpdateUser (User user)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Users SET Username = @Username, PasswordHash = @PasswordHash, Email = @Email, RoleId = @RoleId 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("@RoleId", user.RoleId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteUser (int userId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Users WHERE UserId = @User Id", connection);
            command.Parameters.AddWithValue("@User Id", userId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

2. RoleRepository.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
public class RoleRepository
{
    private readonly string _connectionString;
    public RoleRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public void AddRole(Role role)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Roles (RoleName) VALUES (@RoleName)", connection);
            command.Parameters.AddWithValue("@RoleName", role.RoleName);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public Role GetRoleById(int roleId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Roles WHERE RoleId = @RoleId", connection);
            command.Parameters.AddWithValue("@RoleId", roleId);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    return new Role
                    {
                        RoleId = (int)reader["RoleId"],
                        RoleName = reader["RoleName"].ToString()
                    };
                }
            }
        }
        return null;
    }
    public List<Role> GetAllRoles()
    {
        var roles = new List<Role>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Roles", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    roles.Add(new Role
                    {
                        RoleId = (int)reader["RoleId"],
                        RoleName = reader["RoleName"].ToString()
                    });
                }
            }
        }
        return roles;
    }
    public void UpdateRole(Role role)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var 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 (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Roles WHERE RoleId = @RoleId", connection);
            command.Parameters.AddWithValue("@RoleId", roleId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

3. ReservationRepository.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
public class ReservationRepository
{
    private readonly string _connectionString;
    public ReservationRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public void AddReservation(Reservation reservation)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Reservations (GuestId, RoomId, CheckInDate, CheckOutDate, NumberOfGuests, Status) VALUES (@GuestId, @RoomId, @CheckInDate, @CheckOutDate, @NumberOfGuests, @Status)", connection);
            command.Parameters.AddWithValue("@GuestId", reservation.GuestId);
            command.Parameters.AddWithValue("@RoomId", reservation.RoomId);
            command.Parameters.AddWithValue("@CheckInDate", reservation.CheckInDate);
            command.Parameters.AddWithValue("@CheckOutDate", reservation.CheckOutDate);
            command.Parameters.AddWithValue("@NumberOfGuests", reservation.NumberOfGuests);
            command.Parameters.AddWithValue("@Status", reservation.Status);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public Reservation GetReservationById(int reservationId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Reservations WHERE ReservationId = @ReservationId", connection);
            command.Parameters.AddWithValue("@ReservationId", reservationId);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    return new Reservation
                    {
                        ReservationId = (int)reader["ReservationId"],
                        GuestId = (int)reader["GuestId"],
                        RoomId = (int)reader["RoomId"],
                        CheckInDate = (DateTime)reader["CheckInDate"],
                        CheckOutDate = (DateTime)reader["CheckOutDate"],
                        NumberOfGuests = (int)reader["NumberOfGuests"],
                        Status = reader["Status"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return null;
    }
    public List<Reservation> GetAllReservations()
    {
        var reservations = new List<Reservation>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Reservations", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    reservations.Add(new Reservation
                    {
                        ReservationId = (int)reader["ReservationId"],
                        GuestId = (int)reader["GuestId"],
                        RoomId = (int)reader["RoomId"],
                        CheckInDate = (DateTime)reader["CheckInDate"],
                        CheckOutDate = (DateTime)reader["CheckOutDate"],
                        NumberOfGuests = (int)reader["NumberOfGuests"],
                        Status = reader["Status"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return reservations;
    }
    public void UpdateReservation(Reservation reservation)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Reservations SET GuestId = @GuestId, RoomId = @RoomId, CheckInDate = @CheckInDate, CheckOutDate = @CheckOutDate, NumberOfGuests = @NumberOfGuests, Status = @Status WHERE ReservationId = @ReservationId", connection);
            command.Parameters.AddWithValue("@ReservationId", reservation.ReservationId);
            command.Parameters.AddWithValue("@GuestId", reservation.GuestId);
            command.Parameters.AddWithValue("@RoomId", reservation.RoomId);
            command.Parameters.AddWithValue("@CheckInDate", reservation.CheckInDate);
            command.Parameters.AddWithValue("@CheckOutDate", reservation.CheckOutDate);
            command.Parameters.AddWithValue("@NumberOfGuests", reservation.NumberOfGuests);
            command.Parameters.AddWithValue("@Status", reservation.Status);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteReservation(int reservationId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Reservations WHERE ReservationId = @ReservationId", connection);
            command.Parameters.AddWithValue("@ReservationId", reservationId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

4. RoomRepository.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
public class RoomRepository
{
    private readonly string _connectionString;
    public RoomRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public void AddRoom(Room room)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Rooms (RoomNumber, RoomType, Price, Status) VALUES (@RoomNumber, @RoomType, @Price, @Status)", connection);
            command.Parameters.AddWithValue("@RoomNumber", room.RoomNumber);
            command.Parameters.AddWithValue("@RoomType", room.RoomType);
            command.Parameters.AddWithValue("@Price", room.Price);
            command.Parameters.AddWithValue("@Status", room.Status);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public Room GetRoomById(int roomId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Rooms WHERE RoomId = @RoomId", connection);
            command.Parameters.AddWithValue("@RoomId", roomId);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    return new Room
                    {
                        RoomId = (int)reader["RoomId"],
                        RoomNumber = reader["RoomNumber"].ToString(),
                        RoomType = reader["RoomType"].ToString(),
                        Price = (decimal)reader["Price"],
                        Status = reader["Status"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return null;
    }
    public List<Room> GetAllRooms()
    {
        var rooms = new List<Room>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Rooms", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    rooms.Add(new Room
                    {
                        RoomId = (int)reader["RoomId"],
                        RoomNumber = reader["RoomNumber"].ToString(),
                        RoomType = reader["RoomType"].ToString(),
                        Price = (decimal)reader["Price"],
                        Status = reader["Status"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return rooms;
    }
    public void UpdateRoom(Room room)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Rooms SET RoomNumber = @RoomNumber, RoomType = @RoomType, Price = @Price, Status = @Status WHERE RoomId = @RoomId", connection);
            command.Parameters.AddWithValue("@RoomId", room.RoomId);
            command.Parameters.AddWithValue("@RoomNumber", room.RoomNumber);
            command.Parameters.AddWithValue("@RoomType", room.RoomType);
            command.Parameters.AddWithValue("@Price", room.Price);
            command.Parameters.AddWithValue("@Status", room.Status);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteRoom(int roomId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Rooms WHERE RoomId = @RoomId", connection);
            command.Parameters.AddWithValue("@RoomId", roomId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

5. InvoiceRepository.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
public class InvoiceRepository
{
    private readonly string _connectionString;
    public InvoiceRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public void AddInvoice(Invoice invoice)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Invoices (ReservationId, Amount, PaymentStatus) VALUES (@ReservationId, @Amount, @PaymentStatus)", connection);
            command.Parameters.AddWithValue("@ReservationId", invoice.ReservationId);
            command.Parameters.AddWithValue("@Amount", invoice.Amount);
            command.Parameters.AddWithValue("@PaymentStatus", invoice.PaymentStatus);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public Invoice GetInvoiceById(int invoiceId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Invoices WHERE InvoiceId = @InvoiceId", connection);
            command.Parameters.AddWithValue("@InvoiceId", invoiceId);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    return new Invoice
                    {
                        InvoiceId = (int)reader["InvoiceId"],
                        ReservationId = (int)reader["ReservationId"],
                        Amount = (decimal)reader["Amount"],
                        PaymentStatus = reader["PaymentStatus"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return null;
    }
    public List<Invoice> GetAllInvoices()
    {
        var invoices = new List<Invoice>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Invoices", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    invoices.Add(new Invoice
                    {
                        InvoiceId = (int)reader["InvoiceId"],
                        ReservationId = (int)reader["ReservationId"],
                        Amount = (decimal)reader["Amount"],
                        PaymentStatus = reader["PaymentStatus"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return invoices;
    }
    public void UpdateInvoice(Invoice invoice)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Invoices SET ReservationId = @ReservationId, Amount = @Amount, PaymentStatus = @PaymentStatus WHERE InvoiceId = @InvoiceId", connection);
            command.Parameters.AddWithValue("@InvoiceId", invoice.InvoiceId);
            command.Parameters.AddWithValue("@ReservationId", invoice.ReservationId);
            command.Parameters.AddWithValue("@Amount", invoice.Amount);
            command.Parameters.AddWithValue("@PaymentStatus", invoice.PaymentStatus);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteInvoice(int invoiceId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Invoices WHERE InvoiceId = @InvoiceId", connection);
            command.Parameters.AddWithValue("@InvoiceId", invoiceId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

6. HousekeepingTaskRepository.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
public class HousekeepingTaskRepository
{
    private readonly string _connectionString;
    public HousekeepingTaskRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public void AddTask(HousekeepingTask task)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO HousekeepingTasks (RoomId, TaskDescription, Status) VALUES (@RoomId, @TaskDescription, @Status)", connection);
            command.Parameters.AddWithValue("@RoomId", task.RoomId);
            command.Parameters.AddWithValue("@TaskDescription", task.TaskDescription);
            command.Parameters.AddWithValue("@Status", task.Status);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public HousekeepingTask GetTaskById(int taskId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM HousekeepingTasks WHERE TaskId = @TaskId", connection);
            command.Parameters.AddWithValue("@TaskId", taskId);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    return new HousekeepingTask
                    {
                        TaskId = (int)reader["TaskId"],
                        RoomId = (int)reader["RoomId"],
                        TaskDescription = reader["TaskDescription"].ToString(),
                        Status = reader["Status"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return null;
    }
    public List<HousekeepingTask> GetAllTasks()
    {
        var tasks = new List<HousekeepingTask>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM HousekeepingTasks", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    tasks.Add(new HousekeepingTask
                    {
                        TaskId = (int)reader["TaskId"],
                        RoomId = (int)reader["RoomId"],
                        TaskDescription = reader["TaskDescription"].ToString(),
                        Status = reader["Status"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return tasks;
    }
    public void UpdateTask(HousekeepingTask task)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE HousekeepingTasks SET RoomId = @RoomId, TaskDescription = @TaskDescription, Status = @Status WHERE TaskId = @TaskId", connection);
            command.Parameters.AddWithValue("@TaskId", task.TaskId);
            command.Parameters.AddWithValue("@RoomId", task.RoomId);
            command.Parameters.AddWithValue("@TaskDescription", task.TaskDescription);
            command.Parameters.AddWithValue("@Status", task.Status);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteTask(int taskId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM HousekeepingTasks WHERE TaskId = @TaskId", connection);
            command.Parameters.AddWithValue("@TaskId", taskId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

7. GuestRepository.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
public class GuestRepository
{
    private readonly string _connectionString;
    public GuestRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public void AddGuest(Guest guest)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Guests (FirstName, LastName, Email, Phone) VALUES (@FirstName, @LastName, @Email, @Phone)", connection);
            command.Parameters.AddWithValue("@FirstName", guest.FirstName);
            command.Parameters.AddWithValue("@LastName", guest.LastName);
            command.Parameters.AddWithValue("@Email", guest.Email);
            command.Parameters.AddWithValue("@Phone", guest.Phone);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public Guest GetGuestById(int guestId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Guests WHERE GuestId = @GuestId", connection);
            command.Parameters.AddWithValue("@GuestId", guestId);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    return new Guest
                    {
                        GuestId = (int)reader["GuestId"],
                        FirstName = reader["FirstName"].ToString(),
                        LastName = reader["LastName"].ToString(),
                        Email = reader["Email"].ToString(),
                        Phone = reader["Phone"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return null;
    }
    public List<Guest> GetAllGuests()
    {
        var guests = new List<Guest>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Guests", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    guests.Add(new Guest
                    {
                        GuestId = (int)reader["GuestId"],
                        FirstName = reader["FirstName"].ToString(),
                        LastName = reader["LastName"].ToString(),
                        Email = reader["Email"].ToString(),
                        Phone = reader["Phone"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return guests;
    }
    public void UpdateGuest(Guest guest)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Guests SET FirstName = @FirstName, LastName = @LastName, Email = @Email, Phone = @Phone WHERE GuestId = @GuestId", connection);
            command.Parameters.AddWithValue("@GuestId", guest.GuestId);
            command.Parameters.AddWithValue("@FirstName", guest.FirstName);
            command.Parameters.AddWithValue("@LastName", guest.LastName);
            command.Parameters.AddWithValue("@Email", guest.Email);
            command.Parameters.AddWithValue("@Phone", guest.Phone);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteGuest(int guestId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Guests WHERE GuestId = @GuestId", connection);
            command.Parameters.AddWithValue("@GuestId", guestId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

8. FeedbackRepository.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
public class FeedbackRepository
{
    private readonly string _connectionString;
    public FeedbackRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public void AddFeedback(Feedback feedback)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Feedback (GuestId, Rating, Comments) VALUES (@GuestId, @Rating, @Comments)", connection);
            command.Parameters.AddWithValue("@GuestId", feedback.GuestId);
            command.Parameters.AddWithValue("@Rating", feedback.Rating);
            command.Parameters.AddWithValue("@Comments", feedback.Comments);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public Feedback GetFeedbackById(int feedbackId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Feedback WHERE FeedbackId = @FeedbackId", connection);
            command.Parameters.AddWithValue("@FeedbackId", feedbackId);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    return new Feedback
                    {
                        FeedbackId = (int)reader["FeedbackId"],
                        GuestId = (int)reader["GuestId"],
                        Rating = (int)reader["Rating"],
                        Comments = reader["Comments"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return null;
    }
    public List<Feedback> GetAllFeedbacks()
    {
        var feedbacks = new List<Feedback>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Feedback", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    feedbacks.Add(new Feedback
                    {
                        FeedbackId = (int)reader["FeedbackId"],
                        GuestId = (int)reader["GuestId"],
                        Rating = (int)reader["Rating"],
                        Comments = reader["Comments"].ToString(),
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return feedbacks;
    }
    public void UpdateFeedback(Feedback feedback)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Feedback SET GuestId = @GuestId, Rating = @Rating, Comments = @Comments WHERE FeedbackId = @FeedbackId", connection);
            command.Parameters.AddWithValue("@FeedbackId", feedback.FeedbackId);
            command.Parameters.AddWithValue("@GuestId", feedback.GuestId);
            command.Parameters.AddWithValue("@Rating", feedback.Rating);
            command.Parameters.AddWithValue("@Comments", feedback.Comments);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteFeedback(int feedbackId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Feedback WHERE FeedbackId = @FeedbackId", connection);
            command.Parameters.AddWithValue("@FeedbackId", feedbackId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

9. MenuItemRepository.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
public class MenuItemRepository
{
    private readonly string _connectionString;
    public MenuItemRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public void AddMenuItem(MenuItem menuItem)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO MenuItems (Name, Description, Price) VALUES (@Name, @Description, @Price)", connection);
            command.Parameters.AddWithValue("@Name", menuItem.Name);
            command.Parameters.AddWithValue("@Description", menuItem.Description);
            command.Parameters.AddWithValue("@Price", menuItem.Price);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public MenuItem GetMenuItemById(int menuItemId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM MenuItems WHERE MenuItemId = @MenuItemId", connection);
            command.Parameters.AddWithValue("@MenuItemId", menuItemId);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    return new MenuItem
                    {
                        MenuItemId = (int)reader["MenuItemId"],
                        Name = reader["Name"].ToString(),
                        Description = reader["Description"].ToString(),
                        Price = (decimal)reader["Price"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return null;
    }
    public List<MenuItem> GetAllMenuItems()
    {
        var menuItems = new List<MenuItem>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM MenuItems", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    menuItems.Add(new MenuItem
                    {
                        MenuItemId = (int)reader["MenuItemId"],
                        Name = reader["Name"].ToString(),
                        Description = reader["Description"].ToString(),
                        Price = (decimal)reader["Price"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return menuItems;
    }
    public void UpdateMenuItem(MenuItem menuItem)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE MenuItems SET Name = @Name, Description = @Description, Price = @Price WHERE MenuItemId = @MenuItemId", connection);
            command.Parameters.AddWithValue("@MenuItemId", menuItem.MenuItemId);
            command.Parameters.AddWithValue("@Name", menuItem.Name);
            command.Parameters.AddWithValue("@Description", menuItem.Description);
            command.Parameters.AddWithValue("@Price", menuItem.Price);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteMenuItem(int menuItemId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM MenuItems WHERE MenuItemId = @MenuItemId", connection);
            command.Parameters.AddWithValue("@MenuItemId", menuItemId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

10. EventBookingRepository.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
public class EventBookingRepository
{
    private readonly string _connectionString;
    public EventBookingRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public void AddEventBooking(EventBooking eventBooking)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO EventBookings (EventName, BookingDate, NumberOfGuests) VALUES (@EventName, @BookingDate, @NumberOfGuests)", connection);
            command.Parameters.AddWithValue("@EventName", eventBooking.EventName);
            command.Parameters.AddWithValue("@BookingDate", eventBooking.BookingDate);
            command.Parameters.AddWithValue("@NumberOfGuests", eventBooking.NumberOfGuests);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public EventBooking GetEventBookingById(int eventBookingId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM EventBookings WHERE EventBookingId = @EventBookingId", connection);
            command.Parameters.AddWithValue("@EventBookingId", eventBookingId);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    return new EventBooking
                    {
                        EventBookingId = (int)reader["EventBookingId"],
                        EventName = reader["EventName"].ToString(),
                        BookingDate = (DateTime)reader["BookingDate"],
                        NumberOfGuests = (int)reader["NumberOfGuests"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    };
                }
            }
        }
        return null;
    }
    public List<EventBooking> GetAllEventBookings()
    {
        var eventBookings = new List<EventBooking>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM EventBookings", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    eventBookings.Add(new EventBooking
                    {
                        EventBookingId = (int)reader["EventBookingId"],
                        EventName = reader["EventName"].ToString(),
                        BookingDate = (DateTime)reader["BookingDate"],
                        NumberOfGuests = (int)reader["NumberOfGuests"],
                        CreatedAt = (DateTime)reader["CreatedAt"]
                    });
                }
            }
        }
        return eventBookings;
    }
    public void UpdateEventBooking(EventBooking eventBooking)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE EventBookings SET EventName = @EventName, BookingDate = @BookingDate, NumberOfGuests = @NumberOfGuests WHERE EventBookingId = @EventBookingId", connection);
            command.Parameters.AddWithValue("@EventBookingId", eventBooking.EventBookingId);
            command.Parameters.AddWithValue("@EventName", eventBooking.EventName);
            command.Parameters.AddWithValue("@BookingDate", eventBooking.BookingDate);
            command.Parameters.AddWithValue("@NumberOfGuests", eventBooking.NumberOfGuests);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeleteEventBooking(int eventBookingId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM EventBookings WHERE EventBookingId = @EventBookingId", connection);
            command.Parameters.AddWithValue("@EventBookingId", eventBookingId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

11. PromotionRepository.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
public class PromotionRepository
{
    private readonly string _connectionString;
    public PromotionRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
    public void AddPromotion(Promotion promotion)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("INSERT INTO Promotions (Code, DiscountAmount, ExpirationDate, IsActive) VALUES (@Code, @DiscountAmount, @ExpirationDate, @IsActive)", connection);
            command.Parameters.AddWithValue("@Code", promotion.Code);
            command.Parameters.AddWithValue("@DiscountAmount", promotion.DiscountAmount);
            command.Parameters.AddWithValue("@ExpirationDate", promotion.ExpirationDate);
            command.Parameters.AddWithValue("@IsActive", promotion.IsActive);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public Promotion GetPromotionById(int promotionId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Promotions WHERE PromotionId = @PromotionId", connection);
            command.Parameters.AddWithValue("@PromotionId", promotionId);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                if (reader.Read())
                {
                    return new Promotion
                    {
                        PromotionId = (int)reader["PromotionId"],
                        Code = reader["Code"].ToString(),
                        DiscountAmount = (decimal)reader["DiscountAmount"],
                        ExpirationDate = (DateTime)reader["ExpirationDate"],
                        IsActive = (bool)reader["IsActive"]
                    };
                }
            }
        }
        return null;
    }
    public List<Promotion> GetAllPromotions()
    {
        var promotions = new List<Promotion>();
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("SELECT * FROM Promotions", connection);
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    promotions.Add(new Promotion
                    {
                        PromotionId = (int)reader["PromotionId"],
                        Code = reader["Code"].ToString(),
                        DiscountAmount = (decimal)reader["DiscountAmount"],
                        ExpirationDate = (DateTime)reader["ExpirationDate"],
                        IsActive = (bool)reader["IsActive"]
                    });
                }
            }
        }
        return promotions;
    }
    public void UpdatePromotion(Promotion promotion)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("UPDATE Promotions SET Code = @Code, DiscountAmount = @DiscountAmount, ExpirationDate = @ExpirationDate, IsActive = @IsActive WHERE PromotionId = @PromotionId", connection);
            command.Parameters.AddWithValue("@PromotionId", promotion.PromotionId);
            command.Parameters.AddWithValue("@Code", promotion.Code);
            command.Parameters.AddWithValue("@DiscountAmount", promotion.DiscountAmount);
            command.Parameters.AddWithValue("@ExpirationDate", promotion. ExpirationDate);
            command.Parameters.AddWithValue("@IsActive", promotion.IsActive);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
    public void DeletePromotion(int promotionId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var command = new SqlCommand("DELETE FROM Promotions WHERE PromotionId = @PromotionId", connection);
            command.Parameters.AddWithValue("@PromotionId", promotionId);
            connection.Open();
            command.ExecuteNonQuery();
        }
    }
}

This implementation provides a complete set of repository classes for all models in your Online Ticket Booking System. Each repository includes methods for adding, retrieving, updating, and deleting records from the database. Ensure to handle exceptions and edge cases in your production code, such as connection issues or invalid data. You may also want to implement a data access layer or use dependency injection to manage your repositories more effectively.

Creating Controllers

Now create controller for all repositories.

Below are the controller implementations for each repository in your Online Ticket Booking System. Each controller will handle HTTP requests and interact with the corresponding repository to perform CRUD operations.

1. UserController.cs

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
public class UserController : Controller
{
    private readonly UserRepository _userRepository;
    public UserController(UserRepository userRepository)
    {
        _userRepository = userRepository;
    }
    [HttpPost]
    public IActionResult Create(User user)
    {
        _userRepository.AddUser (user);
        return RedirectToAction("Index");
    }
    public IActionResult Index()
    {
        var users = _userRepository.GetAllUsers();
        return View(users);
    }
    public IActionResult Edit(int id)
    {
        var user = _userRepository.GetUser ById(id);
        return View(user);
    }
    [HttpPost]
    public IActionResult Edit(User user)
    {
        _userRepository.UpdateUser (user);
        return RedirectToAction("Index");
    }
    public IActionResult Delete(int id)
    {
        _userRepository.DeleteUser (id);
        return RedirectToAction("Index");
    }
}

2. RoleController.cs

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
public class RoleController : Controller
{
    private readonly RoleRepository _roleRepository;
    public RoleController(RoleRepository roleRepository)
    {
        _roleRepository = roleRepository;
    }
    [HttpPost]
    public IActionResult Create(Role role)
    {
        _roleRepository.AddRole(role);
        return RedirectToAction("Index");
    }
    public IActionResult Index()
    {
        var roles = _roleRepository.GetAllRoles();
        return View(roles);
    }
    public IActionResult Edit(int id)
    {
        var role = _roleRepository.GetRoleById(id);
        return View(role);
    }
    [HttpPost]
    public IActionResult Edit(Role role)
    {
        _roleRepository.UpdateRole(role);
        return RedirectToAction("Index");
    }
    public IActionResult Delete(int id)
    {
        _roleRepository.DeleteRole(id);
        return RedirectToAction("Index");
    }
}

3. ReservationController.cs

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
public class ReservationController : Controller
{
    private readonly ReservationRepository _reservationRepository;
    public ReservationController(ReservationRepository reservationRepository)
    {
        _reservationRepository = reservationRepository;
    }
    [HttpPost]
    public IActionResult Create(Reservation reservation)
    {
        _reservationRepository.AddReservation(reservation);
        return RedirectToAction("Index");
    }
    public IActionResult Index()
    {
        var reservations = _reservationRepository.GetAllReservations();
        return View(reservations);
    }
    public IActionResult Edit(int id)
    {
        var reservation = _reservationRepository.GetReservationById(id);
        return View(reservation);
    }
    [HttpPost]
    public IActionResult Edit(Reservation reservation)
    {
        _reservationRepository.UpdateReservation(reservation);
        return RedirectToAction("Index");
    }
    public IActionResult Delete(int id)
    {
        _reservationRepository.DeleteReservation(id);
        return RedirectToAction("Index");
    }
}

4. RoomController.cs

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
public class RoomController : Controller
{
    private readonly RoomRepository _roomRepository;
    public RoomController(RoomRepository roomRepository)
    {
        _roomRepository = roomRepository;
    }
    [HttpPost]
    public IActionResult Create(Room room)
    {
        _roomRepository.AddRoom(room);
        return RedirectToAction("Index");
    }
    public IActionResult Index()
    {
        var rooms = _roomRepository.GetAllRooms();
        return View(rooms);
    }
    public IActionResult Edit(int id)
    {
        var room = _roomRepository.GetRoomById(id);
        return View(room);
    }
    [HttpPost]
    public IActionResult Edit(Room room)
    {
        _roomRepository.UpdateRoom(room);
        return RedirectToAction("Index");
    }
    public IActionResult Delete(int id)
    {
        _roomRepository.DeleteRoom(id);
        return RedirectToAction("Index");
    }
}

5. InvoiceController.cs

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
public class InvoiceController : Controller
{
    private readonly InvoiceRepository _invoiceRepository;
    public InvoiceController(InvoiceRepository invoiceRepository)
    {
        _invoiceRepository = invoiceRepository;
    }
    [HttpPost]
    public IActionResult Create(Invoice invoice)
    {
        _invoiceRepository.AddInvoice(invoice);
        return RedirectToAction("Index");
    }
    public IActionResult Index()
    {
        var invoices = _invoiceRepository.GetAllInvoices();
        return View(invoices);
    }
    public IActionResult Edit(int id)
    {
        var invoice = _invoiceRepository.GetInvoiceById(id);
        return View(invoice);
    }
    [HttpPost]
    public IActionResult Edit(Invoice invoice)
    {
        _invoiceRepository.UpdateInvoice(invoice);
        return RedirectToAction("Index");
    }
    public IActionResult Delete(int id)
    {
        _invoiceRepository.DeleteInvoice(id);
        return RedirectToAction("Index");
    }
}

6. HousekeepingTaskController.cs

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
public class HousekeepingTaskController : Controller
{
    private readonly HousekeepingTaskRepository _taskRepository;
    public HousekeepingTaskController(HousekeepingTaskRepository taskRepository)
    {
        _taskRepository = taskRepository;
    }
    [HttpPost]
    public IActionResult Create(HousekeepingTask task)
    {
        _taskRepository.AddTask(task);
        return RedirectToAction("Index");
    }
    public IActionResult Index()
    {
        var tasks = _taskRepository.GetAllTasks();
        return View(tasks);
    }
    public IActionResult Edit(int id)
    {
        var task = _taskRepository.GetTaskById(id);
        return View(task);
    }
    [HttpPost]
    public IActionResult Edit(HousekeepingTask task)
    {
        _taskRepository.UpdateTask(task);
        return RedirectToAction("Index");
    }
    public IActionResult Delete(int id)
    {
        _taskRepository.DeleteTask(id);
        return RedirectToAction("Index");
    }
}

7. GuestController.cs

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
public class GuestController : Controller
{
    private readonly GuestRepository _guestRepository;
    public GuestController(GuestRepository guestRepository)
    {
        _guestRepository = guestRepository;
    }
    [HttpPost]
    public IActionResult Create(Guest guest)
    {
        _guestRepository.AddGuest(guest);
        return RedirectToAction("Index");
    }
    public IActionResult Index()
    {
        var guests = _guestRepository.GetAllGuests();
        return View(guests);
    }
    public IActionResult Edit(int id)
    {
        var guest = _guestRepository.GetGuestById(id);
        return View(guest);
    }
    [HttpPost]
    public IActionResult Edit(Guest guest)
    {
        _guestRepository.UpdateGuest(guest);
        return RedirectToAction("Index");
    }
    public IActionResult Delete(int id)
    {
        _guestRepository.DeleteGuest(id);
        return RedirectToAction("Index");
    }
}

8. FeedbackController.cs

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
public class FeedbackController : Controller
{
    private readonly FeedbackRepository _feedbackRepository;
    public FeedbackController(FeedbackRepository feedbackRepository)
    {
        _feedbackRepository = feedbackRepository;
    }
    [HttpPost]
    public IActionResult Create(Feedback feedback)
    {
        _feedbackRepository.AddFeedback(feedback);
        return RedirectToAction("Index");
    }
    public IActionResult Index()
    {
        var feedbacks = _feedbackRepository.GetAllFeedbacks();
        return View(feedbacks);
    }
    public IActionResult Edit(int id)
    {
        var feedback = _feedbackRepository.GetFeedbackById(id);
        return View(feedback);
    }
    [HttpPost]
    public IActionResult Edit(Feedback feedback)
    {
        _feedbackRepository.UpdateFeedback(feedback);
        return RedirectToAction("Index");
    }
    public IActionResult Delete(int id)
    {
        _feedbackRepository.DeleteFeedback(id);
        return RedirectToAction("Index");
    }
}

9. MenuItemController.cs

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
public class MenuItemController : Controller
{
    private readonly MenuItemRepository _menuItemRepository;
    public MenuItemController(MenuItemRepository menuItemRepository)
    {
        _menuItemRepository = menuItemRepository;
    }
    [HttpPost]
    public IActionResult Create(MenuItem menuItem)
    {
        _menuItemRepository.AddMenuItem(menuItem);
        return RedirectToAction("Index");
    }
    public IActionResult Index()
    {
        var menuItems = _menuItemRepository.GetAllMenuItems();
        return View(menuItems);
    }
    public IActionResult Edit(int id)
    {
        var menuItem = _menuItemRepository.GetMenuItemById(id);
        return View(menuItem);
    }
    [HttpPost]
    public IActionResult Edit(MenuItem menuItem)
    {
        _menuItemRepository.UpdateMenuItem(menuItem);
        return RedirectToAction("Index");
    }
    public IActionResult Delete(int id)
    {
        _menuItemRepository.DeleteMenuItem(id);
        return RedirectToAction("Index");
    }
}

10. EventBookingController.cs

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
public class EventBookingController : Controller
{
    private readonly EventBookingRepository _eventBookingRepository;
    public EventBookingController(EventBookingRepository eventBookingRepository)
    {
        _eventBookingRepository = eventBookingRepository;
    }
    [HttpPost]
    public IActionResult Create(EventBooking eventBooking)
    {
        _eventBookingRepository.AddEventBooking(eventBooking);
        return RedirectToAction("Index");
    }
    public IActionResult Index()
    {
        var eventBookings = _eventBookingRepository.GetAllEventBookings();
        return View(eventBookings);
    }
    public IActionResult Edit(int id)
    {
        var eventBooking = _eventBookingRepository.GetEventBookingById(id);
        return View(eventBooking);
    }
    [HttpPost]
    public IActionResult Edit(EventBooking eventBooking)
    {
        _eventBookingRepository.UpdateEventBooking(eventBooking);
        return RedirectToAction("Index");
    }
    public IActionResult Delete(int id)
    {
        _eventBookingRepository.DeleteEventBooking(id);
        return RedirectToAction("Index");
    }
}

11. PromotionController.cs

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
public class PromotionController : Controller
{
    private readonly PromotionRepository _promotionRepository;
    public PromotionController(PromotionRepository promotionRepository)
    {
        _promotionRepository = promotionRepository;
    }
    [HttpPost]
    public IActionResult Create(Promotion promotion)
    {
        _promotionRepository.AddPromotion(promotion);
        return RedirectToAction("Index");
    }
    public IActionResult Index()
    {
        var promotions = _promotionRepository.GetAllPromotions();
        return View(promotions);
    }
    public IActionResult Edit(int id)
    {
        var promotion = _promotionRepository.GetPromotionById(id);
        return View(promotion);
    }
    [HttpPost]
    public IActionResult Edit(Promotion promotion)
    {
        _promotionRepository.UpdatePromotion(promotion);
        return RedirectToAction("Index");
    }
    public IActionResult Delete(int id)
    {
        _promotionRepository.DeletePromotion(id);
        return RedirectToAction("Index");
    }
}

In this implementation, each controller corresponds to a repository and provides methods for handling HTTP requests related to that entity. The controllers include:

User Controller: Manages user-related actions (create, read, update, delete).

RoleController: Manages role-related actions.

ReservationController: Manages reservation-related actions.

RoomController: Manages room-related actions.

InvoiceController: Manages invoice-related actions.

HousekeepingTaskController: Manages housekeeping tasks.

GuestController: Manages guest-related actions.

FeedbackController: Manages feedback submissions.

MenuItemController: Manages menu items.

EventBookingController: Manages event bookings.

PromotionController: Manages promotions.

Notes

Dependency Injection: Ensure that you configure your repository classes in the Startup.cs file for dependency injection.

Views: Each controller action that returns a view (like Index, Edit, etc.) assumes that you have corresponding Razor views set up in the appropriate folder structure.

Error Handling: Consider adding error handling and validation logic to ensure robustness.

Security: Implement authentication and authorization as needed to protect sensitive operations.

This structure provides a solid foundation for your ASP.NET application, allowing you to manage various entities related to your Online Ticket Booking System effectively.

Basic Razor View Files

Below are the basic Razor view files for each controller in your Online Ticket Booking System. Each view will correspond to the actions defined in the controllers, allowing you to create, read, update, and delete records for each entity.

User Views

Views/User/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>Role</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var user in Model)
        {
            <tr>
                <td>@user.Username</td>
                <td>@user.Email</td>
                <td>@user.RoleId</td>
                <td>
                    <a href='@Url.Action("Edit", new { id = user.UserId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = user.UserId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/User/Create.cshtml

@model User
<h2>Create User</h2>
<form asp-action="Create" method="post">
    <label>Username:</label>
    <input asp-for="Username" required />
    <label>Password:</label>
    <input asp-for="PasswordHash" type="password" required />
    <label>Email:</label>
    <input asp-for="Email" required />
    <label>Role ID:</label>
    <input asp-for="RoleId" required />
    <button type="submit">Create</button>
</form>

Views/User/Edit.cshtml

@model User
<h2>Edit User</h2>
<form asp-action="Edit" method="post">
    <input type="hidden" asp-for="User Id" />
    <label>Username:</label>
    <input asp-for="Username" required />
    <label>Password:</label>
    <input asp-for="PasswordHash" type="password" />
    <label>Email:</label>
    <input asp-for="Email" required />
    <label>Role ID:</label>
    <input asp-for="RoleId" required />
    <button type="submit">Update</button>
</form>

Role Views

Views/Role/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>
                    <a href='@Url.Action("Edit", new { id = role.RoleId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = role.RoleId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Role/Create.cshtml

@model Role
<h2>Create Role</h2>
<form asp-action="Create" method="post">
    <label>Role Name:</label>
    <input asp-for="RoleName" required />
    <button type="submit">Create</button>
</form>

Views/Role/Edit.cshtml

@model Role
<h2>Edit Role</h2>
<form asp-action="Edit" method="post">
    <input type="hidden" asp-for="RoleId" />
    <label>Role Name:</label>
    <input asp-for="RoleName" required />
    <button type="submit">Update</button>
</form>

Reservation Views

Views/Reservation/Index.cshtml

@model IEnumerable<Reservation>
<h2>Reservations</h2>
<a href='@Url.Action("Create")'>Create New Reservation</a>
<table>
    <thead>
        <tr>
            <th>Guest ID</th>
            <th>Room ID</th>
            <th>Check-In Date</th>
            <th>Check-Out Date</th>
            <th>Status</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var reservation in Model)
        {
            <tr>
                <td>@reservation.GuestId</td>
                <td>@reservation.RoomId</td>
                <td>@reservation.CheckInDate.ToShortDateString()</td>
                <td>@reservation.CheckOutDate.ToShortDateString()</td>
                <td>@reservation.Status</td>
                <td>
                    <a href='@Url.Action("Edit", new { id = reservation.ReservationId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = reservation.ReservationId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Reservation/Create.cshtml

@model Reservation
<h2>Create Reservation</h2>
<form asp-action="Create" method="post">
    <label>Guest ID:</label>
    <input asp-for="GuestId" required />
    <label>Room ID:</label>
    <input asp-for="RoomId" required />
    <label>Check-In Date:</label>
    <input asp-for="CheckInDate" type="date" required />
    <label>Check-Out Date:</label>
    <input asp-for="CheckOutDate" type="date" required />
    <label>Number of Guests:</label>
    <input asp-for="NumberOfGuests" required />
    <label>Status:</label>
    <input asp-for="Status" required />
    <button type="submit">Create</button>
</form>

Views/Reservation/Edit.cshtml

@model Reservation
<h2>Edit Reservation</h2>
<form asp-action="Edit" method="post">
    <input type="hidden" asp-for="ReservationId" />
    <label>Guest ID:</label>
    <input asp-for="GuestId" required />
    <label>Room ID:</label>
    <input asp-for="RoomId" required />
    <label>Check-In Date:</label>
    <input asp-for="CheckInDate" type="date" required />
    <label>Check-Out Date:</label>
    <input asp-for="CheckOutDate" type="date" required />
    <label>Number of Guests:</label>
    <input asp-for="NumberOfGuests" required />
    <label>Status:</label>
    <input asp-for="Status" required />
    <button type="submit">Update</button>
</form>

Room Views

Views/Room/Index.cshtml

@model IEnumerable<Room>
<h2>Rooms</h2>
<a href='@Url.Action("Create")'>Create New Room</a>
<table>
    <thead>
        <tr>
            <th>Room Number</th>
            <th>Room Type</th>
            <th>Price</th>
            <th>Status</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var room in Model)
        {
            <tr>
                <td>@room.RoomNumber</td>
                <td>@room.RoomType</td>
                <td>@room.Price</td>
                <td>@room.Status</td>
                <td>
                    <a href='@Url.Action("Edit", new { id = room.RoomId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = room.RoomId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Room/Create.cshtml

@model Room
<h2>Create Room</h2>
<form asp-action="Create" method="post">
    <label>Room Number:</label>
    <input asp-for="RoomNumber" required />
    <label>Room Type:</label>
    <input asp-for="RoomType" required />
    <label>Price:</label>
    <input asp-for="Price" required />
    <label>Status:</label>
    <input asp-for="Status" required />
    <button type="submit">Create</button>
</form>

Views/Room/Edit.cshtml

@model Room
<h2>Edit Room</h2>
<form asp-action="Edit" method="post">
    <input type="hidden" asp-for="RoomId" />
    <label>Room Number:</label>
    <input asp-for="RoomNumber" required />
    <label>Room Type:</label>
    <input asp-for="RoomType" required />
    <label>Price:</label>
    <input asp-for="Price" required />
    <label>Status:</label>
    <input asp-for="Status" required />
    <button type="submit">Update</button>
</form>

Invoice Views

Views/Invoice/Index.cshtml

@model IEnumerable<Invoice>
<h2>Invoices</h2>
<a href='@Url.Action("Create")'>Create New Invoice</a>
<table>
    <thead>
        <tr>
            <th>Reservation ID</th>
            <th>Amount</th>
            <th>Payment Status</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var invoice in Model)
        {
            <tr>
                <td>@invoice.ReservationId</td>
                <td>@invoice.Amount</td>
                <td>@invoice.PaymentStatus</td>
                <td>
                    <a href='@Url.Action("Edit", new { id = invoice.InvoiceId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = invoice.InvoiceId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Invoice/Create.cshtml

@model Invoice
<h2>Create Invoice</h2>
<form asp-action="Create" method="post">
    <label>Reservation ID:</label>
    <input asp-for="ReservationId" required />
    <label>Amount:</label>
    <input asp-for="Amount" required />
    <label >Payment Status:</label>
    <input asp-for="PaymentStatus" required />
    <button type="submit">Create</button>
</form>

Views/Invoice/Edit.cshtml

@model Invoice
<h2>Edit Invoice</h2>
<form asp-action="Edit" method="post">
    <input type="hidden" asp-for="InvoiceId" />
    <label>Reservation ID:</label>
    <input asp-for="ReservationId" required />
    <label>Amount:</label>
    <input asp-for="Amount" required />
    <label>Payment Status:</label>
    <input asp-for="PaymentStatus" required />
    <button type="submit">Update</button>
</form>

Housekeeping Task Views

Views/HousekeepingTask/Index.cshtml

@model IEnumerable<HousekeepingTask>
<h2>Housekeeping Tasks</h2>
<a href='@Url.Action("Create")'>Create New Task</a>
<table>
    <thead>
        <tr>
            <th>Task Name</th>
            <th>Status</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var task in Model)
        {
            <tr>
                <td>@task.TaskName</td>
                <td>@task.Status</td>
                <td>
                    <a href='@Url.Action("Edit", new { id = task.TaskId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = task.TaskId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/HousekeepingTask/Create.cshtml

@model HousekeepingTask
<h2>Create Housekeeping Task</h2>
<form asp-action="Create" method="post">
    <label>Task Name:</label>
    <input asp-for="TaskName" required />
    <label>Status:</label>
    <input asp-for="Status" required />
    <button type="submit">Create</button>
</form>

Views/HousekeepingTask/Edit.cshtml

@model HousekeepingTask
<h2>Edit Housekeeping Task</h2>
<form asp-action="Edit" method="post">
    <input type="hidden" asp-for="TaskId" />
    <label>Task Name:</label>
    <input asp-for="TaskName" required />
    <label>Status:</label>
    <input asp-for="Status" required />
    <button type="submit">Update</button>
</form>

Guest Views

Views/Guest/Index.cshtml

@model IEnumerable<Guest>
<h2>Guests</h2>
<a href='@Url.Action("Create")'>Create New Guest</a>
<table>
    <thead>
        <tr>
            <th>Guest Name</th>
            <th>Email</th>
            <th>Phone</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var guest in Model)
        {
            <tr>
                <td>@guest.Name</td>
                <td>@guest.Email</td>
                <td>@guest.Phone</td>
                <td>
                    <a href='@Url.Action("Edit", new { id = guest.GuestId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = guest.GuestId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Guest/Create.cshtml

@model Guest
<h2>Create Guest</h2>
<form asp-action="Create" method="post">
    <label>Name:</label>
    <input asp-for="Name" required />
    <label>Email:</label>
    <input asp-for="Email" required />
    <label>Phone:</label>
    <input asp-for="Phone" required />
    <button type="submit">Create</button>
</form>

Views/Guest/Edit.cshtml

@model Guest
<h2>Edit Guest</h2>
<form asp-action="Edit" method="post">
    <input type="hidden" asp-for="GuestId" />
    <label>Name:</label>
    <input asp-for="Name" required />
    <label>Email:</label>
    <input asp-for="Email" required />
    <label>Phone:</label>
    <input asp-for="Phone" required />
    <button type="submit">Update</button>
</form>

Feedback Views

Views/Feedback/Index.cshtml

@model IEnumerable<Feedback>
<h2>Feedback</h2>
<a href='@Url.Action("Create")'>Create New Feedback</a>
<table>
    <thead>
        <tr>
            <th>Guest ID</th>
            <th>Comments</th>
            <th>Rating</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var feedback in Model)
        {
            <tr>
                <td>@feedback.GuestId</td>
                <td>@feedback.Comments</td>
                <td>@feedback.Rating</td>
                <td>
                    <a href='@Url.Action("Edit", new { id = feedback.FeedbackId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = feedback.FeedbackId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Feedback/Create.cshtml

@model Feedback
<h2>Create Feedback</h2>
<form asp-action="Create" method="post">
    <label>Guest ID:</label>
    <input asp-for="GuestId" required />
    <label>Comments:</label>
    <textarea asp-for="Comments" required></textarea>
    <label>Rating:</label>
    <input asp-for="Rating" type="number" min="1" max="5" required />
    <button type="submit">Create</button>
</form>

Views/Feedback/Edit.cshtml

@model Feedback
<h2>Edit Feedback</h2>
<form asp-action="Edit" method="post">
    <input type="hidden" asp-for="FeedbackId" />
    <label>Guest ID:</label>
    <input asp-for="GuestId" required />
    <label>Comments:</label>
    <textarea asp-for="Comments" required></textarea>
    <label>Rating:</label>
    <input asp-for="Rating" type="number" min="1" max="5" required />
    <button type="submit">Update</button>
</form>

Menu Item Views

Views/MenuItem/Index.cshtml

@model IEnumerable<MenuItem>
<h2>Menu Items</h2>
<a href='@Url.Action("Create")'>Create New Menu Item</a>
<table>
    <thead>
        <tr>
            <th>Name</th>
            <th>Price</th>
            <th>Description</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@item.Name</td>
                <td>@item.Price</td>
                <td>@item.Description</td>
                <td>
                    <a href='@Url.Action("Edit", new { id = item.MenuItemId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = item.MenuItemId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/MenuItem/Create.cshtml

@model MenuItem
<h2>Create Menu Item</h2>
<form asp-action="Create" method="post">
    <label>Name:</label>
    <input asp-for="Name" required />
    <label>Price:</label>
    <input asp-for="Price" required />
    <label>Description:</label>
    <textarea asp-for="Description" required></textarea>
    <button type="submit">Create</button>
</form>

Views/MenuItem/Edit.cshtml

@model MenuItem
<h2>Edit Menu Item</h2>
<form asp-action="Edit" method="post">
    <input type="hidden" asp-for="MenuItemId" />
    <label>Name:</label>
    <input asp-for="Name" required />
    <label>Price:</label>
    <input asp-for="Price" required />
    <label>Description:</label>
    <textarea asp-for="Description" required></textarea>
    <button type="submit">Update</button>
</form>

Event Booking Views

Views/EventBooking/Index.cshtml

@model IEnumerable<EventBooking>
<h2>Event Bookings</h2>
<a href='@Url.Action("Create")'>Create New Event Booking</a>
<table>
    <thead>
        <tr>
            <th>Event ID</th>
            <th>Guest ID</th>
            <th>Booking Date</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var booking in Model)
        {
            <tr>
                <td>@booking.EventId</td>
                <td>@booking.G uestId</td>
                <td>@booking.BookingDate.ToShortDateString()</td>
                <td>
                    <a href='@Url.Action("Edit", new { id = booking.EventBookingId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = booking.EventBookingId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/EventBooking/Create.cshtml

@model EventBooking
<h2>Create Event Booking</h2>
<form asp-action="Create" method="post">
    <label>Event ID:</label>
    <input asp-for="EventId" required />
    <label>Guest ID:</label>
    <input asp-for="GuestId" required />
    <label>Booking Date:</label>
    <input asp-for="BookingDate" type="date" required />
    <button type="submit">Create</button>
</form>

Views/EventBooking/Edit.cshtml

@model EventBooking
<h2>Edit Event Booking</h2>
<form asp-action="Edit" method="post">
    <input type="hidden" asp-for="EventBookingId" />
    <label>Event ID:</label>
    <input asp-for="EventId" required />
    <label>Guest ID:</label>
    <input asp-for="GuestId" required />
    <label>Booking Date:</label>
    <input asp-for="BookingDate" type="date" required />
    <button type="submit">Update</button>
</form>

Promotion Views

Views/Promotion/Index.cshtml

@model IEnumerable<Promotion>
<h2>Promotions</h2>
<a href='@Url.Action("Create")'>Create New Promotion</a>
<table>
    <thead>
        <tr>
            <th>Promotion Name</th>
            <th>Discount Percentage</th>
            <th>Start Date</th>
            <th>End Date</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var promotion in Model)
        {
            <tr>
                <td>@promotion.Name</td>
                <td>@promotion.DiscountPercentage</td>
                <td>@promotion.StartDate.ToShortDateString()</td>
                <td>@promotion.EndDate.ToShortDateString()</td>
                <td>
                    <a href='@Url.Action("Edit", new { id = promotion.PromotionId })'>Edit</a> |
                    <a href='@Url.Action("Delete", new { id = promotion.PromotionId })'>Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Views/Promotion/Create.cshtml

@model Promotion
<h2>Create Promotion</h2>
<form asp-action="Create" method="post">
    <label>Promotion Name:</label>
    <input asp-for="Name" required />
    <label>Discount Percentage:</label>
    <input asp-for="DiscountPercentage" required />
    <label>Start Date:</label>
    <input asp-for="StartDate" type="date" required />
    <label>End Date:</label>
    <input asp-for="EndDate" type="date" required />
    <button type="submit">Create</button>
</form>

Views/Promotion/Edit.cshtml

@model Promotion
<h2>Edit Promotion</h2>
<form asp-action="Edit" method="post">
    <input type="hidden" asp-for="PromotionId" />
    <label>Promotion Name:</label>
    <input asp-for="Name" required />
    <label>Discount Percentage:</label>
    <input asp-for="DiscountPercentage" required />
    <label>Start Date:</label>
    <input asp-for="StartDate" type="date" required />
    <label>End Date:</label>
    <input asp-for="EndDate" type="date" required />
    <button type="submit">Update</button>
</form>

This completes the basic Razor view files for all controllers in your Online Ticket Booking System. Each view is designed to facilitate the management of the respective entities, providing a user-friendly interface for creating, editing, and deleting records.

Creating a Dashboard Page

Creating a dashboard page for your Online Ticket Booking System involves aggregating and displaying key metrics and data from various entities in your application. Below is an example of how you might structure a dashboard page using Razor syntax in ASP.NET.

Dashboard View

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 Reservations</h3>
        <p>@Model.TotalReservations</p>
    </div>
    <div class="card">
        <h3>Total Rooms</h3>
        <p>@Model.TotalRooms</p>
    </div>
    <div class="card">
        <h3>Total Invoices</h3>
        <p>@Model.TotalInvoices</p>
    </div>
    <div class="card">
        <h3>Total Feedback</h3>
        <p>@Model.TotalFeedback</p>
    </div>
    <div class="card">
        <h3>Total Menu Items</h3>
        <p>@Model.TotalMenuItems</p>
    </div>
    <div class="card">
        <h3>Total Event Bookings</h3>
        <p>@Model.TotalEventBookings</p>
    </div>
    <div class="card">
        <h3>Total Promotions</h3>
        <p>@Model.TotalPromotions</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>

Dashboard ViewModel

You will need a ViewModel to hold the data for the dashboard. Create a new class called DashboardViewModel.

Models/DashboardViewModel.cs

public class DashboardViewModel
{
    public int TotalUsers { get; set; }
    public int TotalReservations { get; set; }
    public int TotalRooms { get; set; }
    public int TotalInvoices { get; set; }
    public int TotalFeedback { get; set; }
    public int TotalMenuItems { get; set; }
    public int TotalEventBookings { get; set; }
    public int TotalPromotions { get; set; }
}

Dashboard Controller

You will need a controller to populate the dashboard data. Create a new controller called DashboardController.

Controllers/DashboardController.cs

using Microsoft.AspNetCore.Mvc;
public class DashboardController : Controller
{
    private readonly UserRepository _userRepository;
    private readonly ReservationRepository _reservationRepository;
    private readonly RoomRepository _roomRepository;
    private readonly InvoiceRepository _invoiceRepository;
    private readonly FeedbackRepository _feedbackRepository;
    private readonly MenuItemRepository _menuItemRepository;
    private readonly EventBookingRepository _eventBookingRepository;
    private readonly PromotionRepository _promotionRepository;
    public DashboardController(
        UserRepository userRepository,
        ReservationRepository reservationRepository,
        RoomRepository roomRepository,
        InvoiceRepository invoiceRepository,
        FeedbackRepository feedbackRepository,
        MenuItemRepository menuItemRepository,
        EventBookingRepository eventBookingRepository,
        PromotionRepository promotionRepository)
    {
        _userRepository = userRepository;
        _reservationRepository = reservationRepository;
        _roomRepository = roomRepository;
        _invoiceRepository = invoiceRepository;
        _feedbackRepository = feedbackRepository;
        _menuItemRepository = menuItemRepository;
        _eventBookingRepository = eventBookingRepository;
        _promotionRepository = promotionRepository;
    }
    public IActionResult Index()
    {
        var model = new DashboardViewModel
        {
            TotalUsers = _userRepository.GetAllUsers().Count,
            TotalReservations = _reservationRepository.GetAllReservations().Count,
            TotalRooms = _roomRepository.GetAllRooms().Count,
            TotalInvoices = _invoiceRepository.GetAllInvoices().Count,
            TotalFeedback = _feedbackRepository.GetAllFeedbacks().Count,
            TotalMenuItems = _menuItemRepository.GetAllMenuItems().Count,
            TotalEventBookings = _eventBookingRepository.GetAllEventBookings().Count,
            TotalPromotions = _promotionRepository.GetAllPromotions().Count
        };
        return View(model);
    }
}