Relaxing Koala — Restaurant Information System (RIS)

A C# project that digitises day-to-day cafe operations for Relaxing Koala. It manages customers, menus, orders, and reservations with a clean, layered architecture (UI → Controllers → Business Logic → Data Access → Models). Data is persisted as JSON so the app is easy to inspect and extend.

Table of Contents

• Features
• Architecture
• Project Structure
• Requirements
• Quick Start
• Configuration
• Data Storage
• Typical Flows
• Demo
• Roadmap
• Contributors
• License

Features

• Customer records: create, update, search, and reuse across reservations and orders.
• Menu management: add, edit, remove items; present curated menus to users.
• Orders: build and track dine-in and pickup orders with persistence.
• Reservations: check availability, create bookings, modify, and cancel.
• Clear separation of concerns: UI, Controllers, Business Logic, Data Access, and Models.
• JSON persistence through a generic FileManager<T> for consistent I/O.
• Designed to be maintainable, testable, and simple to extend.

Tip: add screenshots under images/ and reference them here, e.g.
![Menu screenshot](images/menu.png)

Architecture

The system follows MVC with a dedicated Data Access Layer. Each layer has a single responsibility to keep changes local and predictable.

Layer	Responsibility	Examples
UI	Console views for input/output	CustomerView, MenuView, OrderView, IView
Controllers	Translate user actions into business operations	CustomerController, MenuController, OrderController
Business Logic	Core workflows and validation	CustomerManager, MenuManager, OrderManager, ReservationManager
Data Access (DAL)	JSON read/write behind a generic gateway	CustomerDataAccess, MenuItemDataAccess, OrderDataAccess, ReservationDataAccess, FileManager<T>
Models	Domain entities	Customer, MenuItem, Order, Reservation, etc.

flowchart LR
  subgraph UI[UI]
    A[CustomerView]
    B[MenuView]
    C[OrderView]
  end

  subgraph CTRL[Controllers]
    D[CustomerController]
    E[MenuController]
    F[OrderController]
  end

  subgraph BL[Business Logic]
    G[CustomerManager]
    H[MenuManager]
    I[OrderManager]
    J[ReservationManager]
  end

  subgraph DAL[Data Access]
    K[CustomerDataAccess]
    L[MenuItemDataAccess]
    M[OrderDataAccess]
    N[ReservationDataAccess]
    O[FileManager<T>]
  end

  P[(JSON Files)]

  A --> D
  B --> E
  C --> F
  D --> G
  E --> H
  F --> I
  D -.-> J
  G --> K
  H --> L
  I --> M
  J --> N
  K --> O --> P
  L --> O
  M --> O
  N --> O

Loading

Project Structure

/RIS
  Program.cs

  /UI
    CustomerView.cs
    MenuView.cs
    OrderView.cs
    IView.cs

  /Controllers
    CustomerController.cs
    MenuController.cs
    OrderController.cs

  /BusinessLogic
    CustomerManager.cs
    MenuManager.cs
    OrderManager.cs
    ReservationManager.cs

  /DataAccess
    CustomerDataAccess.cs
    MenuItemDataAccess.cs
    OrderDataAccess.cs
    ReservationDataAccess.cs

  /Models
    Customer.cs
    MenuItem.cs
    Order.cs
    Reservation.cs
    Feedback.cs
    Person.cs
    FileManager.cs

  /data      (suggested folder for JSON files)
  /images    (screenshots/diagrams for the README)

Requirements

• .NET SDK 6.0 or newer
• Windows, macOS, or Linux
• Git (optional, for cloning)

Quick Start

git clone https://github.com/your-username/relaxing-koala-ris.git
cd relaxing-koala-ris
dotnet restore
dotnet build
dotnet run

Program.cs wires up Views → Controllers → Managers → Data Access, then starts the main loop.

Configuration

Set the storage directory (e.g., ./data) in each *DataAccess class. Keep filenames consistent across the project.

// Example inside a DataAccess class
private readonly FileManager<Customer> _fm =
    new FileManager<Customer>(path: "data/customers.json");

Data Storage

Each entity type is stored in its own JSON file. The generic file manager handles serialization/deserialization.

[
  {
    "Id": "cappuccino",
    "Name": "Cappuccino",
    "Description": "Double shot with steamed milk and foam",
    "Price": 4.80
  },
  {
    "Id": "flat-white",
    "Name": "Flat White",
    "Description": "Velvety microfoam over espresso",
    "Price": 4.80
  }
]

Typical Flows

Place an order

1. User opens the menu in MenuView.
2. Selections are sent to OrderController.
3. OrderController calls OrderManager to create/update the order.
4. OrderManager persists via OrderDataAccess (JSON).
5. Active orders can be read by kitchen/ops from stored state.

Make a reservation

1. View/controller captures reservation details.
2. ReservationManager validates availability and rules.
3. ReservationDataAccess writes the booking to JSON.

Manage customers

1. Create or update a customer in the view.
2. CustomerController calls CustomerManager.
3. CustomerDataAccess saves the change.

Demo

https://www.youtube.com/watch?v=oz1AjqzSJI4

Roadmap

• Payment integration through secure external gateways.
• Analytics dashboards (popular items, sales trends).
• Mobile-friendly client or companion app.

License

MIT