Documentation

  • Home
  • Documentation
Dreams EMR Admin Dashboard

Introduction

Dreams EMR is a admin template for Electronic Medical Record. Dreams EMR is a well-designed fully responsive admin template that makes the web administration process easier than ever. It is equipped with various functionalities and is platform compatible.

System Requirements

Node.js

Version 18.x or later

npm

Version 9.x or later

Web Browser

Chrome, Firefox, Edge, Safari

Features

React 19 + TypeScript + Vite

Fast, modern stack for web applications

Redux Toolkit

Scalable state management with typed hooks

Ant Design & Bootstrap 5

Rich UI components and utilities

Code Splitting

Uses React.lazy & Suspense for performance

Custom Hooks

For theme, debouncing, and more

Internationalization (i18n)

Multi-language support (EN, DE, FR, AR)

RTL Support

Dynamic RTL/LTR switching with custom overrides

Modular Structure

Feature-based organization for easy scaling

Custom Styling

All custom tweaks in src/assets/scss/ and src/assets/css/

Charts & Widgets

Dashboard-ready with Chart.js, ApexCharts, and more

Fully Responsive

Compatible with all mobile devices

Cross Browser

Compatible with all modern browsers

File Structure

Project Overview

The project follows a modular structure with clear separation of concerns.

dreamsemr/
│
└── react/
    │
    ├── public/
    │   └── favicon.png
    │
    ├── src/
    │   ├── core/
    │   │   ├── common/
    │   │   ├── data/
    │   │   ├── json/
    │   │   └── redux/
    │   │
    │   ├── feature-module/
    │   │   ├── components/
    │   │   ├── feature-components/
    │   │   └── routes/
    │   │
    │   └── style/
    │       ├── css/
    │       ├── fonts/
    │       ├── icons/
    │       └── scss/
    │
    ├── package.json
    ├── package-lock.json
    ├── .eslintrc
    ├── index.html
    └── vite.config.ts

Utils Directory Structure

The src/utils/ directory contains reusable utility functions organized by category for easy maintenance and development. 

src/utils/
├── constants/              # Application constants and configuration
│   ├── api.ts             # API endpoints and configuration
│   └── app.ts             # App-wide constants and settings
├── formatters/             # Data formatting utilities
│   ├── currency.ts        # Currency formatting functions
│   └── phone.ts           # Phone number formatting utilities
├── helpers/                # Helper functions
│   ├── date.ts            # Date manipulation and formatting
│   └── string.ts          # String manipulation utilities
├── storage/                # Storage utilities
│   ├── localStorage.ts    # LocalStorage wrapper with expiration
│   └── sessionStorage.ts  # SessionStorage wrapper with expiration
├── validators/             # Validation functions
│   ├── email.ts           # Email validation utilities
│   └── password.ts        # Password validation with strength checking
└── index.ts                # Main export file for all utilities
Key Utility Categories:
Constants

API endpoints, app configuration, and global constants

Formatters

Data formatting for currency, phone numbers, and dates

Helpers

Common helper functions for dates, strings, and data manipulation

Storage

LocalStorage and SessionStorage wrappers with expiration support

Validators

Input validation for emails, passwords, and form data

Index Export

Centralized exports for easy importing across the application

Usage Examples:
// Import utilities from the main index
import { formatCurrency, formatPhoneNumber, validatePassword } from '../utils';

// Or import from specific modules
import { API_ENDPOINTS } from '../utils/constants/api';
import { setSessionItem } from '../utils/storage/sessionStorage';

// Usage examples
const price = formatCurrency(1234.56, 'USD');        // $1,234.56
const phone = formatPhoneNumber('1234567890');       // (123) 456-7890
const { isValid, strength } = validatePassword('MyPass123!');
setSessionItem('userToken', token, 3600000);        // Expires in 1 hour

Installation Guide

Getting Started with Dreams EMR React Template
Prerequisites
  • Node.js (v18 or later recommended). Download Node.js
  • npm (comes with Node.js) or yarn/pnpm as alternative package managers.
  • Any modern web browser (Chrome, Firefox, Edge, Safari, etc.).
Extract the Template
  • After downloading, unzip the template package.
  • Navigate to Dreams EMR/react/ (the source code folder).
Install Dependencies
  • Open a terminal/command prompt in the React folder.
  • Run: 
    npm install
  • This will install all required packages (including TypeScript, Vite, React, etc.).
Start the Development Server
  • Run: 
    npm run dev
  • Open the local URL shown in your terminal (usually http://localhost:5173/).
  • Your app will reload automatically as you edit source files.
Build for Production
  • To create an optimized production build, run: 
    npm run build
  • The output will be in the dist/ folder, ready to deploy.
Install Additional Plugins
  • To add a new package (e.g., a chart library), run: 
    npm install package_name --save
  • Replace package_name with the actual npm package you want to add.
Tips:
  • If you see errors about missing Node.js or npm, install them from the official website above.
  • For Mac/Linux users, you may need to use sudo for global installs.
  • For Windows users, run your terminal as Administrator if you encounter permission issues.
  • Refer to the README.md in the project root for more usage and customization details.

How the React Project Works

This React project is designed for scalability, maintainability, and rapid development. Here's how the main features and flows work:

App Entry

The app starts from src/main.tsx, which sets up the root React component, Redux provider, and router.

State Management

Uses Redux Toolkit for global state (theme, sidebar, user, etc.), with typed hooks for safety and ease of use.

Theming & RTL

Theme settings (light/dark, layout, direction) are managed in Redux and synced to the <html> element.

Internationalization (i18n)

Multi-language support is provided by react-i18next. Languages and translations are managed in src/i18n.ts.

Routing

All routes are defined in src/routes/. The app uses React.lazy and Suspense for code-splitting.

Authentication

Full authentication flows (login, register, password reset, etc.) are implemented in src/pages/authentication/.

Dashboard & Widgets

The dashboard and widgets (charts, tables, stats) are in src/pages/pages/dashboard/.

UI Components

Reusable UI elements (sidebar, header, tables, etc.) are in src/components/ and styled with Bootstrap 5, Ant Design.

Utility System

Common utilities (formatters, validators, storage, helpers) are organized in src/utils/ for easy reuse across components.

Modular Design: The project is modular, so you can easily add new pages, features, or languages as your app grows.
Important Note on Import Paths:

When working with lazy-loaded components in src/routes/router.link.tsx, use these correct import paths:

  • Feature pages: ../pages/pages/[feature-name]/[component]
  • Authentication: ../pages/authentication/[auth-component]
  • Components: ../components/[component-name]/[component]

Example: ../pages/pages/dashboard/dashboard for the dashboard component.

How to change Font ?

You can change the font in your React project by following these detailed steps:

  1. Choose a Font:
    • Visit Google Fonts or another font provider and select your desired font (e.g., Inter, Roboto, etc.).
  2. Add the Font Import to Your CSS:
    • Copy the @import statement provided by Google Fonts.
    • Paste it at the very top of your main CSS file (e.g., src/assets/css/style.css or src/assets/scss/main.scss):
    @import url('https://fonts.googleapis.com/css2?family=Inter:ital,opsz,wght@0,14..32,100..900;1,14..32,100..900&display=swap');
  3. Update the font-family in CSS:
    • In the same CSS file, set the font-family for the body (or a specific class/component):
    body {
  font-family: 'Inter', sans-serif;
}
  4. You can also target specific elements or classes if you want to use different fonts in different places.
  5. Save and Check Your App:
    • Save your CSS file and reload your app in the browser. The new font should be applied site-wide or wherever you specified.
Tips:
  • For best performance, only import the font weights/styles you actually use.
  • Keep your font imports in one place (usually your main CSS file).
  • Test your font on different browsers and devices for consistency.

How to change Layouts ?

Theme Settings in this React app let you customize the look and feel of the interface instantly. You can access the Theme Settings panel by clicking the settings (gear) icon, usually found in the top bar or sidebar of the app.

  • Where to find it: The Theme Settings panel is implemented as a React component called ThemeSettings (located at src/components/theme-settings/themeSettings.tsx). It can be opened from the UI by clicking the settings icon.
  • How it works: When you change a setting in the panel, it updates the app's Redux state and saves your preferences to localStorage. The app then updates the <html> element's attributes (like data-layout, data-sidebar, etc.), so the CSS can apply the correct styles immediately.

Available Layout Options:

  • default – Standard sidebar and topbar layout
  • mini – Collapsed sidebar for more content space
  • hoverview – Sidebar expands on hover
  • hidden – Sidebar is hidden
  • full-width – Content uses the full width of the screen

Sidebar Color Options:

  • light – Light sidebar
  • sidebar2 to sidebar7 – Various preset sidebar color themes
  • gradientsidebar1 to gradientsidebar7 – Gradient sidebar color themes

Topbar Color Options:

  • white – White topbar
  • topbar1 to topbar6 – Preset topbar color themes
  • gradienttopbar1 to gradienttopbar7 – Gradient topbar color themes

Theme Color Options:

  • primary (default)
  • secondary
  • orange
  • teal
  • purple
  • indigo
  • info

You can also switch between Light and Dark modes, adjust the content width (fluid or boxed), and set the text direction (ltr or rtl) from the same panel. All changes are applied instantly and saved for your next visit.

How to use Internationalization (i18n)?

Internationalization (i18n) in this React app allows you to support multiple languages and easily switch between them. This is useful for making your app accessible to a global audience.

  • Where to find it: The i18n setup is in src/i18n.ts and uses react-i18next and i18next libraries. Language switching is typically handled in the header or via a language selector component.
  • How it works: All translations are defined in src/i18n.ts. The app uses the useTranslation hook to access the t function for translating text. When you change the language, the UI updates instantly to reflect the selected language.

Supported Languages:

  • en – English (default)
  • de – German
  • fr – French
  • ar – Arabic (RTL)

How to add a new language:

  • Add your translations in src/i18n.ts under a new language key.
  • Update the language switcher (usually in the header) to include your new language.

You can use the useTranslation hook in your components to translate any text. Example: 

{`const { t } = useTranslation();
return 
{t('welcome_message')}
;`}

All language changes are instant and persistent for the user.

How to use RTL (Right-to-Left) Support?

RTL (Right-to-Left) support allows your app to display content for languages like Arabic or Hebrew. The layout and text direction automatically switch when a RTL language is selected.

  • How to enable: Select a RTL language (like ar) from the language switcher. The app will set dir="rtl" on the <html> element and update styles accordingly.
  • Where to find: RTL logic is handled in src/i18n.ts and the theme settings Redux slice. The UI will automatically adapt when dir is set to rtl.

No extra configuration is needed—just select a RTL language and the app will handle the rest.

Code Example:

// Change language to Arabic (RTL)
i18n.changeLanguage('ar');
// The app will automatically set

How to use Dark Mode?

Dark Mode lets users switch the app's appearance to a darker color scheme, which is easier on the eyes in low-light environments.

  • How to enable: Open the Theme Settings panel (settings icon) and select Dark mode. This sets data-bs-theme="dark" on the <html> element.
  • Where to find: Dark mode logic is handled in the ThemeSettings component and Redux theme slice. The CSS uses the data-bs-theme attribute to apply dark styles.

Your dark mode preference is saved and will be remembered next time you visit the app.

Code Example:

// Enable dark mode via ThemeSettings handler
handleUpdateTheme('data-bs-theme', 'dark');
// Or manually set attribute:
document.documentElement.setAttribute('data-bs-theme', 'dark');

How to use Lazy Routing?

Lazy Routing improves performance by loading route components only when they are needed, reducing the initial bundle size.

  • How it works: The app uses React.lazy and Suspense to load route components on demand. This is set up in the routing configuration (usually in src/routes/).
  • How to add a lazy route: Import your component with React.lazy(() => import('./MyComponent')) and wrap your routes with <Suspense fallback={...}>.

Lazy loading routes helps your app load faster and improves the user experience, especially for large projects.

Code Example:

import React, { Suspense, lazy } from 'react';

const MyComponent = lazy(() => import('./MyComponent'));
											
// In your router:
<Suspense fallback={<div>Loading...</div>}>
<Route path="/component" element={<MyComponent />} />
</Suspense>

Credits

NAME URL
React https://react.dev/
Vite https://vitejs.dev/
TypeScript https://www.typescriptlang.org/
Redux Toolkit https://redux-toolkit.js.org/
Ant Design https://ant.design/
Bootstrap 5 https://getbootstrap.com/
Chart.js https://www.chartjs.org/
ApexCharts https://apexcharts.com/
Google Fonts https://fonts.google.com/
FontAwesome https://fontawesome.com/

Support

Need Support?

If this documentation does not address your questions, please feel free to contact us via email at support@dreamstechnologies.com

Reach the team at GMT+5:30. Typical reply within 12–24 hours on weekdays — rarely up to 48 hrs during holidays. Support is available to verified buyers for template-related issues.

Contact Support

Important Note : We strive to offer top-notch support, but it's only available to verified buyers and for template-related issues such as bugs and errors. Custom changes and third-party module setups are not covered.

Custom Work

Do you need a customized application for your business?

If you need a customized application for your business depends on your specific requirements and goals, Please contact us. Customization can be the key to success, ensuring your project perfectly aligns with your unique goals and requirements.

Don't Miss Out on the Benefits of Customization!

Unlock the potential of your project. It's time to ensure your project isn't another cookie-cutter solution but truly unique and effective one.

Discover how customization can make a difference in your project's success. Let's create a solution that's as unique as your vision!

We'll tailor the application to meet your specific needs and preferences.

We will upload your website to the server and ensure it is live.

Book an Appointment Get a Free Quote
thanks

Thank You

Thank you once again for downloading Dreams EMR.
We hope you're enjoying your experience, and we kindly request that you take a moment to share your valuable review and rating with us.

Review Link