replace

update readme file

.env

@@ -4,7 +4,7 @@
 FLASK_ENV=development
 FLASK_DEBUG=True
 FLASK_HOST=0.0.0.0
-FLASK_PORT=5011
+FLASK_PORT=5015
 
 # -----------------------------
 # Security
@@ -23,17 +23,15 @@ DB_USER=root
 DB_PASSWORD=root
 
 # DATABASE_URL=mysql+pymysql://root:root@localhost/comparisondb
-# -----------------------------
-# LDAP Configuration
-# -----------------------------
-USE_LDAP_AUTH=true
 
-LDAP_URL=ldap://192.168.0.25:389
+
-LDAP_BIND_DN=cn=admin,dc=lcepl,dc=org
+# -----------------------------
-LDAP_BIND_PASSWORD=Lcepl1950@2026
+# LDAP Configuration new
-LDAP_BASE_DN=dc=lcepl,dc=org
+# -----------------------------
+LDAP_SERVER=ldap://host.docker.internal
+LDAP_PORT=389
+LDAP_USE_SSL=False
+
 LDAP_DOMAIN=lcepl.org
-
+LDAP_BASE_DN=DC=lcepl,DC=org
-# OpenLDAP standard username attribute
+LDAP_SEARCH_BASE=OU=Users,DC=lcepl,DC=org
-LDAP_SEARCH_FILTER=(uid={username})
-

Dockerfile

@@ -5,23 +5,20 @@ WORKDIR /app
 # Install system dependencies
 RUN apt-get update && apt-get install -y \
     gcc \
-    default-libmysqlclient-dev \
-    pkg-config \
     && rm -rf /var/lib/apt/lists/*
 
 # Copy requirements and install Python dependencies
 COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt gunicorn
+RUN pip install --no-cache-dir -r requirements.txt
 
 # Copy application code
 COPY . .
 
 # Create necessary directories
 RUN mkdir -p app/logs app/static/uploads app/static/downloads
-ENV FLASK_APP=run.py
 
 # Expose port
 EXPOSE 5001
 
-# Run the application with Gunicorn (production WSGI server)
+# Run the application
-CMD ["gunicorn", "--bind", "0.0.0.0:5001", "run:app"]
+CMD ["python", "run.py"]

README.md

@@ -36,7 +36,8 @@ The Comparison Project is designed to:
 
 ## Tech Stack
 
-**Backend Framework**: Flask  
+**Frontend Framework**: HTML, CSS, Js, Bootstrap  
+**Backend Framework**: Python Flask  
 **Database**: SQL Database (MySQL/PostgreSQL/SQLite configured via environment variables)  
 **ORM**: SQLAlchemy  
 **File Processing**: Pandas, OpenPyXL, XlsxWriter  
@@ -580,4 +581,4 @@ Open browser: `http://127.0.0.1:5000/`
 
 For issues, feature requests, or contributions, please contact the development team.
 
-**Last Updated:** January 2026
+**Last Updated:** April 2026

app/__init__.py

@@ -1,6 +1,6 @@
 from flask import Flask, redirect, url_for
 from app.config import Config
-from app.services.db_service import db, migrate
+from app.services.db_service import db
 from app.services.logger_service import LoggerService
 
 def create_app():
@@ -9,9 +9,6 @@ def create_app():
 
     # Initialize extensions
     db.init_app(app)
-    migrate.init_app(app, db)
-    with app.app_context():
-        db.create_all()
 
     # Initialize Logger
     LoggerService.init_app(app)
@@ -38,7 +35,10 @@ def register_blueprints(app):
     from app.routes.file_report import file_report_bp
     from app.routes.generate_comparison_report import generate_report_bp
     from app.routes.file_format import file_format_bp 
+
+    # new
     from app.routes.activity_routes import activity_bp
+    from app.routes.engineering_master_routes import engi_bp
 
     app.register_blueprint(auth_bp) 
     app.register_blueprint(user_bp)
@@ -48,7 +48,10 @@ def register_blueprints(app):
     app.register_blueprint(file_report_bp)
     app.register_blueprint(generate_report_bp)
     app.register_blueprint(file_format_bp)
+
+    # new
     app.register_blueprint(activity_bp)
+    app.register_blueprint(engi_bp)
     
 
 def register_error_handlers(app):

app/config.py

@@ -1,6 +1,4 @@
 import os
-# project base url
-BASE_DIR = os.path.abspath(os.path.dirname(__file__))
 
 class Config:
     # secret key
@@ -23,23 +21,14 @@ class Config:
     )
 
     SQLALCHEMY_TRACK_MODIFICATIONS = False
-    # uploads folder path
-    UPLOAD_FOLDER = os.path.join(BASE_DIR, "static", "uploads")
-    # file extension
-    ALLOWED_EXTENSIONS = {"xlsx", "xls", "csv"}
 
-    # ---------------- LDAP settings ----------------
+
-    USE_LDAP_AUTH = os.getenv("USE_LDAP_AUTH", "false").lower() == "true"
+    # LDAP Configuration New
-    # e.g. "ldap://192.168.0.25:389" or "ldaps://192.168.0.25:636" (preferred, encrypted)
+    LDAP_SERVER = os.getenv("LDAP_SERVER")
-    LDAP_SERVER = os.getenv("LDAP_URL", "ldap://192.168.0.25:389")
+    LDAP_PORT = int(os.getenv("LDAP_PORT", 389))
-    # Service/admin account used only to SEARCH for a user's real DN.
+    LDAP_USE_SSL = os.getenv("LDAP_USE_SSL", "False").lower() == "true"
-    # The user's own password is never used for this bind.
+
-    LDAP_BIND_DN = os.getenv("LDAP_BIND_DN", "cn=admin,dc=lcepl,dc=org")
+    LDAP_BASE_DN = os.getenv("LDAP_BASE_DN")
-    LDAP_BIND_PASSWORD = os.getenv("LDAP_BIND_PASSWORD", "")
+    LDAP_DOMAIN = os.getenv("LDAP_DOMAIN")
-    # Base DN to search for user entries under
+
-    LDAP_BASE_DN = os.getenv("LDAP_BASE_DN", "dc=lcepl,dc=org")
+    LDAP_SEARCH_BASE = os.getenv("LDAP_SEARCH_BASE")
-    # Used only as a fallback to build an email if the directory entry has none
-    LDAP_DOMAIN = os.getenv("LDAP_DOMAIN", "lcepl.org")
-    # Filter used to find the user's entry by their login username.
-    # Standard OpenLDAP attribute is "uid". Active Directory would use sAMAccountName.
-    LDAP_SEARCH_FILTER = os.getenv("LDAP_SEARCH_FILTER", "(uid={username})")

app/models/user_model.py

@@ -7,13 +7,10 @@ class User(db.Model):
     id = db.Column(db.Integer, primary_key=True)
     name = db.Column(db.String(200), nullable=False)
     email = db.Column(db.String(120), unique=True, nullable=False)
-    password_hash = db.Column(db.String(255), nullable=True)
+    password_hash = db.Column(db.String(255), nullable=False)
-    auth_source = db.Column(db.String(20), nullable=False, default="local")
 
     def set_password(self, password):
         self.password_hash = generate_password_hash(password)
 
     def check_password(self, password):
-        if not self.password_hash:
-            return False
         return check_password_hash(self.password_hash, password)

app/routes/auth.py

@@ -1,49 +1,98 @@
-from flask import Blueprint, render_template, request, redirect, url_for, flash, session
+from flask import (Blueprint, render_template, request, redirect, url_for, flash, session, current_app)
+
 from app.services.user_service import UserService
+from app.constants.messages import SuccessMessage, ErrorMessage
+from app.constants.http_status import HTTPStatus
 
 auth_bp = Blueprint("auth", __name__)
 
+
+# ==========================
+# LOGIN
+# ==========================
 @auth_bp.route("/login", methods=["GET", "POST"])
 def login():
+
     if session.get("user_id"):
+        current_app.logger.info("User already logged in.")
         return redirect(url_for("dashboard.dashboard"))
 
     if request.method == "POST":
-        email = request.form.get("email")
+
-        password = request.form.get("password")
+        try:
+            email = request.form.get("email", "").strip()
+            password = request.form.get("password", "")
+
+            if not email or not password:
+                flash(ErrorMessage.INVALID_REQUEST, "danger")
+                current_app.logger.warning("Login failed. Email or password missing.")
+                return render_template("login.html", title="Login")
 
             user = UserService.validate_login(email, password)
+
             if user:
+                session.clear()
                 session["user_id"] = user.id
                 session["user_name"] = user.name
-            session["user_email"] = user.email
+                session["email"] = user.email
-            flash("Login successful", "success")
+                session.permanent = True
+                
+                current_app.logger.info(f"Login successful. User={user.name}")
+                flash(SuccessMessage.LOGIN, "success")
                 return redirect(url_for("dashboard.dashboard"))
 
-        flash("Invalid email or password", "danger")
+            current_app.logger.warning(f"Invalid login attempt. Email={email}")
+            flash(ErrorMessage.LOGIN_FAILED,"danger")
+
+        except Exception as e:
+            current_app.logger.exception("Login Error" )
+            flash(ErrorMessage.INTERNAL_SERVER_ERROR,"danger")
 
     return render_template("login.html", title="Login")
 
 
+# ==========================
+# LOGOUT
+# ==========================
 @auth_bp.route("/logout")
 def logout():
+    username = session.get("user_name", "Unknown")
     session.clear()
-    flash("Logged out successfully", "info")
+    current_app.logger.info(f"Logout successful. User={username}")
+    flash(SuccessMessage.LOGOUT,"info")
+
     return redirect(url_for("auth.login"))
 
+
+# ==========================
+# REGISTER
+# ==========================
 @auth_bp.route("/register", methods=["GET", "POST"])
 def register():
-    if request.method == "POST":
-        name = request.form.get("name")
-        email = request.form.get("email")
-        password = request.form.get("password")
 
-        user = UserService.register_user(name, email, password)
+    if request.method == "POST":
-        if not user:
+        try:
-            flash("Email already exists", "danger")
+            name = request.form.get("name", "").strip()
+            email = request.form.get("email", "").strip()
+            password = request.form.get("password", "")
+
+            if not name or not email or not password:
+                flash(ErrorMessage.INVALID_REQUEST,"danger")
                 return redirect(url_for("auth.register"))
 
-        flash("User registered successfully", "success")
+            user = UserService.register_user(name, email, password)
+
+            if not user:
+                current_app.logger.warning(f"Duplicate Registration: {email}")
+                flash(ErrorMessage.DUPLICATE_ENTRY,"danger")
+                return redirect(url_for("auth.register"))
+
+            current_app.logger.info(f"New user registered: {email}")
+            flash(SuccessMessage.CREATED,"success")
             return redirect(url_for("auth.login"))
 
+        except Exception:
+            current_app.logger.exception("User Registration Failed" )
+            flash(ErrorMessage.INTERNAL_SERVER_ERROR,"danger")
+
     return render_template("register.html",title="Register")

app/services/ldap_service.py

@@ -1,72 +1,130 @@
+from ldap3 import (
+    Server,
+    Connection,
+    ALL,
+    NTLM,
+    SIMPLE,
+    SUBTREE
+)
+
 from flask import current_app
-from ldap3 import Server, Connection, ALL, SUBTREE
+from app.config import Config
-from ldap3.core.exceptions import LDAPException
 
 
 class LDAPService:
     """
-    Handles authentication against an LDAP / OpenLDAP server using the
+    LDAP / Active Directory Authentication Service
-    standard "search + bind" pattern:
-      1. Bind with a service/admin account just to SEARCH for the user's DN.
-      2. Re-bind using that DN + the password the user typed, to verify it.
-    The user's typed password is only ever used in step 2, never sent
-    anywhere else.
     """
 
     @staticmethod
     def authenticate(username, password):
+        """
+        Authenticate LDAP User
+
+        Returns:
+            {
+                "success": True,
+                "user": {
+                    "username": "...",
+                    "name": "...",
+                    "email": "..."
+                }
+            }
+
+        OR
+
+            {
+                "success": False,
+                "message": "Invalid username or password"
+            }
+        """
+
         if not username or not password:
-            return None
+            return {
+                "success": False,
+                "message": "Username and Password are required."
+            }
 
-        server = Server(current_app.config["LDAP_SERVER"], get_info=ALL)
-
-        # --- Step 1: bind as the admin/service account to search the directory ---
         try:
-            admin_conn = Connection(
+
-                server,
+            # -----------------------------------
-                user=current_app.config["LDAP_BIND_DN"],
+            # LDAP SERVER
-                password=current_app.config["LDAP_BIND_PASSWORD"],
+            # -----------------------------------
-                auto_bind=True,
+            server = Server(
+                Config.LDAP_SERVER,
+                port=Config.LDAP_PORT,
+                use_ssl=Config.LDAP_USE_SSL,
+                get_info=ALL
             )
-        except LDAPException as e:
-            current_app.logger.error(f"LDAP service account bind failed: {e}")
-            return None
 
-        # --- Step 2: find the user's real DN + profile attributes ---
+            # -----------------------------------
-        try:
+            # Login Format
-            search_filter = current_app.config["LDAP_SEARCH_FILTER"].format(username=username)
+            #
-            admin_conn.search(
+            # username@domain.com
-                search_base=current_app.config["LDAP_BASE_DN"],
+            # -----------------------------------
+            user_dn = f"{username}@{Config.LDAP_DOMAIN}"
+
+            conn = Connection(
+                server,
+                user=user_dn,
+                password=password,
+                authentication=SIMPLE,
+                auto_bind=True
+            )
+
+            # -----------------------------------
+            # Search User
+            # -----------------------------------
+            search_filter = f"(sAMAccountName={username})"
+
+            conn.search(
+                search_base=Config.LDAP_SEARCH_BASE,
                 search_filter=search_filter,
                 search_scope=SUBTREE,
-                attributes=["cn", "mail", "uid"],
+                attributes=[
+                    "displayName",
+                    "mail",
+                    "givenName",
+                    "sn",
+                    "cn"
+                ]
             )
-        except LDAPException as e:
-            current_app.logger.error(f"LDAP search failed for '{username}': {e}")
-            admin_conn.unbind()
-            return None
 
-        if not admin_conn.entries:
+            display_name = username
-            current_app.logger.warning(f"LDAP user not found: {username}")
+            email = ""
-            admin_conn.unbind()
-            return None
 
-        entry = admin_conn.entries[0]
+            if conn.entries:
-        user_dn = entry.entry_dn
+
-        name = str(entry.cn) if "cn" in entry and entry.cn.value else username
+                entry = conn.entries[0]
-        email = (
+
-            str(entry.mail)
+                if "displayName" in entry:
-            if "mail" in entry and entry.mail.value
+                    display_name = str(entry.displayName)
-            else f"{username}@{current_app.config['LDAP_DOMAIN']}"
+
+                if "mail" in entry:
+                    email = str(entry.mail)
+
+            conn.unbind()
+
+            current_app.logger.info(
+                f"LDAP Login Success : {username}"
             )
-        admin_conn.unbind()
 
-        # --- Step 3: the actual auth check - bind AS the user with their password ---
+            return {
-        try:
+                "success": True,
-            user_conn = Connection(server, user=user_dn, password=password, auto_bind=True)
+                "user": {
-            user_conn.unbind()
+                    "username": username,
-        except LDAPException as e:
+                    "name": display_name,
-            current_app.logger.warning(f"LDAP authentication failed for '{username}': {e}")
+                    "email": email
-            return None
+                }
+            }
 
-        return {"username": username, "name": name, "email": email}
+        except Exception as ex:
+
+            current_app.logger.warning(
+                f"LDAP Login Failed : {username} : {str(ex)}"
+            )
+
+            return {
+                "success": False,
+                "message": "Invalid Username or Password."
+            }

app/services/user_service.py

@@ -1,7 +1,6 @@
-from flask import current_app
 from app.models.user_model import User
 from app.services.db_service import db
-from app.services.ldap_service import LDAPService
+from flask import current_app
 
 class UserService:
 
@@ -10,57 +9,21 @@ class UserService:
         if User.query.filter_by(email=email).first():
             return None
 
-        user = User(name=name, email=email, auth_source="local")
+        user = User(name=name, email=email)
         user.set_password(password)
 
         db.session.add(user)
         db.session.commit()
+        current_app.logger.info("User list viewed")
         return user
 
     @staticmethod
-    def validate_login(identifier, password):
+    def validate_login(email, password):
-        """
+        user = User.query.filter_by(email=email).first()
-        identifier = whatever was typed in the login form. Can be an email
-        (local users) or an LDAP username, depending on USE_LDAP_AUTH.
-        """
-        if current_app.config.get("USE_LDAP_AUTH"):
-            ldap_user = UserService._validate_ldap_login(identifier, password)
-            if ldap_user:
-                return ldap_user
-            return None
-        user = User.query.filter_by(email=identifier).first()
         if user and user.check_password(password):
             return user
         return None
 
-    @staticmethod
-    def _validate_ldap_login(username, password):
-        ldap_info = LDAPService.authenticate(username, password)
-        if not ldap_info:
-            return None
-        return UserService._get_or_create_ldap_user(ldap_info)
-
-    @staticmethod
-    def _get_or_create_ldap_user(ldap_info):
-        """
-        LDAP is the source of truth for the password. We still keep a row in
-        our local `users` table (no password) so the rest of the app - which
-        expects a User with an id - keeps working unchanged.
-        """
-        user = User.query.filter_by(email=ldap_info["email"]).first()
-        if user is None:
-            user = User(
-                name=ldap_info["name"],
-                email=ldap_info["email"],
-                auth_source="ldap",
-            )
-            db.session.add(user)
-            db.session.commit()
-        elif user.name != ldap_info["name"]:
-            user.name = ldap_info["name"]
-            db.session.commit()
-        return user
-
     @staticmethod
     def get_all_users():
         return User.query.all()

app/templates/client_report.html

@@ -31,6 +31,24 @@
                     type="button">Tr.Ex </button>
             </li>
             <li class="nav-item">
+<<<<<<< HEAD
+                <button class="nav-link" id="mh-tab" data-bs-toggle="tab" data-bs-target="#mh" type="button">Mh.Ex
+                    </button>
+            </li>
+            <li class="nav-item">
+                <button class="nav-link" id="dc-tab" data-bs-toggle="tab" data-bs-target="#dc" type="button">MH & DC
+                    </button>
+            </li>
+            <li class="nav-item">
+<<<<<<< HEAD
+                <button class="nav-link" id="laying-tab" data-bs-toggle="tab" data-bs-target="#laying"
+                    type="button">Laying
+                    & Bedding Comparison</button>
+=======
+                <button class="nav-link" id="laying-tab" data-bs-toggle="tab" data-bs-target="#laying" type="button">Laying
+                    & Bedding </button>
+>>>>>>> 1dceb640bd930c37888799f10f02fe90b219be67
+=======
                 <button class="nav-link" id="mh-tab" data-bs-toggle="tab" data-bs-target="#mh" type="button">
                     Mh.Ex</button>
             </li>
@@ -41,6 +59,7 @@
             <li class="nav-item">
                 <button class="nav-link" id="laying-tab" data-bs-toggle="tab" data-bs-target="#laying"type="button">
                     Laying & Bedding </button>
+>>>>>>> pankaj-dev
         </ul>
 
         <div class="tab-content mt-3" id="reportTabsContent">

docker-compose.yml

@@ -17,11 +17,9 @@ services:
     build: .
     container_name: comparison_app
     restart: always
-    env_file:
-      - .env
     environment:
-      FLASK_ENV: production
+      FLASK_ENV: development
-      FLASK_DEBUG: "False"
+      FLASK_DEBUG: "True"
       FLASK_HOST: "0.0.0.0"
       FLASK_PORT: "5001"
 

logs/app.log

@@ -0,0 +1,3 @@
+2026-08-06 12:44:45 | INFO     | User=System | IP=- | - | - | ======================================================================
+2026-08-06 12:44:45 | INFO     | User=System | IP=- | - | - | Application Started Successfully
+2026-08-06 12:44:45 | INFO     | User=System | IP=- | - | - | ======================================================================

requirements.txt

@@ -1,5 +1,4 @@
 Flask
-ldap3
 pandas
 openpyxl
 xlrd
@@ -10,3 +9,4 @@ xlsxwriter
 matplotlib 
 flask_sqlalchemy
 flask_migrate
+weasyprint

run.py

@@ -1,11 +1,15 @@
 from dotenv import load_dotenv
 load_dotenv()
 from app import create_app
+from app.services.db_service import db
 import os
 
 app = create_app()
 
 if __name__ == "__main__":
+    with app.app_context():
+        db.create_all() 
+
     app.run(
         host=os.getenv("FLASK_HOST"),
         port=int(os.getenv("FLASK_PORT")),