Luxelooks

Salon Management Dashboard for

Introduction

Product Name:

LuxeLooks

Overview:

LuxeLooks is a comprehensive salon management dashboard designed to streamline operations for salons, spas, and beauty centers. It offers intuitive tools for appointment scheduling, client management, and service management, ensuring smooth and efficient business operations.

Key Features:

  • Appointment Management: Easily schedule, modify, and track client appointments.
  • Employee Management: Manage staff schedules, roles, and performance.
  • Gallery: Showcase your salon's work and styles with an integrated gallery.
  • Client Management: Maintain detailed client profiles and history for personalized services.
  • Offers and Promotions: Create and manage promotional offers to attract new clients.
  • Service Management: Organize and update your list of services, including treatments and pricing.
  • Reviews and Feedback: Collect and manage customer reviews to improve your services.
  • Stock Management: Keep track of salon supplies and manage inventory efficiently.
  • Settings: Customize the dashboard settings for your salon’s specific needs.

Target Audience:

LuxeLooks is ideal for salon owners, spa centers, hair stylists, and beauty professionals looking to enhance their business efficiency and improve client satisfaction through a streamlined dashboard solution.

Demo Link:

Explore the demo of LuxeLooks here.

Email: Sh981572@gmail.com

Password: LuxeLooks123

Getting Started

Installation Requirements

Before you can install and run the LuxeLooks dashboard, make sure you have the following installed on your system:

  • Node.js (v14 or higher)
  • npm or yarn (for managing frontend and backend dependencies)
  • Express.js (for the backend framework)
  • MongoDB (as the database)

Installation Guide

Follow these steps to install the LuxeLooks dashboard for both frontend and backend using the provided zip folders:

Frontend (client) Installation

  1. Download and extract the client zip folder to your local machine.
  2. Navigate into the extracted client folder:
    cd client
  3. Install the required dependencies (since node_modules is not included, you must run):
    npm install

Backend (server) Installation (Express.js and MongoDB)

  1. Download and extract the server zip folder to your local machine.
  2. Navigate into the extracted server folder:
    cd server
  3. Install backend dependencies (again, node_modules is not included, so you must run):
    npm install
  4. Ensure MongoDB is running locally or use a cloud-based MongoDB connection.

Basic Configuration

Before running the application, you need to configure both the frontend and backend:

Frontend (client) Configuration

Create a `.env` file in the root of your frontend directory with the following settings:


          NEXT_PUBLIC_FIREBASE_API_KEY=""
          NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN=""
          NEXT_PUBLIC_FIREBASE_PROJECT_ID=""
          NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET=""
          NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID=""
          NEXT_PUBLIC_FIREBASE_APP_ID=""
          NEXT_PUBLIC_FIREBASE_MEASUREMENT_ID=""
          
          # NEXT_PUBLIC_API_URL= # optional: replace with your server URL
          NEXT_PUBLIC_NODE_ENV=development
          
          NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=""
                

Backend (server) Configuration (Express.js)

Create a `.env` file in the root of your backend directory with the following settings:


          MONGODB_URI=""
          EMAIL=""
          PASSWORD=""
          PORT=3000
          HOST=0.0.0.0
          SMTP_HOST=smtp-mail.outlook.com
          SMTP_PORT=587
          FIREBASE_SERVICE_ACCOUNT="./src/config/serviceAccount.json"
          
          NODE_ENV=production
          
          JWT_SECRET=""
          
          ALLOWED_ORIGIN=http://localhost:3000
          
          STRIPE_SECRET_KEY=""
          STRIPE_WEBHOOK_SECRET=""
                

Running the Dashboard

Frontend (client)

To run the frontend part of the LuxeLooks dashboard, use the following command:

npm run dev

This will start the frontend development server at http://localhost:3000.

Backend (server - Express.js)

To run the backend Express server, use the following command:

npm run dev

The backend server will run on http://localhost:3000 (configured in your `.env` file). Ensure MongoDB is running and the database connection is properly configured.

Accessing the Dashboard

Once both frontend and backend are running, open your browser and go to:

http://localhost:3000

Log in using your credentials to start managing your salon with LuxeLooks!

Template Overview

Layout and Structure

Frontend Layout Structure

The LuxeLooks dashboard is designed specifically for large screens, optimized for desktops and tablets above 768px. The layout and structure provide an organized, user-friendly interface for managing salon operations. Key features include:

  • Responsive grid layout with multi-column sections to present data efficiently.
  • Side navigation bar with easy access to key sections like appointments, employees, clients, and more.
  • Top header with integrated search, user profile, and notifications.
  • Content areas for displaying business metrics, charts, and appointment lists in a visually appealing format.

Backend Layout Structure

Responsive Design (Above 768px)

The dashboard is optimized for tablets and desktops, providing the best user experience on larger screens. Key responsive design features include:

  • Fluid layout that adjusts to different screen resolutions to ensure optimal display on tablets and desktops.
  • Fixed side menu and top bar for consistent navigation across all pages.
  • Efficient use of space with sections dedicated to key business operations, such as employee management and stock control.
  • Support for different screen sizes, ensuring that important information is accessible and readable.

Navigation Structure

The navigation structure is designed for ease of use, providing quick access to all sections of the dashboard. Key features include:

  • Vertical sidebar navigation with collapsible menu options for a clean and uncluttered layout.
  • Sticky top bar for easy access to user account settings, notifications, and quick actions like logging out.
  • Clear and intuitive icons alongside menu items for easy navigation.
  • Fast access to frequently used sections, such as client management, appointment scheduling, and stock management.

Customizability

The LuxeLooks dashboard is designed to be easily customizable to fit your salon's branding and operational needs. Customizability features include:

  • Ability to customize the **color scheme** and **branding** (e.g., uploading a company logo and adjusting the color palette).
  • Options to **toggle or hide sections** such as charts, activity logs, or notifications, depending on your preferences.
  • CSS customization for deeper changes to the layout and design.
  • Well-commented code that makes it easy for developers to implement additional customizations and features.
  • Support for multiple theme options to match your company branding and style.

Mobile Phone Integration

Step-by-Step Guide for Expo Template Integration with Backend

1. Extract the Zip Folder

Extract the provided zip folder that contains the Expo template using a file extraction tool like WinRAR or 7-Zip. The folder will contain all the necessary files to set up your mobile app.

2. Install Node.js and Expo CLI

Ensure Node.js is installed from nodejs.org. Once Node.js is installed, install Expo CLI globally:

npm install -g expo-cli

3. Initialize the Expo Project

Open your terminal, navigate to the extracted folder, and run the following commands to start the project:

cd path_to_extracted_folder
    expo start

After starting, you’ll see a QR code to scan with your mobile device.

4. Run the App on Your Mobile Phone

Download the Expo Go app from the Google Play Store or the Apple App Store. Scan the QR code shown in the terminal to preview the app.

5. Connecting to an Existing Backend

To connect the Expo template with your existing backend (built using Express.js, Node.js, etc.), follow these steps:

5.1. Set Up API Endpoints

Ensure your backend is hosted and accessible via an API. For local development, use tools like ngrok to expose your local server to the internet.

// Example: Exposing your local backend server via ngrok
    ngrok http 3000
5.2. Configure the API Base URL

In your Expo project, locate the file where API requests are handled (typically in a `services` or `api` folder) and update the base URL to point to your backend. For example, in api.js:

const API_BASE_URL = 'https://your-backend-url.com/api';

If you're using Axios for API calls, configure the base URL as follows:

import axios from 'axios';
    
    const api = axios.create({
      baseURL: 'https://your-backend-url.com/api',
    });
    
    export default api;
5.3. Test the API Connection

Make sure the mobile app can successfully communicate with your backend. You can add a simple test request to ensure everything works:

useEffect(() => {
      api.get('/test-endpoint')
        .then(response => console.log('Backend Response:', response))
        .catch(error => console.error('API Error:', error));
    }, []);

6. Customizing the App

Once the app is running and connected to the backend, you can start customizing it by opening the project folder in a code editor like Visual Studio Code. You can edit files like App.js, located in the root folder, and other components in the components directory.

cd path_to_project
    code .

7. Additional Features

To integrate additional features, such as push notifications, camera, or location services, you can use Expo modules:

  • expo install expo-notifications – For push notifications.
  • expo install expo-camera – For camera functionality.
  • expo install expo-location – For accessing location services.

8. Build and Deploy

Once customization is complete, you can build the app for Android and iOS by running the following commands:

expo build:android
    expo build:ios

For more detailed instructions, visit Expo's official documentation.

UI Components & Modules

1. Dashboard Components

The dashboard components include various interactive UI elements such as charts, tables, and overview panels that you can use to display key metrics of your salon.

  • Charts: Display important salon statistics (appointments, revenue, clients) using responsive chart libraries like Chart.js or Recharts.
  • Tables: Display and manage data such as appointments, services, and client details using responsive tables.
  • Overview Panels: Use these panels to give quick insights into key data points like active appointments or service statistics.

2. Forms and Inputs

Forms are essential for interacting with the application and collecting user data. Below are some common forms and inputs:

  • Appointment Forms: Customize forms for booking, modifying, or canceling appointments.
  • Service Forms: Add forms to create, update, and remove salon services.
  • Client Forms: Use these for adding or editing client details.
  • Form Validation: Utilize form validation libraries like Formik or react-hook-form to ensure proper input validation.

3. Modal and Popup Modules

Modals are useful for displaying additional information or confirming user actions.

  • Confirmation Modals: Use these to confirm user actions like deleting an appointment or service.
  • Information Modals: Display detailed information or alerts, such as a success message after submitting a form.

4. Notifications and Alerts

Notify users of important actions or system messages using notification modules:

  • Toast Notifications: These are small, non-intrusive notifications for actions such as appointment confirmations or errors.
  • Alert Boxes: Display critical alerts, like service errors or session timeouts.

5. Customizable Themes and Layouts

The LuxeLooks template comes with a flexible theme that can be easily customized. You can adjust the theme colors, fonts, and layout settings through SCSS variables.

  • Color Scheme: Modify primary, secondary, and background colors to fit your brand.
  • Typography: Adjust font-family and font-size properties for different sections.
  • Layout Adjustments: Customize the layout of the sidebar, header, or main content sections.

6. Data Tables and Pagination

For displaying large sets of data, use responsive data tables with pagination and filtering options.

  • Client Data Table: Display and manage client data with search and filter capabilities.
  • Appointment Table: List appointments with options to edit, delete, or view details.
  • Pagination: Use pagination to display long lists of data in a more manageable way.

7. Charts and Data Visualization

Data visualization components are key for displaying actionable insights in a visually appealing way. Here's what you can use:

  • Bar Charts: For showing appointment counts, revenue by month, etc.
  • Pie Charts: To visualize service distribution, customer demographics, or appointment types.
  • Line Charts: For tracking trends over time, like client visits or sales performance.

8. Custom Components for Reports and Analytics

Customize and generate different types of reports directly from the dashboard:

  • Service Report: Track service popularity and revenue generation.
  • Employee Report: Track employee performance based on appointments and client feedback.
  • Client Reports: Generate reports on client visits, preferences, and history.

API Integration Guide

Overview

This section provides an overview of the various API routes available in the application. The routes are divided into two categories: Public Routes and Protected Routes.

Authentication Setup

The application uses JSON Web Tokens (JWT) for authenticating users. Below is the setup process for authentication:

  • Login API: Users can log in using their credentials. After successful login, they will receive a JWT token.
    POST /auth/login
    Example Request:
        {
          "email": "user@example.com",
          "password": "password123"
        }
                  
  • Set Token in Cookies: After login, the server will return the JWT in the response. It should be saved as a cookie or in local storage on the client side.
    POST /auth/set-token
  • Token Verification: For protected routes, the server will verify the JWT token sent in the request header (Authorization: Bearer ).
    GET /auth/check-token

Error Handling

Our API uses standard HTTP status codes to indicate the success or failure of a request. Here are the most common error statuses:

  • 400 Bad Request: The server cannot process the request due to invalid syntax. This usually occurs when required parameters are missing or incorrectly formatted.
  • 401 Unauthorized: The request lacks valid authentication credentials. This occurs when the token is missing or expired.
  • 403 Forbidden: The server understood the request, but the client does not have permission to perform the operation (usually due to insufficient user roles).
  • 404 Not Found: The requested resource could not be found on the server.
  • 500 Internal Server Error: Something went wrong on the server. This is a general error message for unexpected issues.

For all API requests, errors are returned in the following format:

    {
      "status": "error",
      "message": "Error description here",
      "code": 
    }
          

Public Routes

These routes do not require authentication and can be accessed freely.

  • /otp/send-otp: POST - Send OTP for verification
  • /otp/verify-otp: POST - Verify the OTP for login/registration
  • /auth/set-token: POST - Set the authentication token cookie
  • /auth/signup: POST - Create a new user account
  • /auth/login: POST - Login to the system
  • /auth/logout: POST - Logout from the system
  • /auth/check-token: GET - Check if the token is valid
  • /auth/get-user-details/:uid: GET - Retrieve details of a user by UID

Protected Routes

These routes require authentication, and users must be logged in to access them. The authentication token must be sent as a Bearer token in the Authorization header.

Appointment Routes

  • /appointments: GET - List appointments, POST - Add a new appointment
  • /appointments/:id: PATCH - Update an appointment
  • /appointments/soft-delete/:id: PATCH - Soft delete an appointment
  • /appointments/count: GET - Get appointment count
  • /appointments/count/gender: GET - Get appointment count by gender
  • /appointments/employee/:employeeId: GET - Get appointments by employee
  • /appointments/client/:clientId: GET - Get appointments by client

Service Routes

  • /services: GET - List services, POST - Add a new service
  • /services/count: GET - Get count of services
  • /services/:id: PATCH - Update a service
  • /services/soft-delete/:id: PATCH - Soft delete a service

Employee Routes

  • /employees: GET - List employees, POST - Add a new employee
  • /employees/service: GET - List employees based on service
  • /employees/:id: PATCH - Update employee details
  • /employees/soft-delete/:id: PATCH - Soft delete an employee

Client Routes

  • /clients: GET - List clients, POST - Add a new client
  • /clients/count: GET - Get count of non-trashed clients
  • /clients/:id: PATCH - Soft delete a client

Stock Routes

  • /stocks/addStock: POST - Add new stock
  • /stocks/listStocks: GET - List all stocks
  • /stocks/expired: GET - List expired stocks
  • /stocks/soft-delete/:id: PATCH - Soft delete a stock

Supplier Routes

  • /suppliers: GET - List suppliers, POST - Add a new supplier
  • /suppliers/brand/:brandId: GET - List suppliers based on brand
  • /suppliers/soft-delete/:id: PATCH - Soft delete a supplier

Brand Routes

  • /brands: GET - List brands, POST - Add a new brand
  • /brands/soft-delete/:id: PATCH - Soft delete a brand

Offer Routes

  • /offers: GET - List offers, POST - Add a new offer
  • /offers/soft-delete/:id: PATCH - Soft delete an offer
  • /offers/:id: PATCH - Update an offer

Review Routes

  • /review: GET - List reviews, POST - Add a new review

Order Routes

  • /order/draft: POST - Create a new draft order
  • /order: GET - List orders
  • /order/:id/paid: PATCH - Finalize an order as paid

Notification Routes

  • /notifications: GET - List notifications
  • /notifications/read: PATCH - Update read status of notifications

Stripe Routes

  • /payment/create-payment-intent: POST - Create a payment intent
  • /payment/webhook: POST - Handle Stripe webhook events

User Roles and Permissions

LuxeLooks Dashboard is designed to be managed by a single Admin. The admin role has complete access to all features and functionalities within the dashboard. This includes:

  • Managing salon appointments and schedules.
  • Handling employee data and roles.
  • Managing services and pricing.
  • Accessing financial reports and analytics.
  • Setting up and managing payment integrations.
  • Customizing dashboard settings and preferences.

Since this dashboard only supports one admin, there are no additional user roles or restricted permissions at this time. The admin is responsible for all aspects of managing and maintaining the platform.

Customization Guide

1. Customizing the Color Scheme

The color scheme of the LuxeLooks template can be adjusted to match your salon's branding. Here's how to modify it in a Next.js project:

  • Open the app/globals.scss
  • Search for the CSS variables like --primary-color, --secondary-color, and others in the SCSS file.
  • Update these variables with your desired color values. For example, change:
  • :root { --primary-color: #3498db; }
  • Once updated, the changes will be reflected on the frontend immediately after saving the file.

2. Adding Your Salon Logo

To replace the logo of the salon in the dashboard:

  • Locate the logo component typically in components/Sidebar.jsx .
  • Replace the existing logo with your own logo image, either in the public directory or by using an image URL:
  • <img src="/images/your-logo.png" alt="Salon Logo" />

3. Customizing the Sidebar Menu

To modify the sidebar, which includes links to different sections like appointments, services, and employees:

  • Open the components/Sidebar.jsx file.
  • Modify the existing links or add new ones in the sidebar menu:
  • <Link href="/new-page">New Page</Link>
  • Reorder items by changing the position of the Link components in the JSX structure.

4. Customizing the Fonts and Typography

To change the fonts across the dashboard in Next.js:

  • Open the app/_layout.js file and add Google Fonts or any other font import in the <Head> tag:
  • <link href="https://fonts.googleapis.com/css2?family=Roboto&display=swap" rel="stylesheet">
  • Update the font-family in styles/globals.scss:
  • body { font-family: 'Roboto', sans-serif; }

5. Modifying the Dashboard Layout

If you want to change the layout of the dashboard, such as resizing or reordering sections:

  • Look into components/Layout.jsx or pages/dashboard.jsx (or wherever your dashboard layout is defined).
  • Update the JSX structure to modify the layout. For example, if you want to reorder the sidebar or content section:
  • <div className="sidebar"></div>
  • Use Flexbox or CSS Grid to customize the layout:
  • .dashboard { display: flex; }

6. Adding New Functionalities or Pages

To add new pages (e.g., a service history page or client reports):

  • Create a new page under the pages directory, such as pages/service-history.jsx.
  • Define the page structure and content within the new file.
  • To make the page accessible from the sidebar, add a new link in components/Sidebar.jsx:
  • <Link href="/service-history">Service History</Link>

7. Updating or Integrating APIs

Next.js is great for integrating APIs. If the dashboard needs to fetch data from a different API, here’s what you can do:

  • Use getServerSideProps or getStaticProps to fetch data from an external API in your pages. For example:
  • export async function getServerSideProps(context) {
                  const res = await fetch('https://api.example.com/data');
                  const data = await res.json();
                  return { props: { data } };
                }
  • On the frontend, make API requests using fetch or a library like Axios to integrate dynamic data into your components.
  • Update your API routes in pages/api if you need to handle backend logic for the API.

8. Testing and Deployment

Before finalizing your customizations, it’s essential to test the template:

  • Test the responsiveness of the template across devices (desktop, tablet, and mobile).
  • Check all functionality (e.g., login, appointments, payment processing) to ensure they work properly.
  • Once you're satisfied with your changes, deploy the Next.js application to a hosting provider. You can use services like Vercel or Netlify.
  • Make sure to update the .env.local file for any environment variables like API keys, database credentials, etc.

Deployment Guide

To deploy LuxeLooks for use in a live environment, you can use various hosting platforms. Below are the steps for deploying the application and some guidance on bandwidth requirements and hosting plans.

Steps to Deploy LuxeLooks

  1. Ensure your project is set up correctly for production with necessary environment variables defined in the .env file.
  2. Build your Next.js frontend by running the following command:
    npm run build
  3. Deploy your backend (Express.js) to a hosting platform such as Heroku or any other cloud provider.
  4. Deploy the frontend (Next.js) on platforms like Vercel, which offers seamless integration with Next.js projects.

Hosting Provider Recommendations

For web hosting, you can choose a provider based on your expected traffic and bandwidth requirements. Below is an overview of what to consider:

1. Small Scale Usage (Up to 5,000 Monthly Visitors)

2. Medium Scale Usage (5,000 - 50,000 Monthly Visitors)

3. Large Scale Usage (50,000+ Monthly Visitors)

Heroku Example

Here's an example of how you can deploy the LuxeLooks backend using Heroku:

  1. Sign up at Heroku and create a new project.
  2. Install the Heroku CLI and log in:
    heroku login
  3. Initialize a new Git repository (if you haven't already):
    git init
  4. Push your code to Heroku:
    
        heroku git:remote -a your-app-name
        git add .
        git commit -m "Deploying LuxeLooks"
        git push heroku master
                  
  5. Set up environment variables (API keys, database credentials) in the Heroku dashboard under the "Settings" tab.
  6. Open your deployed application by running:
    heroku open

Other Hosting Providers

If you prefer to use other hosting platforms, here are some alternatives:

  • Amazon Web Services (AWS) - Use EC2 for the backend and S3 for static asset hosting.
  • Google Cloud - Deploy using Google App Engine for scalable infrastructure.
  • DigitalOcean - Affordable cloud hosting starting at $5/month for small to medium-scale applications.

Troubleshooting and FAQ

LuxeLooks is a comprehensive salon management dashboard built using Next.js. It provides a range of features, including appointment scheduling, employee management, gallery displays, client records, service offerings, and much more. It is designed to streamline salon operations efficiently.

LuxeLooks is available for purchase on CodeCanyon. This platform allows you to securely buy and download the application for immediate use.

All sales of LuxeLooks are final. We do not offer refunds or exchanges once the product has been purchased. If you encounter any technical issues or have questions, please contact our support team, and we will assist you to the best of our abilities.

There are two types of licenses available for LuxeLooks:
  • Regular License: This license allows you or one client to use LuxeLooks in a single end product where access is free and no subscription fees are charged. You can’t sell the end product, except to one client. If you or your client want to sell the end product or charge for its use, you will need the Extended License. For more details, visit: Regular License Details.
  • Extended License: This license allows you or one client to create an end product that users can be charged for (such as subscription-based access or selling the application). It covers one single end product and allows for the end product to be sold. For more details, visit: Extended License Details.

If you're experiencing any issues with LuxeLooks, please reach out to our support team via email at codeforge0@gmail.com. Our team is available from Monday to Friday, 9:00 AM to 6:00 PM IST, and will respond to your query within 12 to 24 hours.

Yes, LuxeLooks is highly customizable. You can modify the dashboard’s UI and extend its features according to your salon's specific needs. Detailed documentation is provided to guide you through the setup and customization process.

After purchasing LuxeLooks from CodeCanyon, you will receive a download link for the zip folder. Follow the installation guide in the documentation to set up both the frontend (Next.js) and backend (Express.js with MongoDB) environments.

Support and Updates

Contact Us

For more information or technical support, please don’t hesitate to contact us via codeforge0@gmail.com. Our dedicated team is here to help you every step of the way in deploying your application.

Support Availability

We are available to assist you from Monday to Friday, 9:00 AM to 6:00 PM IST. You can expect a response to your queries within 12 to 24 hours during our working days.

Note: We observe weekends off, so Saturday and Sunday are non-working days. We appreciate your understanding and look forward to assisting you promptly during business hours.

Appendix

Glossary

  • Next.js: A React framework that enables server-side rendering and static website generation for building modern web applications.
  • Express.js: A web application framework for Node.js, used for building REST APIs and server-side applications.
  • MongoDB: A NoSQL database that stores data in JSON-like documents, making it scalable and flexible.
  • Firebase: A platform developed by Google that offers backend services like authentication, real-time databases, and cloud storage.
  • npm: Node Package Manager, a tool used for managing JavaScript packages and dependencies.
  • Stripe: An online payment processing platform that allows businesses to accept payments over the internet.
  • Middleware: A function in Express.js that processes requests between the client and server before reaching the controller, often used for authentication, logging, or error handling.
  • Controller: A part of the backend that handles business logic by receiving requests, interacting with the model, and sending the appropriate response to the client.
  • Model: Represents the data structure or schema in the application, often linked with a database (e.g., MongoDB) to handle data storage, retrieval, and manipulation.
  • Environment Variables (.env): A file where sensitive configuration settings like API keys and database credentials are stored.
  • License: A legal agreement granting the buyer the rights to use, modify, and distribute software under specific terms.

Release History

  • v1.0.0: Initial release of LuxeLooks. Features include salon management, appointment scheduling, and basic dashboard functionalities.
Thank you for purchasing the LuxeLooks salon dashboard template. We truly appreciate your support and hope this template helps streamline your business operations. If you have any questions or need assistance, feel free to reach out to us. Your success is our priority!