pjpatil12/Comparison_Project
1
0
Fork 0
Code Issues Pull Requests 2 Actions Packages Projects Releases Wiki Activity

Compare commits

base: pjpatil12:prajakta-devs
Branches Tags
pjpatil12:main pjpatil12:Laxmi-Devs pjpatil12:pankaj-dev pjpatil12:swapnil-dev pjpatil12:production pjpatil12:prajakta-devs pjpatil12:empty
..
compare: pjpatil12:e7e955634f818157a381c1417573e4d950f9522b
Branches Tags
pjpatil12:Laxmi-Devs pjpatil12:main pjpatil12:pankaj-dev pjpatil12:swapnil-dev pjpatil12:production pjpatil12:prajakta-devs pjpatil12:empty

7 Commits
prajakta-d ... e7e955634f

Author SHA1 Message Date
anishd100
e7e955634f Merge branch 'dev-anish' of http://gitea.lcepl.org/pjpatil12/Comparison_Project into dev-anish 2026-02-02 12:27:38 +05:30
anishd100
5b14adc7c3 webhook 2026-02-02 12:27:27 +05:30
anishd100
de8e68aff2 Update app/templates/base.html 2026-02-02 06:47:42 +00:00
anishd100
2ef8a9aff9 new dashboard 1 2026-01-24 16:46:33 +05:30
anishd100
20a5d01f88 dashboarded added 2026-01-24 13:41:52 +05:30
pjpatil12
1dceb640bd Merge pull request 'Dowload report of client report fix' (#10) from dev-anish into main 
Reviewed-on: #10
 2026-01-19 06:54:02 +00:00
anishd100
359847958d Dowload report of client report fix 2026-01-17 18:06:58 +05:30
69 changed files with 5289 additions and 5449 deletions
Expand all files Collapse all files

19
.dockerignore
View File

@@ -1,19 +0,0 @@
.git
.gitignore
__pycache__
*.pyc
*.pyo
*.pyd
.Python
env/
venv/
*.egg-info/
dist/
build/
.vscode/
.idea/
*.log
.env
instance/
.pytest_cache/
.coverage

17
.env
View File

@@ -4,7 +4,7 @@
FLASK_ENV=development
FLASK_DEBUG=True
FLASK_HOST=0.0.0.0
FLASK_PORT=5011
FLASK_PORT=5001
# -----------------------------
# Security
@@ -20,20 +20,7 @@ DB_HOST=127.0.0.1
DB_PORT=3306
DB_NAME=comparisondb
DB_USER=root
DB_PASSWORD=root
DB_PASSWORD=admin
# 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_BASE_DN=dc=lcepl,dc=org
LDAP_DOMAIN=lcepl.org
# OpenLDAP standard username attribute
LDAP_SEARCH_FILTER=(uid={username})

5
.gitignore vendored
View File

@@ -13,7 +13,8 @@ venv
# Ignore Log files ss
logs/
*.log
# Ignore db folders
instance/

11
Dockerfile
View File

@@ -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
EXPOSE 5000
# Run the application with Gunicorn (production WSGI server)
CMD ["gunicorn", "--bind", "0.0.0.0:5001", "run:app"]
# Run the application
CMD ["python", "run.py"]

84
app/__init__.py
View File

@@ -1,7 +1,9 @@
import logging
import logging.handlers
import os
from flask import Flask, redirect, url_for
from app.config import Config
from app.services.db_service import db, migrate
from app.services.logger_service import LoggerService
from app.services.db_service import db
def create_app():
app = Flask(__name__)
@@ -9,12 +11,9 @@ 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)
# Configure logging
setup_logging(app)
# Register blueprints
register_blueprints(app)
@@ -29,16 +28,77 @@ def create_app():
return app
def setup_logging(app):
"""Configure comprehensive logging for debugging"""
# Ensure logs directory exists
logs_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'logs')
os.makedirs(logs_dir, exist_ok=True)
# Create logger
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
# Remove existing handlers
logger.handlers.clear()
# Create formatters
detailed_formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'
)
# File handler for all logs
file_handler = logging.handlers.RotatingFileHandler(
os.path.join(logs_dir, 'app.log'),
maxBytes=10485760, # 10MB
backupCount=5
)
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(detailed_formatter)
logger.addHandler(file_handler)
# File handler for RA bill fetching only
ra_bill_handler = logging.handlers.RotatingFileHandler(
os.path.join(logs_dir, 'ra_bill_fetch.log'),
maxBytes=5242880, # 5MB
backupCount=5
)
ra_bill_handler.setLevel(logging.DEBUG)
ra_bill_handler.setFormatter(detailed_formatter)
# Only attach to relevant loggers
ra_loggers = ['app.routes.dashboard', 'app.routes.file_report']
for logger_name in ra_loggers:
logging.getLogger(logger_name).addHandler(ra_bill_handler)
# Console handler for important messages
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
console_formatter = logging.Formatter(
'%(levelname)s - %(name)s - %(message)s'
)
console_handler.setFormatter(console_formatter)
logger.addHandler(console_handler)
# Suppress verbose libraries
logging.getLogger('werkzeug').setLevel(logging.WARNING)
logging.getLogger('sqlalchemy.engine').setLevel(logging.WARNING)
app.logger.info("Logging initialized successfully")
app.logger.info(f"Log files location: {logs_dir}")
def register_blueprints(app):
from app.routes.auth import auth_bp
from app.routes.user_routes import user_bp
from app.routes.user import user_bp
from app.routes.dashboard import dashboard_bp
from app.routes.subcontractor_routes import subcontractor_bp
from app.routes.file_import import file_import_bp
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
from app.routes.activity_routes import activity_bp
app.register_blueprint(auth_bp)
app.register_blueprint(user_bp)
@@ -48,19 +108,13 @@ def register_blueprints(app):
app.register_blueprint(file_report_bp)
app.register_blueprint(generate_report_bp)
app.register_blueprint(file_format_bp )
app.register_blueprint(activity_bp)
def register_error_handlers(app):
from flask import current_app
@app.errorhandler(404)
def page_not_found(e):
current_app.logger.warning("404 Page Not Found")
return "Page Not Found", 404
@app.errorhandler(500)
def internal_error(e):
current_app.logger.exception("500 Internal Server Error")
return "Internal Server Error", 500

18
app/config.py
View File

@@ -6,7 +6,7 @@ class Config:
# secret key
SECRET_KEY = os.getenv("SECRET_KEY", "dev-secret-key")
# Database variables
# Database varibles
DB_DIALECT = os.getenv("DB_DIALECT")
DB_DRIVER = os.getenv("DB_DRIVER")
DB_USER = os.getenv("DB_USER")
@@ -27,19 +27,3 @@ class Config:
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"
# e.g. "ldap://192.168.0.25:389" or "ldaps://192.168.0.25:636" (preferred, encrypted)
LDAP_SERVER = os.getenv("LDAP_URL", "ldap://192.168.0.25:389")
# Service/admin account used only to SEARCH for a user's real DN.
# 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_BIND_PASSWORD = os.getenv("LDAP_BIND_PASSWORD", "")
# Base DN to search for user entries under
LDAP_BASE_DN = os.getenv("LDAP_BASE_DN", "dc=lcepl,dc=org")
# 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})")

29
app/constants/http_status.py
View File

@@ -1,29 +0,0 @@
class HTTPStatus:
# ==========================
# 2xx Success
# ==========================
OK = 200 # Request successful
CREATED = 201 # Resource created successfully
ACCEPTED = 202 # Request accepted for processing
NO_CONTENT = 204 # Success, no response body
# ==========================
# 4xx Client Errors
# ==========================
BAD_REQUEST = 400 # Invalid request
UNAUTHORIZED = 401 # Authentication required
FORBIDDEN = 403 # Access denied
NOT_FOUND = 404 # Resource not found
METHOD_NOT_ALLOWED = 405 # HTTP method not allowed
CONFLICT = 409 # Resource conflict (e.g., duplicate)
UNPROCESSABLE_ENTITY = 422 # Validation error
TOO_MANY_REQUESTS = 429 # Rate limit exceeded
# ==========================
# 5xx Server Errors
# ==========================
INTERNAL_SERVER_ERROR = 500 # Internal server error
NOT_IMPLEMENTED = 501 # Feature not implemented
BAD_GATEWAY = 502 # Invalid response from upstream server
SERVICE_UNAVAILABLE = 503 # Server temporarily unavailable
GATEWAY_TIMEOUT = 504 # Upstream server timeout

65
app/constants/messages.py
View File

@@ -1,65 +0,0 @@
class SuccessMessage:
FETCHED = "Data fetched successfully."
CREATED = "Resource created successfully."
UPDATED = "Resource updated successfully."
DELETED = "Resource deleted successfully."
SAVED = "Data saved successfully."
IMPORTED = "Data imported successfully."
EXPORTED = "Data exported successfully."
UPLOADED = "File uploaded successfully."
DOWNLOADED = "File downloaded successfully."
LOGIN = "Login successful."
LOGOUT = "Logout successful."
PASSWORD_CHANGED = "Password changed successfully."
PASSWORD_RESET = "Password reset successfully."
EMAIL_SENT = "Email sent successfully."
STATUS_UPDATED = "Status updated successfully."
class ErrorMessage:
INVALID_REQUEST = "Invalid request."
INVALID_DATA = "Invalid data provided."
VALIDATION_FAILED = "Validation failed."
UNAUTHORIZED = "Unauthorized access."
FORBIDDEN = "Access denied."
NOT_FOUND = "Resource not found."
METHOD_NOT_ALLOWED = "Method not allowed."
DUPLICATE_ENTRY = "Duplicate record found."
RECORD_EXISTS = "Record already exists."
RECORD_NOT_FOUND = "Record does not exist."
FILE_NOT_FOUND = "File not found."
FILE_UPLOAD_FAILED = "File upload failed."
FILE_IMPORT_FAILED = "File import failed."
DATABASE_ERROR = "Database operation failed."
INTERNAL_SERVER_ERROR = "Internal server error."
SERVICE_UNAVAILABLE = "Service temporarily unavailable."
LOGIN_FAILED = "Invalid username or password."
SESSION_EXPIRED = "Session expired. Please login again."
PASSWORD_MISMATCH = "Passwords do not match."
INVALID_TOKEN = "Invalid or expired token."
class WarningMessage:
NO_DATA_FOUND = "No data found."
ALREADY_EXISTS = "Record already exists."
UNSAVED_CHANGES = "You have unsaved changes."
DELETE_CONFIRMATION = "Are you sure you want to delete the selected record(s)?"
INVALID_FILTER = "No records match the selected filters."
class InfoMessage:
PROCESSING = "Request is being processed."
LOADING = "Loading data..."
SAVING = "Saving data..."
DELETING = "Deleting record..."
IMPORTING = "Importing data..."
EXPORTING = "Preparing export..."

66
app/errors/error_handlers.py
View File

@@ -1,66 +0,0 @@
from flask import request, render_template
from app.utils.response_handler import ResponseHandler
from app.utils.exceptions import APIException
from app.constants.http_status import HTTPStatus
from app.constants.messages import ErrorMessage
from app.services.db_service import db
import traceback
def register_error_handlers(app):
# Custom API Exception
@app.errorhandler(APIException)
def handle_api_exception(e):
db.session.rollback()
if request.path.startswith("/api"):
return ResponseHandler.error(
message=e.message,
errors=e.errors,
status_code=e.status_code
)
return render_template("errors/500.html"), e.status_code
# 404
@app.errorhandler(404)
def handle_404(e):
if request.path.startswith("/api"):
return ResponseHandler.error(
message=ErrorMessage.NOT_FOUND,
status_code=HTTPStatus.NOT_FOUND
)
return render_template("errors/404.html"), 404
# 500
@app.errorhandler(500)
def handle_500(e):
db.session.rollback()
traceback.print_exc()
if request.path.startswith("/api"):
return ResponseHandler.error(
message=ErrorMessage.INTERNAL_ERROR,
status_code=HTTPStatus.INTERNAL_SERVER_ERROR
)
return render_template("errors/500.html"), 500
# Catch All
@app.errorhandler(Exception)
def handle_general_exception(e):
db.session.rollback()
traceback.print_exc()
if request.path.startswith("/api"):
return ResponseHandler.error(
message=ErrorMessage.INTERNAL_ERROR,
status_code=HTTPStatus.INTERNAL_SERVER_ERROR
)
return render_template("errors/500.html"), 500

0
app/models/rate_model.py → app/logs/app.log
View File

80
app/models/laying_client_model.py
View File

@@ -1,8 +1,5 @@
from app import db
from datetime import datetime
from sqlalchemy import event
from app.utils.regex_utils import RegularExpression
from decimal import Decimal
class LayingClient(db.Model):
__tablename__ = "laying_client"
@@ -10,47 +7,39 @@ class LayingClient(db.Model):
id = db.Column(db.Integer, primary_key=True)
# Basic Fields
RA_Bill_No = db.Column(db.String(500))
Location = db.Column(db.String(500))
MH_NO = db.Column(db.String(100))
CC_length = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
CC_length = db.Column(db.Float)
# Bedding Qty.
Outer_dia_of_MH_m = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Bedding_Length = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Width = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Depth = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Qty = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Outer_dia_of_MH_m = db.Column(db.Float)
Bedding_Length = db.Column(db.Float)
Width = db.Column(db.Float)
Depth = db.Column(db.Float)
Qty = db.Column(db.Float)
# PIPE LAYING Qty.
Pipe_Dia_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
ID_of_MH_m = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Laying_Length = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Pipe_Dia_mm = db.Column(db.Float)
ID_of_MH_m = db.Column(db.Float)
Laying_Length = db.Column(db.Float)
pipe_150_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_200_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_250_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_300_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_350_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_400_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_450_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_500_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_600_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_700_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_900_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_1200_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_150_mm = db.Column(db.Float)
pipe_200_mm = db.Column(db.Float)
pipe_250_mm = db.Column(db.Float)
pipe_300_mm = db.Column(db.Float)
pipe_350_mm = db.Column(db.Float)
pipe_400_mm = db.Column(db.Float)
pipe_450_mm = db.Column(db.Float)
pipe_500_mm = db.Column(db.Float)
pipe_600_mm = db.Column(db.Float)
pipe_700_mm = db.Column(db.Float)
pipe_900_mm = db.Column(db.Float)
pipe_1200_mm = db.Column(db.Float)
np4_pipe_200_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
np4_pipe_250_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
np4_pipe_300_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
np4_pipe_350_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
np4_pipe_400_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
np4_pipe_450_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
np4_pipe_500_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
np4_pipe_600_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Total = db.Column(db.Float)
Remarks = db.Column(db.String(500))
RA_Bill_No=db.Column(db.String(500))
Total = db.Column(db.Numeric(12, 2), default=Decimal("0.00"))
Remarks = db.Column(db.String(500), default="Import File")
created_at = db.Column(db.DateTime,default=datetime.now,nullable=False)
created_at = db.Column(db.DateTime, default=datetime.today)
def __repr__(self):
@@ -60,15 +49,10 @@ class LayingClient(db.Model):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
# AUTO TOTAL USING REGEX
def calculate_laying_total(mapper, connection, target):
total = Decimal("0.00")
for column in target.__table__.columns:
if RegularExpression.PIPE_MM_PATTERN.match(column.name):
value = getattr(target, column.name)
if value is not None:
total += Decimal(value)
target.Total = total.quantize(Decimal("0.01"))
event.listen(LayingClient, "before_insert", calculate_laying_total)
event.listen(LayingClient, "before_update", calculate_laying_total)
def sum_laying_fields():
return [
"pipe_150_mm", "pipe_200_mm", "pipe_250_mm",
"pipe_300_mm", "pipe_350_mm", "pipe_400_mm",
"pipe_450_mm", "pipe_500_mm", "pipe_600_mm",
"pipe_700_mm", "pipe_900_mm", "pipe_1200_mm"
]

63
app/models/laying_model.py
View File

@@ -1,8 +1,5 @@
from app import db
from datetime import datetime
from sqlalchemy import event
from app.utils.regex_utils import RegularExpression
from decimal import Decimal
class Laying(db.Model):
__tablename__ = "laying"
@@ -14,30 +11,31 @@ class Laying(db.Model):
subcontractor = db.relationship("Subcontractor", backref="laying_records")
# Pipe Laying Fields
RA_Bill_No=db.Column(db.String(500))
Location = db.Column(db.String(500))
MH_NO = db.Column(db.String(100))
CC_length = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Pipe_Dia_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
ID_of_MH_m = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Laying_Length = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
CC_length = db.Column(db.Float)
Pipe_Dia_mm = db.Column(db.Float)
ID_of_MH_m = db.Column(db.Float)
Laying_Length = db.Column(db.Float)
pipe_150_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_200_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_250_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_300_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_350_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_400_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_450_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_500_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_600_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_700_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_900_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_1200_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
pipe_150_mm = db.Column(db.Float)
pipe_200_mm = db.Column(db.Float)
pipe_250_mm = db.Column(db.Float)
pipe_300_mm = db.Column(db.Float)
pipe_350_mm = db.Column(db.Float)
pipe_400_mm = db.Column(db.Float)
pipe_450_mm = db.Column(db.Float)
pipe_500_mm = db.Column(db.Float)
pipe_600_mm = db.Column(db.Float)
pipe_700_mm = db.Column(db.Float)
pipe_900_mm = db.Column(db.Float)
pipe_1200_mm = db.Column(db.Float)
Total = db.Column(db.Numeric(12, 2), default=Decimal("0.00"))
Remarks = db.Column(db.String(500), default="Import File")
created_at = db.Column(db.DateTime,default=datetime.now,nullable=False)
Total = db.Column(db.Float)
Remarks = db.Column(db.String(500))
RA_Bill_No=db.Column(db.String(500))
created_at = db.Column(db.DateTime, default=datetime.today)
def __repr__(self):
@@ -47,15 +45,10 @@ class Laying(db.Model):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
# AUTO TOTAL USING REGEX
def calculate_laying_total(mapper, connection, target):
total = Decimal("0.00")
for column in target.__table__.columns:
if RegularExpression.PIPE_MM_PATTERN.match(column.name):
value = getattr(target, column.name)
if value is not None:
total += Decimal(value)
target.Total = total.quantize(Decimal("0.01"))
event.listen(Laying, "before_insert", calculate_laying_total)
event.listen(Laying, "before_update", calculate_laying_total)
def sum_laying_fields():
return [
"pipe_150_mm", "pipe_200_mm", "pipe_250_mm",
"pipe_300_mm", "pipe_350_mm", "pipe_400_mm",
"pipe_450_mm", "pipe_500_mm", "pipe_600_mm",
"pipe_700_mm", "pipe_900_mm", "pipe_1200_mm"
]

75
app/models/manhole_domestic_chamber_model.py
View File

@@ -1,8 +1,5 @@
from app import db
from datetime import datetime
from sqlalchemy import event
from app.utils.regex_utils import RegularExpression
from decimal import Decimal
class ManholeDomesticChamber(db.Model):
__tablename__ = "manhole_domestic_chamber"
@@ -14,40 +11,38 @@ class ManholeDomesticChamber(db.Model):
subcontractor = db.relationship("Subcontractor", backref="manhole_domestic_chamber_records")
# Basic Fields
RA_Bill_No=db.Column(db.String(500))
Location = db.Column(db.String(500))
MH_NO = db.Column(db.String(100))
Depth_of_MH = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Depth_of_MH = db.Column(db.Float)
# Excavation categories
d_0_to_0_75 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_0_76_to_1_05 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_1_06_to_1_65 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_1_66_to_2_15 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_2_16_to_2_65 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_2_66_to_3_15 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_3_16_to_3_65= db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_3_66_to_4_15 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_4_16_to_4_65 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_4_66_to_5_15 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_5_16_to_5_65 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_5_66_to_6_15 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_6_16_to_6_65 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_6_66_to_7_15 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_7_16_to_7_65 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_7_66_to_8_15 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_8_16_to_8_65 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_8_66_to_9_15 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_9_16_to_9_65 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_0_to_0_75 = db.Column(db.Float)
d_0_76_to_1_05 = db.Column(db.Float)
d_1_06_to_1_65 = db.Column(db.Float)
d_1_66_to_2_15 = db.Column(db.Float)
d_2_16_to_2_65 = db.Column(db.Float)
d_2_66_to_3_15 = db.Column(db.Float)
d_3_16_to_3_65= db.Column(db.Float)
d_3_66_to_4_15 = db.Column(db.Float)
d_4_16_to_4_65 = db.Column(db.Float)
d_4_66_to_5_15 = db.Column(db.Float)
d_5_16_to_5_65 = db.Column(db.Float)
Domestic_Chambers = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
DWC_Pipe_Length = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
UPVC_Pipe_Length = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_5_66_to_6_15 = db.Column(db.Float)
d_6_16_to_6_65 = db.Column(db.Float)
d_6_66_to_7_15 = db.Column(db.Float)
d_7_16_to_7_65 = db.Column(db.Float)
d_7_66_to_8_15 = db.Column(db.Float)
d_8_16_to_8_65 = db.Column(db.Float)
d_8_66_to_9_15 = db.Column(db.Float)
d_9_16_to_9_65 = db.Column(db.Float)
Domestic_Chambers = db.Column(db.Float)
DWC_Pipe_Length = db.Column(db.Float)
UPVC_Pipe_Length = db.Column(db.Float)
RA_Bill_No=db.Column(db.String(500))
Total = db.Column(db.Numeric(12, 2), default=Decimal("0.00"))
Remarks = db.Column(db.String(500), default="Import File")
created_at = db.Column(db.DateTime,default=datetime.now,nullable=False)
created_at = db.Column(db.DateTime, default=datetime.today)
def __repr__(self):
return f"<HanholeDomesticChamberConstruction {self.Location}>"
@@ -56,15 +51,13 @@ class ManholeDomesticChamber(db.Model):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
# AUTO TOTAL USING REGEX
def calculate_mh_dc_total(mapper, connection, target):
total = Decimal("0.00")
for column in target.__table__.columns:
if RegularExpression.D_RANGE_PATTERN.match(column.name):
value = getattr(target, column.name)
if value is not None:
total += Decimal(value)
target.Total = total.quantize(Decimal("0.01"))
def sum_mh_dc_fields():
return [
"d_0_to_0_75", "d_0_76_to_1_05", "d_1_06_to_1_65",
"d_1_66_to_2_15", "d_2_16_to_2_65", "d_2_66_to_3_15",
"d_3_16_to_3_65", "d_3_66_to_4_15", "d_4_16_to_4_65",
"d_4_66_to_5_15", "d_5_16_to_5_65", "d_5_66_to_6_15",
"d_6_16_to_6_65", "d_6_66_to_7_15", "d_7_16_to_7_65",
"d_7_66_to_8_15", "d_8_16_to_8_65", "d_8_66_to_9_15",
"d_9_16_to_9_65"]
event.listen(ManholeDomesticChamber, "before_insert", calculate_mh_dc_total)
event.listen(ManholeDomesticChamber, "before_update", calculate_mh_dc_total)

84
app/models/manhole_excavation_model.py
View File

@@ -1,8 +1,5 @@
from app import db
from datetime import datetime
from sqlalchemy import event
from app.utils.regex_utils import RegularExpression
from decimal import Decimal
class ManholeExcavation(db.Model):
__tablename__ = "manhole_excavation"
@@ -14,70 +11,57 @@ class ManholeExcavation(db.Model):
subcontractor = db.relationship("Subcontractor", backref="manhole_records")
# Basic Fields
RA_Bill_No=db.Column(db.String(500))
Location = db.Column(db.String(500))
MH_NO = db.Column(db.String(100))
Upto_IL_Depth = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Cutting_Depth = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
ID_of_MH_m = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Ex_Dia_of_Manhole = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Area_of_Manhole = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Upto_IL_Depth = db.Column(db.Float)
Cutting_Depth = db.Column(db.Float)
ID_of_MH_m = db.Column(db.Float)
Ex_Dia_of_Manhole = db.Column(db.Float)
Area_of_Manhole = db.Column(db.Float)
# Excavation categories
Soft_Murum_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_3_0_to_4_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_0_to_1_5 = db.Column(db.Float)
Soft_Murum_1_5_to_3_0 = db.Column(db.Float)
Soft_Murum_3_0_to_4_5 = db.Column(db.Float)
Hard_Murum_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_0_to_1_5 = db.Column(db.Float)
Hard_Murum_1_5_to_3_0 = db.Column(db.Float)
Soft_Rock_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_0_to_1_5 = db.Column(db.Float)
Soft_Rock_1_5_to_3_0 = db.Column(db.Float)
Hard_Rock_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_3_0_to_4_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_4_5_to_6_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_6_0_to_7_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_0_to_1_5 = db.Column(db.Float)
Hard_Rock_1_5_to_3_0 = db.Column(db.Float)
Hard_Rock_3_0_to_4_5 = db.Column(db.Float)
Hard_Rock_4_5_to_6_0 = db.Column(db.Float)
Hard_Rock_6_0_to_7_5 = db.Column(db.Float)
# Totals
Soft_Murum_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_1_5_to_3_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_3_0_to_4_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_0_to_1_5_total = db.Column(db.Float)
Soft_Murum_1_5_to_3_0_total = db.Column(db.Float)
Soft_Murum_3_0_to_4_5_total = db.Column(db.Float)
Hard_Murum_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_1_5_and_above_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_0_to_1_5_total = db.Column(db.Float)
Hard_Murum_1_5_and_above_total = db.Column(db.Float)
Soft_Rock_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_1_5_and_above_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_0_to_1_5_total = db.Column(db.Float)
Soft_Rock_1_5_and_above_total = db.Column(db.Float)
Hard_Rock_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_1_5_to_3_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_3_0_to_4_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_4_5_to_6_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_6_0_to_7_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_0_to_1_5_total = db.Column(db.Float)
Hard_Rock_1_5_to_3_0_total = db.Column(db.Float)
Hard_Rock_3_0_to_4_5_total = db.Column(db.Float)
Hard_Rock_4_5_to_6_0_total = db.Column(db.Float)
Hard_Rock_6_0_to_7_5_total = db.Column(db.Float)
Total = db.Column(db.Numeric(12, 2), default=Decimal("0.00"))
Remarks = db.Column(db.String(500), default="Import File")
created_at = db.Column(db.DateTime,default=datetime.now,nullable=False)
Total = db.Column(db.Float)
Remarks = db.Column(db.String(500))
RA_Bill_No=db.Column(db.String(500))
created_at = db.Column(db.DateTime, default=datetime.today)
def __repr__(self):
return f"<HanholeExcavation {self.Location}>"
def serialize(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
# AUTO TOTAL USING REGEX
def calculate_Manhole_total(mapper, connection, target):
total = Decimal("0.00")
for column in target.__table__.columns:
if RegularExpression.STR_TOTAL_PATTERN.match(column.name):
value = getattr(target, column.name)
if value is not None:
total += Decimal(value)
target.Total = total.quantize(Decimal("0.01"))
event.listen(ManholeExcavation, "before_insert", calculate_Manhole_total)
event.listen(ManholeExcavation, "before_update", calculate_Manhole_total)

67
app/models/mh_dc_client_model.py
View File

@@ -1,40 +1,42 @@
from app import db
from datetime import datetime
from sqlalchemy import event
from app.utils.regex_utils import RegularExpression
from decimal import Decimal
class ManholeDomesticChamberClient(db.Model):
__tablename__ = "mh_dc_client"
id = db.Column(db.Integer, primary_key=True)
# Foreign Key to Subcontractor table
# subcontractor_id = db.Column(db.Integer, db.ForeignKey("subcontractors.id"), nullable=False)
# Relationship for easy access (subcontractor.subcontractor_name)
# subcontractor = db.relationship("Subcontractor", backref="mh_dc_records")
# Basic Fields
RA_Bill_No = db.Column(db.String(500))
RA_Bill_No=db.Column(db.String(500))
Location = db.Column(db.String(500))
MH_NO = db.Column(db.String(100))
MH_TOP_LEVEL = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
MH_IL_LEVEL = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Depth_of_MH = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
MH_TOP_LEVEL = db.Column(db.Float)
MH_IL_LEVEL = db.Column(db.Float)
Depth_of_MH = db.Column(db.Float)
# Excavation categories
d_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_1_5_to_2_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_2_0_to_2_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_2_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_3_0_to_3_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_3_5_to_4_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_4_0_to_4_5= db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_4_5_to_5_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_5_0_to_5_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_5_5_to_6_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_6_0_to_6_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_0_to_1_5 = db.Column(db.Float)
d_1_5_to_2_0 = db.Column(db.Float)
d_2_0_to_2_5 = db.Column(db.Float)
d_2_5_to_3_0 = db.Column(db.Float)
Domestic_Chambers = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
d_3_0_to_3_5 = db.Column(db.Float)
d_3_5_to_4_0 = db.Column(db.Float)
d_4_0_to_4_5= db.Column(db.Float)
d_4_5_to_5_0 = db.Column(db.Float)
Total = db.Column(db.Numeric(12, 2), default=Decimal("0.00"))
Remarks = db.Column(db.String(500), default="Import File")
created_at = db.Column(db.DateTime,default=datetime.now,nullable=False)
d_5_0_to_5_5 = db.Column(db.Float)
d_5_5_to_6_0 = db.Column(db.Float)
d_6_0_to_6_5 = db.Column(db.Float)
Domestic_Chambers = db.Column(db.Float)
created_at = db.Column(db.DateTime, default=datetime.today)
def __repr__(self):
return f"<HanholeDomesticChamberConstruction {self.Location}>"
@@ -44,15 +46,12 @@ class ManholeDomesticChamberClient(db.Model):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
# AUTO TOTAL USING REGEX
def calculate_mh_dc_total(mapper, connection, target):
total = Decimal("0.00")
for column in target.__table__.columns:
if RegularExpression.D_RANGE_PATTERN.match(column.name):
value = getattr(target, column.name)
if value is not None:
total += Decimal(value)
target.Total = total.quantize(Decimal("0.01"))
event.listen(ManholeDomesticChamberClient, "before_insert", calculate_mh_dc_total)
event.listen(ManholeDomesticChamberClient, "before_update", calculate_mh_dc_total)
def sum_mh_dc_fields():
return [
"d_0_to_0_75", "d_0_76_to_1_05", "d_1_06_to_1_65",
"d_1_66_to_2_15", "d_2_16_to_2_65", "d_2_66_to_3_15",
"d_3_16_to_3_65", "d_3_66_to_4_15", "d_4_16_to_4_65",
"d_4_66_to_5_15", "d_5_16_to_5_65", "d_5_66_to_6_15",
"d_6_16_to_6_65", "d_6_66_to_7_15", "d_7_16_to_7_65",
"d_7_66_to_8_15", "d_8_16_to_8_65", "d_8_66_to_9_15",
"d_9_16_to_9_65" ]

115
app/models/mh_ex_client_model.py
View File

@@ -1,96 +1,83 @@
from app import db
from datetime import datetime
from sqlalchemy import event
from app.utils.regex_utils import RegularExpression
from decimal import Decimal
class ManholeExcavationClient(db.Model):
__tablename__ = "mh_ex_client"
id = db.Column(db.Integer, primary_key=True)
# Foreign Key to Subcontractor table
# subcontractor_id = db.Column(db.Integer, db.ForeignKey("subcontractors.id"), nullable=False)
# Relationship for easy access (subcontractor.subcontractor_name)
# subcontractor = db.relationship("Subcontractor", backref="mh_ex_records")
# Basic Fields
RA_Bill_No = db.Column(db.String(500))
RA_Bill_No=db.Column(db.String(500))
Location = db.Column(db.String(500))
MH_NO = db.Column(db.String(100))
Ground_Level = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
MH_Invert_Level = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
MH_Top_Level = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Ex_Level = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Cutting_Depth = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
MH_Depth = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
ID_of_MH_m = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Ground_Level = db.Column(db.Float)
MH_Invert_Level = db.Column(db.Float)
MH_Top_Level = db.Column(db.Float)
Ex_Level = db.Column(db.Float)
Cutting_Depth = db.Column(db.Float)
MH_Depth = db.Column(db.Float)
ID_of_MH_m = db.Column(db.Float)
Dia_of_MH_Cutting = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Area_of_Manhole = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Dia_of_MH_Cutting = db.Column(db.Float)
Area_of_Manhole = db.Column(db.Float)
# Excavation categories
Marshi_Muddy_Slushy_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Marshi_Muddy_Slushy_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Marshi_Muddy_Slushy_3_0_to_4_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Marshi_Muddy_Slushy_0_to_1_5 = db.Column(db.Float)
Marshi_Muddy_Slushy_1_5_to_3_0 = db.Column(db.Float)
Marshi_Muddy_Slushy_3_0_to_4_5 = db.Column(db.Float)
Soft_Murum_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_3_0_to_4_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_0_to_1_5 = db.Column(db.Float)
Soft_Murum_1_5_to_3_0 = db.Column(db.Float)
Soft_Murum_3_0_to_4_5 = db.Column(db.Float)
Hard_Murum_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_3_0_to_4_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_0_to_1_5 = db.Column(db.Float)
Hard_Murum_1_5_to_3_0 = db.Column(db.Float)
Hard_Murum_3_0_to_4_5 = db.Column(db.Float)
Soft_Rock_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_3_0_to_4_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_0_to_1_5 = db.Column(db.Float)
Soft_Rock_1_5_to_3_0 = db.Column(db.Float)
Soft_Murum_3_0_to_4_5 = db.Column(db.Float)
Hard_Rock_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_3_0_to_4_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_4_5_to_6_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_6_0_to_7_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_0_to_1_5 = db.Column(db.Float)
Hard_Rock_1_5_to_3_0 = db.Column(db.Float)
Hard_Rock_3_0_to_4_5 = db.Column(db.Float)
Hard_Rock_4_5_to_6_0 = db.Column(db.Float)
Hard_Rock_6_0_to_7_5 = db.Column(db.Float)
# Totals
Marshi_Muddy_Slushy_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Marshi_Muddy_Slushy_1_5_to_3_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Marshi_Muddy_Slushy_3_0_to_4_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Marshi_Muddy_Slushy_0_to_1_5_total = db.Column(db.Float)
Marshi_Muddy_Slushy_1_5_to_3_0_total = db.Column(db.Float)
Marshi_Muddy_Slushy_3_0_to_4_5_total = db.Column(db.Float)
Soft_Murum_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_1_5_to_3_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_3_0_to_4_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_0_to_1_5_total = db.Column(db.Float)
Soft_Murum_1_5_to_3_0_total = db.Column(db.Float)
Soft_Murum_3_0_to_4_5_total = db.Column(db.Float)
Hard_Murum_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_1_5_to_3_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_3_0_to_4_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_0_to_1_5_total = db.Column(db.Float)
Hard_Murum_1_5_to_3_0_total = db.Column(db.Float)
Hard_Murum_3_0_to_4_5_total = db.Column(db.Float)
Soft_Rock_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_1_5_to_3_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_3_0_to_4_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_0_to_1_5_total = db.Column(db.Float)
Soft_Rock_1_5_to_3_0_total = db.Column(db.Float)
Soft_Rock_3_0_to_4_5_total = db.Column(db.Float)
Hard_Rock_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_1_5_to_3_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_3_0_to_4_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_4_5_to_6_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_6_0_to_7_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_0_to_1_5_total = db.Column(db.Float)
Hard_Rock_1_5_to_3_0_total = db.Column(db.Float)
Hard_Rock_3_0_to_4_5_total = db.Column(db.Float)
Hard_Rock_4_5_to_6_0_total = db.Column(db.Float)
Hard_Rock_6_0_to_7_5_total = db.Column(db.Float)
Remarks = db.Column(db.String(500))
Total = db.Column(db.Float)
Total = db.Column(db.Numeric(12, 2), default=Decimal("0.00"))
Remarks = db.Column(db.String(500), default="Import File")
created_at = db.Column(db.DateTime,default=datetime.now,nullable=False)
created_at = db.Column(db.DateTime, default=datetime.today)
def __repr__(self):
return f"<HanholeExcavation {self.Location}>"
def serialize(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
# AUTO TOTAL USING REGEX
def calculate_Manhole_total(mapper, connection, target):
total = Decimal("0.00")
for column in target.__table__.columns:
if RegularExpression.STR_TOTAL_PATTERN.match(column.name):
value = getattr(target, column.name)
if value is not None:
total += Decimal(value)
target.Total = total.quantize(Decimal("0.01"))
event.listen(ManholeExcavationClient, "before_insert", calculate_Manhole_total)
event.listen(ManholeExcavationClient, "before_update", calculate_Manhole_total)

23
app/models/subcontractor_rate_model.py
View File

@@ -1,23 +0,0 @@
from app import db
from datetime import datetime
class SubcontractorRate(db.Model):
__tablename__ = "subcontractor_rates"
id = db.Column(db.Integer, primary_key=True)
subcontractor_id = db.Column(db.Integer, db.ForeignKey("subcontractors.id"), nullable=False)
subcontractor = db.relationship("Subcontractor", backref="rate_master")
category = db.Column(db.String(50), nullable=False)
item_code = db.Column(db.String(50), nullable=False)
item_name = db.Column(db.String(200), nullable=False)
unit = db.Column(db.String(20))
rate = db.Column(db.Numeric(12,2), nullable=False)
effective_from = db.Column(db.Date, nullable=False)
effective_to = db.Column(db.Date)
status = db.Column(db.String(20), default="Active")
created_at = db.Column(db.DateTime, default=datetime.now)
def __repr__(self):
return f"<subcontractor Rate {self.item_name}>"

123
app/models/tr_ex_client_model.py
View File

@@ -1,101 +1,88 @@
from app import db
from datetime import datetime
from sqlalchemy import event
from app.utils.regex_utils import RegularExpression
from decimal import Decimal
class TrenchExcavationClient(db.Model):
__tablename__ = "tr_ex_client"
id = db.Column(db.Integer, primary_key=True)
# Foreign Key to Subcontractor table
# subcontractor_id = db.Column(db.Integer, db.ForeignKey("subcontractors.id"), nullable=False)
# Relationship for easy access (subcontractor.subcontractor_name)
# subcontractor = db.relationship("Subcontractor", backref="tr_ex_records")
# Basic Fields
RA_Bill_No=db.Column(db.String(500))
Location = db.Column(db.String(500))
MH_NO = db.Column(db.String(100))
CC_length = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Actual_Trench_Length = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Ground_Level = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Invert_Level = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Excavated_level = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Cutting_Depth = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Avg_Depth = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Pipe_Dia_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
CC_length = db.Column(db.Float)
Actual_Trench_Length = db.Column(db.Float)
Ground_Level = db.Column(db.Float)
Invert_Level = db.Column(db.Float)
Excavated_level = db.Column(db.Float)
Cutting_Depth = db.Column(db.Float)
Avg_Depth = db.Column(db.Float)
Pipe_Dia_mm = db.Column(db.Float)
# width
Width_0_to_1_5_m = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Width_1_5_to_3_0_m = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Width_3_0_to_4_5_m = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Width_4_5_to_6_0_m = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Width_6_0_to_7_5_m = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Width_0_to_1_5_m = db.Column(db.Float)
Width_1_5_to_3_0_m = db.Column(db.Float)
Width_3_0_to_4_5_m = db.Column(db.Float)
Width_4_5_to_6_0_m = db.Column(db.Float)
Width_6_0_to_7_5_m = db.Column(db.Float)
# Excavation categories
Marshi_Muddy_Slushy_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Marshi_Muddy_Slushy_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Marshi_Muddy_Slushy_3_0_to_4_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Marshi_Muddy_Slushy_0_to_1_5 = db.Column(db.Float)
Marshi_Muddy_Slushy_1_5_to_3_0 = db.Column(db.Float)
Marshi_Muddy_Slushy_3_0_to_4_5 = db.Column(db.Float)
Soft_Murum_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_3_0_to_4_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_0_to_1_5 = db.Column(db.Float)
Soft_Murum_1_5_to_3_0 = db.Column(db.Float)
Soft_Murum_3_0_to_4_5 = db.Column(db.Float)
Hard_Murum_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_3_0_to_4_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_0_to_1_5 = db.Column(db.Float)
Hard_Murum_1_5_to_3_0 = db.Column(db.Float)
Hard_Murum_3_0_to_4_5 = db.Column(db.Float)
Soft_Rock_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_3_0_to_4_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_0_to_1_5 = db.Column(db.Float)
Soft_Rock_1_5_to_3_0 = db.Column(db.Float)
Soft_Rock_3_0_to_4_5 = db.Column(db.Float)
Hard_Rock_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_3_0_to_4_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_4_5_to_6_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_6_0_to_7_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_0_to_1_5 = db.Column(db.Float)
Hard_Rock_1_5_to_3_0 = db.Column(db.Float)
Hard_Rock_3_0_to_4_5 = db.Column(db.Float)
Hard_Rock_4_5_to_6_0 = db.Column(db.Float)
Hard_Rock_6_0_to_7_5 = db.Column(db.Float)
# Totals
Marshi_Muddy_Slushy_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Marshi_Muddy_Slushy_1_5_to_3_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Marshi_Muddy_Slushy_3_0_to_4_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Marshi_Muddy_Slushy_0_to_1_5_total = db.Column(db.Float)
Marshi_Muddy_Slushy_1_5_to_3_0_total = db.Column(db.Float)
Marshi_Muddy_Slushy_3_0_to_4_5_total = db.Column(db.Float)
Soft_Murum_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_1_5_to_3_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_3_0_to_4_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_0_to_1_5_total = db.Column(db.Float)
Soft_Murum_1_5_to_3_0_total = db.Column(db.Float)
Soft_Murum_3_0_to_4_5_total = db.Column(db.Float)
Hard_Murum_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_1_5_to_3_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_3_0_to_4_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_0_to_1_5_total = db.Column(db.Float)
Hard_Murum_1_5_to_3_0_total = db.Column(db.Float)
Hard_Murum_3_0_to_4_5_total = db.Column(db.Float)
Soft_Rock_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_1_5_to_3_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_3_0_to_4_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_0_to_1_5_total = db.Column(db.Float)
Soft_Rock_1_5_to_3_0_total = db.Column(db.Float)
Soft_Rock_3_0_to_4_5_total = db.Column(db.Float)
Hard_Rock_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_1_5_to_3_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_3_0_to_4_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_4_5_to_6_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_6_0_to_7_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_0_to_1_5_total = db.Column(db.Float)
Hard_Rock_1_5_to_3_0_total = db.Column(db.Float)
Hard_Rock_3_0_to_4_5_total = db.Column(db.Float)
Hard_Rock_4_5_to_6_0_total = db.Column(db.Float)
Hard_Rock_6_0_to_7_5_total = db.Column(db.Float)
Total = db.Column(db.Numeric(12, 2), default=Decimal("0.00"))
Remarks = db.Column(db.String(500), default="Import File")
created_at = db.Column(db.DateTime,default=datetime.now,nullable=False)
Total = db.Column(db.Float)
Remarks = db.Column(db.String(500))
created_at = db.Column(db.DateTime, default=datetime.today)
def __repr__(self):
return f"<TrenchExcavation {self.Location}>"
def serialize(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
# AUTO TOTAL USING REGEX
def calculate_trench_client_total(mapper, connection, target):
total = Decimal("0.00")
for column in target.__table__.columns:
if RegularExpression.STR_TOTAL_PATTERN.match(column.name):
value = getattr(target, column.name)
if value is not None:
total += Decimal(value)
target.Total = total.quantize(Decimal("0.01"))
event.listen(TrenchExcavationClient, "before_insert", calculate_trench_client_total)
event.listen(TrenchExcavationClient, "before_update", calculate_trench_client_total)

127
app/models/trench_excavation_model.py
View File

@@ -1,8 +1,5 @@
from app import db
from datetime import datetime
from sqlalchemy import event
from app.utils.regex_utils import RegularExpression
from decimal import Decimal
class TrenchExcavation(db.Model):
__tablename__ = "trench_excavation"
@@ -14,64 +11,65 @@ class TrenchExcavation(db.Model):
subcontractor = db.relationship("Subcontractor", backref="trench_records")
# Basic Fields
RA_Bill_No=db.Column(db.String(500))
Location = db.Column(db.String(500))
MH_NO = db.Column(db.String(100))
CC_length = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Invert_Level = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
MH_Top_Level = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Ground_Level = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
ID_of_MH_m = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Actual_Trench_Length = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Pipe_Dia_mm = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
CC_length = db.Column(db.Float)
Invert_Level = db.Column(db.Float)
MH_Top_Level = db.Column(db.Float)
Ground_Level = db.Column(db.Float)
ID_of_MH_m = db.Column(db.Float)
Actual_Trench_Length = db.Column(db.Float)
Pipe_Dia_mm = db.Column(db.Float)
# width
Width_0_to_2_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Width_2_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Width_3_0_to_4_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Width_4_5_to_6_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Width_0_to_2_5 = db.Column(db.Float)
Width_2_5_to_3_0 = db.Column(db.Float)
Width_3_0_to_4_5 = db.Column(db.Float)
Width_4_5_to_6_0 = db.Column(db.Float)
Upto_IL_Depth = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Cutting_Depth = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Avg_Depth = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Upto_IL_Depth = db.Column(db.Float)
Cutting_Depth = db.Column(db.Float)
Avg_Depth = db.Column(db.Float)
# Excavation categories
Soft_Murum_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_3_0_to_4_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_0_to_1_5 = db.Column(db.Float)
Soft_Murum_1_5_to_3_0 = db.Column(db.Float)
Soft_Murum_3_0_to_4_5 = db.Column(db.Float)
Hard_Murum_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_0_to_1_5 = db.Column(db.Float)
Hard_Murum_1_5_to_3_0 = db.Column(db.Float)
Soft_Rock_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_0_to_1_5 = db.Column(db.Float)
Soft_Rock_1_5_to_3_0 = db.Column(db.Float)
Hard_Rock_0_to_1_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_1_5_to_3_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_3_0_to_4_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_4_5_to_6_0 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_6_0_to_7_5 = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_0_to_1_5 = db.Column(db.Float)
Hard_Rock_1_5_to_3_0 = db.Column(db.Float)
Hard_Rock_3_0_to_4_5 = db.Column(db.Float)
Hard_Rock_4_5_to_6_0 = db.Column(db.Float)
Hard_Rock_6_0_to_7_5 = db.Column(db.Float)
# Totals
Soft_Murum_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_1_5_to_3_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_3_0_to_4_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Murum_0_to_1_5_total = db.Column(db.Float)
Soft_Murum_1_5_to_3_0_total = db.Column(db.Float)
Soft_Murum_3_0_to_4_5_total = db.Column(db.Float)
Hard_Murum_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_1_5_and_above_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Murum_0_to_1_5_total = db.Column(db.Float)
Hard_Murum_1_5_and_above_total = db.Column(db.Float)
Soft_Rock_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_1_5_and_above_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Soft_Rock_0_to_1_5_total = db.Column(db.Float)
Soft_Rock_1_5_and_above_total = db.Column(db.Float)
Hard_Rock_0_to_1_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_1_5_to_3_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_3_0_to_4_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_4_5_to_6_0_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_6_0_to_7_5_total = db.Column(db.Numeric(10, 2), default=Decimal("0.00"))
Hard_Rock_0_to_1_5_total = db.Column(db.Float)
Hard_Rock_1_5_to_3_0_total = db.Column(db.Float)
Hard_Rock_3_0_to_4_5_total = db.Column(db.Float)
Hard_Rock_4_5_to_6_0_total = db.Column(db.Float)
Hard_Rock_6_0_to_7_5_total = db.Column(db.Float)
Total = db.Column(db.Numeric(12, 2), default=Decimal("0.00"))
Remarks = db.Column(db.String(500), default="Import File")
created_at = db.Column(db.DateTime,default=datetime.now,nullable=False)
Total = db.Column(db.Float)
Remarks = db.Column(db.String(500))
RA_Bill_No=db.Column(db.String(500))
created_at = db.Column(db.DateTime, default=datetime.today)
def __repr__(self):
@@ -80,16 +78,33 @@ class TrenchExcavation(db.Model):
def serialize(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
def excavation_category_sums(self):
# AUTO TOTAL USING REGEX
def calculate_trench_total(mapper, connection, target):
total = Decimal("0.00")
for column in target.__table__.columns:
if RegularExpression.STR_TOTAL_PATTERN.match(column.name):
value = getattr(target, column.name)
if value is not None:
total += Decimal(value)
target.Total = total.quantize(Decimal("0.01"))
def safe(val):
return val or 0
event.listen(TrenchExcavation, "before_insert", calculate_trench_total)
event.listen(TrenchExcavation, "before_update", calculate_trench_total)
return {
"Soft_Murum_Total": (
safe(self.Soft_Murum_0_to_1_5)
+ safe(self.Soft_Murum_1_5_to_3_0)
+ safe(self.Soft_Murum_3_0_to_4_5)
),
"Hard_Murum_Total": (
safe(self.Hard_Murum_0_to_1_5)
+ safe(self.Hard_Murum_1_5_to_3_0)
),
"Soft_Rock_Total": (
safe(self.Soft_Rock_0_to_1_5)
+ safe(self.Soft_Rock_1_5_to_3_0)
),
"Hard_Rock_Total": (
safe(self.Hard_Rock_0_to_1_5)
+ safe(self.Hard_Rock_1_5_to_3_0)
+ safe(self.Hard_Rock_3_0_to_4_5)
+ safe(self.Hard_Rock_4_5_to_6_0)
+ safe(self.Hard_Rock_6_0_to_7_5)
),
}

7
app/models/user_model.py
View File

@@ -5,15 +5,12 @@ class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200), nullable=False)
name = db.Column(db.String(120), nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password_hash = db.Column(db.String(255), nullable=True)
auth_source = db.Column(db.String(20), nullable=False, default="local")
password_hash = db.Column(db.String(255), nullable=False)
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)

21
app/models/width_model.py
View File

@@ -1,21 +0,0 @@
from app import db
class Width(db.Model):
__tablename__ = "width"
id = db.Column(db.Integer, primary_key=True)
Dia_mm = db.Column(db.Numeric(10, 2), default=0)
pipe_150_mm = db.Column(db.Numeric(10, 2), default=0)
pipe_200_mm = db.Column(db.Numeric(10, 2), default=0)
pipe_250_mm = db.Column(db.Numeric(10, 2), default=0)
pipe_300_mm = db.Column(db.Numeric(10, 2), default=0)
pipe_350_mm = db.Column(db.Numeric(10, 2), default=0)
pipe_400_mm = db.Column(db.Numeric(10, 2), default=0)
pipe_450_mm = db.Column(db.Numeric(10, 2), default=0)
pipe_500_mm = db.Column(db.Numeric(10, 2), default=0)
pipe_600_mm = db.Column(db.Numeric(10, 2), default=0)
pipe_700_mm = db.Column(db.Numeric(10, 2), default=0)
pipe_900_mm = db.Column(db.Numeric(10, 2), default=0)
pipe_1200_mm = db.Column(db.Numeric(10, 2), default=0)

59
app/routes/activity_routes.py
View File

@@ -1,59 +0,0 @@
from flask import Blueprint, render_template, request, send_file, abort
import os
from app.utils.helpers import login_required
from app.utils.file_utils import get_logs_folder , ALLOWED_LOG_FILE
from app.services.activity_service import ActivityService
activity_bp = Blueprint("activity", __name__, url_prefix="/activity")
# call activity_log page
@activity_bp.route("/")
@login_required
def activity():
file_name = request.args.get("file", "app.log")
search = request.args.get("search", "")
level = request.args.get("level", "").upper()
user = request.args.get("user", "")
from_date = request.args.get("from_date", "")
to_date = request.args.get("to_date", "")
logs = ActivityService.read_logs(
file_name=file_name,
search=search,
level=level,
user=user,
from_date=from_date,
to_date=to_date
)
return render_template(
"activity/activity_log.html",
logs=logs,
file_name=file_name,
search=search,
level=level,
user=user,
from_date=from_date,
to_date=to_date
)
# Download activity_log files
@activity_bp.route("/logs")
@login_required
def download_log():
filename = request.args.get("file", "app.log")
if filename not in ALLOWED_LOG_FILE:
abort(400, "Invalid log file.")
file_path = os.path.join(get_logs_folder(), filename)
if not os.path.isfile(file_path):
abort(404, "Log file not found.")
return send_file(
file_path,
as_attachment=True,
download_name=filename,
mimetype="text/plain"
)

1
app/routes/auth.py
View File

@@ -16,7 +16,6 @@ def login():
if user:
session["user_id"] = user.id
session["user_name"] = user.name
session["user_email"] = user.email
flash("Login successful", "success")
return redirect(url_for("dashboard.dashboard"))

894
app/routes/dashboard.py
View File

@@ -1,614 +1,308 @@
import matplotlib
matplotlib.use("Agg")
import logging
from flask import Blueprint, render_template, session, redirect, url_for, jsonify, request
import matplotlib.pyplot as plt
import io
import base64
from app.utils.plot_utils import plot_to_base64
from app.utils.helpers import login_required
from app.services.dashboard_service import DashboardService
from sqlalchemy import func
from sqlalchemy import func, union_all
from app import db
from sqlalchemy import tuple_
# Subcontractor models import
from app.models.subcontractor_model import Subcontractor
from app.models.trench_excavation_model import TrenchExcavation
from app.models.manhole_excavation_model import ManholeExcavation
from app.models.manhole_domestic_chamber_model import ManholeDomesticChamber
from app.models.laying_model import Laying
# client models import
from app.models.tr_ex_client_model import TrenchExcavationClient
from app.models.manhole_excavation_model import ManholeExcavation
from app.models.mh_ex_client_model import ManholeExcavationClient
from app.models.mh_dc_client_model import ManholeDomesticChamberClient
from app.models.laying_model import Laying
from app.models.laying_client_model import LayingClient
from app.models.subcontractor_model import Subcontractor
dashboard_bp = Blueprint("dashboard", __name__, url_prefix="/dashboard")
# Configure logging for debugging
logger = logging.getLogger(__name__)
# API to get dynamic filters from database
@dashboard_bp.route("/api/filters")
def get_filters():
try:
logger.info("=" * 60)
logger.info("FETCHING RA BILLS - START")
logger.info("=" * 60)
# 1. Fetch Subcontractors (Linked to Trench entries)
logger.info("Step 1: Fetching Subcontractors...")
subcontractors = db.session.query(Subcontractor.subcontractor_name)\
.join(TrenchExcavation, Subcontractor.id == TrenchExcavation.subcontractor_id)\
.distinct().all()
logger.info(f"✓ Subcontractors found: {len(subcontractors)}")
logger.debug(f" Subcontractor list: {[s[0] for s in subcontractors if s[0]]}")
# 2. Check total records in TrenchExcavation table
logger.info("Step 2: Checking TrenchExcavation table...")
total_records = db.session.query(TrenchExcavation).count()
logger.info(f"✓ Total TrenchExcavation records: {total_records}")
# 3. Check records with RA_Bill_No
logger.info("Step 3: Checking records with RA_Bill_No...")
records_with_ra = db.session.query(TrenchExcavation).filter(TrenchExcavation.RA_Bill_No != None).count()
logger.info(f"✓ Records with RA_Bill_No (not null): {records_with_ra}")
# 4. Check for empty strings
records_with_ra_and_value = db.session.query(TrenchExcavation).filter(
TrenchExcavation.RA_Bill_No != None,
TrenchExcavation.RA_Bill_No != ""
).count()
logger.info(f"✓ Records with RA_Bill_No (not null & not empty): {records_with_ra_and_value}")
# 5. Raw sample of RA_Bill_No values
logger.info("Step 4: Sampling RA_Bill_No values from database...")
sample_bills = db.session.query(TrenchExcavation.RA_Bill_No).limit(10).all()
logger.debug(f" Sample RA_Bill_No values (Subcontractor): {[str(r[0]) for r in sample_bills]}")
sample_bills_client = db.session.query(TrenchExcavationClient.RA_Bill_No).limit(10).all()
logger.debug(f" Sample RA_Bill_No values (Client): {[str(r[0]) for r in sample_bills_client]}")
# 6. Fetch RA Bills from BOTH Subcontractor and Client tables
logger.info("Step 5: Fetching distinct RA Bills from both Subcontractor and Client data...")
# Get RA bills from Subcontractor data
subcon_ra_bills = db.session.query(TrenchExcavation.RA_Bill_No)\
.filter(TrenchExcavation.RA_Bill_No != None)\
.filter(TrenchExcavation.RA_Bill_No != "")\
.distinct()
logger.debug(f" Subcontractor RA Bills (before union): {len(subcon_ra_bills.all())}")
# Get RA bills from Client data
client_ra_bills = db.session.query(TrenchExcavationClient.RA_Bill_No)\
.filter(TrenchExcavationClient.RA_Bill_No != None)\
.filter(TrenchExcavationClient.RA_Bill_No != "")\
.distinct()
logger.debug(f" Client RA Bills (before union): {len(client_ra_bills.all())}")
# Union both queries to get all unique RA bills
ra_bills_union = db.session.query(TrenchExcavation.RA_Bill_No)\
.filter(TrenchExcavation.RA_Bill_No != None)\
.filter(TrenchExcavation.RA_Bill_No != "")\
.union(
db.session.query(TrenchExcavationClient.RA_Bill_No)\
.filter(TrenchExcavationClient.RA_Bill_No != None)\
.filter(TrenchExcavationClient.RA_Bill_No != "")
).order_by(TrenchExcavation.RA_Bill_No).all()
logger.info(f"✓ Distinct RA Bills found (Combined): {len(ra_bills_union)}")
ra_bills_list = [r[0] for r in ra_bills_union if r[0]]
logger.info(f" RA Bills list: {ra_bills_list}")
# 7. Debug: Check data types
if ra_bills_union:
logger.debug(f" First RA Bill value: {ra_bills_union[0][0]}")
logger.debug(f" First RA Bill type: {type(ra_bills_union[0][0])}")
response = {
"subcontractors": [s[0] for s in subcontractors if s[0]],
"ra_bills": ra_bills_list
}
logger.info(f"✓ Response prepared successfully")
logger.info("=" * 60)
return jsonify(response)
except Exception as e:
logger.error("=" * 60)
logger.error(f"ERROR in get_filters(): {str(e)}")
logger.error(f"Error type: {type(e).__name__}")
logger.exception("Full traceback:")
logger.error("=" * 60)
return jsonify({"error": str(e)}), 500
# API for the live abstract data - handles multiple table types
@dashboard_bp.route("/api/excavation-abstract")
def excavation_abstract():
try:
logger.info("=" * 60)
logger.info("EXCAVATION ABSTRACT FETCH - START")
logger.info("=" * 60)
table_type = request.args.get('table_type', 'trench')
subcon_name = request.args.get('subcontractor', 'All')
ra_bill = request.args.get('ra_bill', 'Cumulative')
logger.info(f"Request Parameters:")
logger.info(f" Table Type: {table_type}")
logger.info(f" Subcontractor: {subcon_name}")
logger.info(f" RA Bill: {ra_bill}")
# Select models and match keys based on table type
if table_type == 'trench':
SubconModel = TrenchExcavation
ClientModel = TrenchExcavationClient
table_label = "Trench Excavation"
location_key = 'Location'
mh_key = 'MH_NO'
excavation_columns = [
("Soft Murum", "0-1.5m", "Soft_Murum_0_to_1_5"),
("Soft Murum", "1.5-3.0m", "Soft_Murum_1_5_to_3_0"),
("Soft Murum", "3.0-4.5m", "Soft_Murum_3_0_to_4_5"),
("Hard Murum", "0-1.5m", "Hard_Murum_0_to_1_5"),
("Hard Murum", "1.5-3.0m", "Hard_Murum_1_5_to_3_0"),
("Soft Rock", "0-1.5m", "Soft_Rock_0_to_1_5"),
("Soft Rock", "1.5-3.0m", "Soft_Rock_1_5_to_3_0"),
("Hard Rock", "0-1.5m", "Hard_Rock_0_to_1_5"),
("Hard Rock", "1.5-3.0m", "Hard_Rock_1_5_to_3_0"),
("Hard Rock", "3.0-4.5m", "Hard_Rock_3_0_to_4_5"),
("Hard Rock", "4.5-6.0m", "Hard_Rock_4_5_to_6_0"),
("Hard Rock", "6.0-7.5m", "Hard_Rock_6_0_to_7_5"),
]
elif table_type == 'manhole':
SubconModel = ManholeExcavation
ClientModel = ManholeExcavationClient
table_label = "Manhole Excavation"
location_key = 'Location'
mh_key = 'MH_NO'
excavation_columns = [
("Soft Murum", "0-1.5m", "Soft_Murum_0_to_1_5"),
("Soft Murum", "1.5-3.0m", "Soft_Murum_1_5_to_3_0"),
("Hard Murum", "0-1.5m", "Hard_Murum_0_to_1_5"),
("Hard Murum", "1.5-3.0m", "Hard_Murum_1_5_to_3_0"),
("Soft Rock", "0-1.5m", "Soft_Rock_0_to_1_5"),
("Soft Rock", "1.5-3.0m", "Soft_Rock_1_5_to_3_0"),
("Hard Rock", "0-1.5m", "Hard_Rock_0_to_1_5"),
("Hard Rock", "1.5-3.0m", "Hard_Rock_1_5_to_3_0"),
]
elif table_type == 'laying':
SubconModel = Laying
ClientModel = LayingClient
table_label = "Laying"
location_key = 'Location'
mh_key = 'MH_NO'
excavation_columns = [
("Soft Murum", "0-1.5m", "Soft_Murum_0_to_1_5"),
("Soft Murum", "1.5-3.0m", "Soft_Murum_1_5_to_3_0"),
("Hard Murum", "0-1.5m", "Hard_Murum_0_to_1_5"),
("Hard Murum", "1.5-3.0m", "Hard_Murum_1_5_to_3_0"),
("Soft Rock", "0-1.5m", "Soft_Rock_0_to_1_5"),
("Soft Rock", "1.5-3.0m", "Soft_Rock_1_5_to_3_0"),
("Hard Rock", "0-1.5m", "Hard_Rock_0_to_1_5"),
("Hard Rock", "1.5-3.0m", "Hard_Rock_1_5_to_3_0"),
]
else:
return jsonify({"error": f"Invalid table_type: {table_type}"}), 400
logger.info(f"Using table: {table_label}")
# ===== FETCH SUBCONTRACTOR DATA =====
logger.info(f"Fetching Subcontractor data ({SubconModel.__tablename__})...")
subcon_query = db.session.query(SubconModel)
# Check if SubconModel has subcontractor relationship
if hasattr(SubconModel, 'subcontractor_id'):
subcon_query = subcon_query.join(
Subcontractor, Subcontractor.id == SubconModel.subcontractor_id
)
if subcon_name != 'All':
subcon_query = subcon_query.filter(Subcontractor.subcontractor_name == subcon_name)
subcon_results = subcon_query.all()
logger.info(f" Found {len(subcon_results)} subcontractor records")
# ===== FETCH CLIENT DATA =====
logger.info(f"Fetching Client data ({ClientModel.__tablename__})...")
client_query = db.session.query(ClientModel)
if ra_bill != 'Cumulative' and hasattr(ClientModel, 'RA_Bill_No'):
client_query = client_query.filter(ClientModel.RA_Bill_No == ra_bill)
client_results = client_query.all()
logger.info(f" Found {len(client_results)} client records")
# ===== MATCH RECORDS BY MH_NO AND LOCATION =====
logger.info("Matching records by MH_NO and Location...")
matched_data = {}
# Build a map of client records by MH_NO + Location
client_map = {}
for client_record in client_results:
mh_no = getattr(client_record, mh_key)
location = getattr(client_record, location_key)
key = f"{location}|{mh_no}"
client_map[key] = client_record
logger.info(f" Client map has {len(client_map)} unique MH_NO+Location combinations")
# Match subcontractor records with client records
match_count = 0
for subcon_record in subcon_results:
mh_no = getattr(subcon_record, mh_key)
location = getattr(subcon_record, location_key)
key = f"{location}|{mh_no}"
# Only process if matching client record exists
if key in client_map:
match_count += 1
client_record = client_map[key]
# Aggregate excavation data for this matched pair
for soil, depth, col_name in excavation_columns:
record_key = f"{soil}|{depth}|{location}|{mh_no}"
# Get values
subcon_val = 0
client_val = 0
if hasattr(subcon_record, col_name):
subcon_val = getattr(subcon_record, col_name) or 0
if hasattr(client_record, col_name):
client_val = getattr(client_record, col_name) or 0
# Only add if at least one has data
if subcon_val > 0 or client_val > 0:
if record_key not in matched_data:
matched_data[record_key] = {
"soil_type": soil,
"depth": depth,
"location": location,
"mh_no": mh_no,
"client_qty": 0,
"subcon_qty": 0
}
matched_data[record_key]["client_qty"] += client_val
matched_data[record_key]["subcon_qty"] += subcon_val
logger.info(f" Matched {match_count} subcontractor records with client records")
logger.info(f" Found {len(matched_data)} excavation items with data")
# Calculate differences and format response
data = []
for key, item in matched_data.items():
difference = item["subcon_qty"] - item["client_qty"]
# Format label as: "Soft Murum 0-1.5m (Location - MH_NO)"
label = f"{item['soil_type']} {item['depth']}"
data.append({
"label": label,
"soil_type": item["soil_type"],
"depth": item["depth"],
"location": item["location"],
"mh_no": item["mh_no"],
"client_qty": round(item["client_qty"], 2),
"subcon_qty": round(item["subcon_qty"], 2),
"difference": round(difference, 2)
})
# Sort by location and mh_no for consistency
data.sort(key=lambda x: (x["location"], x["mh_no"], x["soil_type"], x["depth"]))
logger.info(f"Response prepared with {len(data)} matched records")
logger.info("=" * 60)
return jsonify(data)
except Exception as e:
logger.error("=" * 60)
logger.error(f"ERROR in excavation_abstract(): {str(e)}")
logger.error(f"Error type: {type(e).__name__}")
logger.exception("Full traceback:")
logger.error("=" * 60)
return jsonify({"error": str(e)}), 500
@dashboard_bp.route("/")
def dashboard():
if not session.get("user_id"):
return redirect(url_for("auth.login"))
return render_template("dashboard.html", title="Business Intelligence Dashboard")
@dashboard_bp.route("/api/live-stats")
@login_required
def live_stats():
try:
# 1. Overall Volume
t_count = TrenchExcavation.query.count()
m_count = ManholeExcavation.query.count()
l_count = Laying.query.count()
# 2. Location Distribution (Business reach)
loc_results = db.session.query(
TrenchExcavation.Location,
func.count(TrenchExcavation.id)
).group_by(TrenchExcavation.Location).all()
# 3. Work Timeline (Business productivity trend)
# Assuming your models have a 'created_at' field
timeline_results = db.session.query(
func.date(TrenchExcavation.created_at),
func.count(TrenchExcavation.id)
).group_by(func.date(TrenchExcavation.created_at)).order_by(func.date(TrenchExcavation.created_at)).all()
return jsonify({
"summary": {
"trench": t_count,
"manhole": m_count,
"laying": l_count,
"total": t_count + m_count + l_count
},
"locations": {row[0]: row[1] for row in loc_results if row[0]},
"timeline": {str(row[0]): row[1] for row in timeline_results}
})
except Exception as e:
return jsonify({"error": str(e)}), 500
# subcontractor dashboard
@dashboard_bp.route("/subcontractor_dashboard")
@login_required
def subcontractor_dashboard():
if not session.get("user_id"):
return redirect(url_for("auth.login"))
subcontractors = Subcontractor.query.all()
return render_template(
"subcontractor_dashboard.html",
subcontractors=subcontractors
)
# API: Get Unique RA Bills
@dashboard_bp.route("/api/get-ra-bills")
@login_required
def get_ra_bills():
subcontractor_id = request.args.get("subcontractor")
category = request.args.get("category")
if not subcontractor_id or not category:
return {"ra_bills": []}
match category:
case "trench_excavation":
results = db.session.query(
TrenchExcavation.RA_Bill_No
).filter(
TrenchExcavation.subcontractor_id == subcontractor_id
).distinct().order_by(TrenchExcavation.RA_Bill_No).all()
# (Add others same pattern later)
case "manhole_excavation":
results = db.session.query(
ManholeExcavation.RA_Bill_No
).filter(
ManholeExcavation.subcontractor_id == subcontractor_id
).distinct().order_by(ManholeExcavation.RA_Bill_No).all()
case "Manhole_Domestic_Chamber":
results = db.session.query(
ManholeDomesticChamber.RA_Bill_No
).filter(
ManholeDomesticChamber.subcontractor_id == subcontractor_id
).distinct().order_by(ManholeDomesticChamber.RA_Bill_No).all()
case "Laying":
results = db.session.query(
Laying.RA_Bill_No
).filter(
Laying.subcontractor_id == subcontractor_id
).distinct().order_by(Laying.RA_Bill_No).all()
ra_bills = [r[0] for r in results if r[0]]
return {"ra_bills": ra_bills}
def total(records, field):
return float(sum(getattr(r, field) or 0 for r in records))
# category= trench_excavation
@dashboard_bp.route("/api/tr-analysis")
def trench_analysis():
subcontractor_id = request.args.get("subcontractor", "").strip()
ra_bill = request.args.get("ra_bill", "").strip()
# Convert "1,2,3" -> ["1", "2", "3"]
ra_bill_list = []
if ra_bill:
ra_bill_list = [x.strip() for x in ra_bill.split(",") if x.strip()]
# Subcontractor Query
sub_query = TrenchExcavation.query
if subcontractor_id:
sub_query = sub_query.filter(
TrenchExcavation.subcontractor_id == int(subcontractor_id)
)
if ra_bill_list:
sub_query = sub_query.filter(
TrenchExcavation.RA_Bill_No.in_(ra_bill_list)
)
sub_records = sub_query.all()
sub_keys = [
(
(r.MH_NO or "").strip().upper(),
(r.Location or "").strip().upper()
)
for r in sub_records
]
client_query = TrenchExcavationClient.query
if sub_keys:
client_query = client_query.filter(
tuple_(
func.upper(func.trim(TrenchExcavationClient.MH_NO)),
func.upper(func.trim(TrenchExcavationClient.Location))
).in_(sub_keys)
)
client_records = client_query.all()
chart_data = [
{
"label": "Marshi 0 to 1.5",
"client": total(client_records, "Marshi_Muddy_Slushy_0_to_1_5_total"),
"sub": 0
},
{
"label": "Marshi 1.5 to 3.0",
"client": total(client_records, "Marshi_Muddy_Slushy_1_5_to_3_0_total"),
"sub": 0
},
{
"label": "Marshi 3.0 to 4.5",
"client": total(client_records, "Marshi_Muddy_Slushy_3_0_to_4_5_total"),
"sub": 0
},
{
"label": "Soft Murum 0 to 1.5",
"client": total(client_records, "Soft_Murum_0_to_1_5_total"),
"sub": total(sub_records, "Soft_Murum_0_to_1_5_total")
},
{
"label": "Soft Murum 1.5 to 3.0",
"client": total(client_records, "Soft_Murum_1_5_to_3_0_total"),
"sub": total(sub_records, "Soft_Murum_1_5_to_3_0_total")
},
{
"label": "Soft Murum 3.0 to 4.5",
"client": total(client_records, "Soft_Murum_3_0_to_4_5_total"),
"sub": total(sub_records, "Soft_Murum_3_0_to_4_5_total")
},
{
"label": "Hard Murum 0 to 1.5",
"client": total(client_records, "Hard_Murum_0_to_1_5_total"),
"sub": total(sub_records, "Hard_Murum_0_to_1_5_total")
},
{
"label": "Hard Murum 1.5 to 3.0",
"client": total(client_records, "Hard_Murum_1_5_to_3_0_total"),
"sub": total(sub_records, "Hard_Murum_1_5_and_above_total")
},
{
"label": "Soft Rock 0 to 1.5",
"client": total(client_records, "Soft_Rock_0_to_1_5_total"),
"sub": total(sub_records, "Soft_Rock_0_to_1_5_total")
},
{
"label": "Soft Rock 1.5 to 3.0",
"client": total(client_records, "Soft_Rock_1_5_to_3_0_total"),
"sub": total(sub_records, "Soft_Rock_1_5_and_above_total")
},
{
"label": "Hard Rock 0 to 1.5",
"client": total(client_records, "Hard_Rock_0_to_1_5_total"),
"sub": total(sub_records, "Hard_Rock_0_to_1_5_total")
},
{
"label": "Hard Rock 1.5 to 3.0",
"client": total(client_records, "Hard_Rock_1_5_to_3_0_total"),
"sub": total(sub_records, "Hard_Rock_1_5_to_3_0_total")
},
{
"label": "Hard Rock 3.0 to 4.5",
"client": total(client_records, "Hard_Rock_3_0_to_4_5_total"),
"sub": total(sub_records, "Hard_Rock_3_0_to_4_5_total")
},
{
"label": "Hard Rock 4.5 to 6.0",
"client": total(client_records, "Hard_Rock_4_5_to_6_0_total"),
"sub": total(sub_records, "Hard_Rock_4_5_to_6_0_total")
},
{
"label": "Hard Rock 6.0 to 7.5",
"client": total(client_records, "Hard_Rock_6_0_to_7_5_total"),
"sub": total(sub_records, "Hard_Rock_6_0_to_7_5_total")
}
]
return jsonify({
"title": "Trench Excavation Comparison",
"y_title": "Excavation Qty (Cum)",
"labels": [x["label"] for x in chart_data],
"client_qty": [x["client"] for x in chart_data],
"sub_qty": [x["sub"] for x in chart_data]
})
# category = manhole_excavation
@dashboard_bp.route("/api/mh-analysis")
def manhole_analysis():
subcontractor_id = request.args.get("subcontractor", "").strip()
ra_bill = request.args.get("ra_bill", "").strip()
# Convert "1,2,3" -> ["1", "2", "3"]
ra_bill_list = []
if ra_bill:
ra_bill_list = [x.strip() for x in ra_bill.split(",") if x.strip()]
# Subcontractor Query
sub_query = ManholeExcavation.query
if subcontractor_id:
sub_query = sub_query.filter(
ManholeExcavation.subcontractor_id == int(subcontractor_id)
)
if ra_bill_list:
sub_query = sub_query.filter(
ManholeExcavation.RA_Bill_No.in_(ra_bill_list)
)
sub_records = sub_query.all()
sub_keys = [
(
(r.MH_NO or "").strip().upper(),
(r.Location or "").strip().upper()
)
for r in sub_records
]
client_query = ManholeExcavationClient.query
if sub_keys:
client_query = client_query.filter(
tuple_(
func.upper(func.trim(ManholeExcavationClient.MH_NO)),
func.upper(func.trim(ManholeExcavationClient.Location))
).in_(sub_keys)
)
client_records = client_query.all()
chart_data = [
{
"label": "Marshi 0 to 1.5",
"client": total(client_records, "Marshi_Muddy_Slushy_0_to_1_5_total"),
"sub": 0
},
{
"label": "Marshi 1.5 to 3.0",
"client": total(client_records, "Marshi_Muddy_Slushy_1_5_to_3_0_total"),
"sub": 0
},
{
"label": "Marshi 3.0 to 4.5",
"client": total(client_records, "Marshi_Muddy_Slushy_3_0_to_4_5_total"),
"sub": 0
},
{
"label": "Soft Murum 0 to 1.5",
"client": total(client_records, "Soft_Murum_0_to_1_5_total"),
"sub": total(sub_records, "Soft_Murum_0_to_1_5_total")
},
{
"label": "Soft Murum 1.5 to 3.0",
"client": total(client_records, "Soft_Murum_1_5_to_3_0_total"),
"sub": total(sub_records, "Soft_Murum_1_5_to_3_0_total")
},
{
"label": "Soft Murum 3.0 to 4.5",
"client": total(client_records, "Soft_Murum_3_0_to_4_5_total"),
"sub": total(sub_records, "Soft_Murum_3_0_to_4_5_total")
},
{
"label": "Hard Murum 0 to 1.5",
"client": total(client_records, "Hard_Murum_0_to_1_5_total"),
"sub": total(sub_records, "Hard_Murum_0_to_1_5_total")
},
{
"label": "Hard Murum 1.5 to 3.0",
"client": total(client_records, "Hard_Murum_1_5_to_3_0_total"),
"sub": total(sub_records, "Hard_Murum_1_5_and_above_total")
},
{
"label": "Soft Rock 0 to 1.5",
"client": total(client_records, "Soft_Rock_0_to_1_5_total"),
"sub": total(sub_records, "Soft_Rock_0_to_1_5_total")
},
{
"label": "Soft Rock 1.5 to 3.0",
"client": total(client_records, "Soft_Rock_1_5_to_3_0_total"),
"sub": total(sub_records, "Soft_Rock_1_5_and_above_total")
},
{
"label": "Hard Rock 0 to 1.5",
"client": total(client_records, "Hard_Rock_0_to_1_5_total"),
"sub": total(sub_records, "Hard_Rock_0_to_1_5_total")
},
{
"label": "Hard Rock 1.5 to 3.0",
"client": total(client_records, "Hard_Rock_1_5_to_3_0_total"),
"sub": total(sub_records, "Hard_Rock_1_5_to_3_0_total")
},
{
"label": "Hard Rock 3.0 to 4.5",
"client": total(client_records, "Hard_Rock_3_0_to_4_5_total"),
"sub": total(sub_records, "Hard_Rock_3_0_to_4_5_total")
},
{
"label": "Hard Rock 4.5 to 6.0",
"client": total(client_records, "Hard_Rock_4_5_to_6_0_total"),
"sub": total(sub_records, "Hard_Rock_4_5_to_6_0_total")
},
{
"label": "Hard Rock 6.0 to 7.5",
"client": total(client_records, "Hard_Rock_6_0_to_7_5_total"),
"sub": total(sub_records, "Hard_Rock_6_0_to_7_5_total")
}
]
return jsonify({
"title": "Manhole Excavation Comparison",
"y_title": "Manhole Qty (Nos)",
"labels": [x["label"] for x in chart_data],
"client_qty": [x["client"] for x in chart_data],
"sub_qty": [x["sub"] for x in chart_data]
})
# category = Manhole_Domestic_Chamber
@dashboard_bp.route("/api/mdc-analysis")
def Manhole_Domestic_Chamber_analysis():
subcontractor_id = request.args.get("subcontractor", "").strip()
ra_bill = request.args.get("ra_bill", "").strip()
# Convert "1,2,3" -> ["1", "2", "3"]
ra_bill_list = []
if ra_bill:
ra_bill_list = [x.strip() for x in ra_bill.split(",") if x.strip()]
# Subcontractor Query
sub_query = ManholeDomesticChamber.query
if subcontractor_id:
sub_query = sub_query.filter(
ManholeDomesticChamber.subcontractor_id == int(subcontractor_id)
)
if ra_bill_list:
sub_query = sub_query.filter(
ManholeDomesticChamber.RA_Bill_No.in_(ra_bill_list)
)
sub_records = sub_query.all()
sub_keys = [
(
(r.MH_NO or "").strip().upper(),
(r.Location or "").strip().upper()
)
for r in sub_records
]
client_query = ManholeDomesticChamberClient.query
if sub_keys:
client_query = client_query.filter(
tuple_(
func.upper(func.trim(ManholeDomesticChamberClient.MH_NO)),
func.upper(func.trim(ManholeDomesticChamberClient.Location))
).in_(sub_keys)
)
client_records = client_query.all()
chart_data = [
{
"label": "Depth of MH",
"client": total(client_records, "Depth_of_MH"),
"sub": total(sub_records, "Depth_of_MH")
},
{
"label": "Domestic_Chambers Total",
"client": total(client_records, "Total"),
"sub": total(sub_records, "Total")
}
]
return jsonify({
"title": "Domestic Chamber Comparison",
"y_title": "Quantity (Nos)",
"labels": [x["label"] for x in chart_data],
"client_qty": [x["client"] for x in chart_data],
"sub_qty": [x["sub"] for x in chart_data]
})
# category = Laying
@dashboard_bp.route("/api/laying-analysis")
def laying_analysis():
subcontractor_id = request.args.get("subcontractor", "").strip()
ra_bill = request.args.get("ra_bill", "").strip()
# Convert "1,2,3" -> ["1", "2", "3"]
ra_bill_list = []
if ra_bill:
ra_bill_list = [x.strip() for x in ra_bill.split(",") if x.strip()]
# Subcontractor Query
sub_query = Laying.query
if subcontractor_id:
sub_query = sub_query.filter(
Laying.subcontractor_id == int(subcontractor_id)
)
if ra_bill_list:
sub_query = sub_query.filter(
Laying.RA_Bill_No.in_(ra_bill_list)
)
sub_records = sub_query.all()
sub_keys = [
(
(r.MH_NO or "").strip().upper(),
(r.Location or "").strip().upper()
)
for r in sub_records
]
client_query = LayingClient.query
if sub_keys:
client_query = client_query.filter(
tuple_(
func.upper(func.trim(LayingClient.MH_NO)),
func.upper(func.trim(LayingClient.Location))
).in_(sub_keys)
)
client_records = client_query.all()
chart_data = [
{
"label": "150 mm",
"client": total(client_records, "pipe_150_mm"),
"sub": total(sub_records, "pipe_150_mm")
},
{
"label": "200 mm",
"client": total(client_records, "pipe_200_mm"),
"sub": total(sub_records, "pipe_200_mm")
},
{
"label": "250 mm",
"client": total(client_records, "pipe_250_mm"),
"sub": total(sub_records, "pipe_250_mm")
},
{
"label": "300 mm",
"client": total(client_records, "pipe_300_mm"),
"sub": total(sub_records, "pipe_300_mm")
},
{
"label": "350 mm",
"client": total(client_records, "pipe_350_mm"),
"sub": total(sub_records, "pipe_350_mm")
},
{
"label": "400 mm",
"client": total(client_records, "pipe_400_mm"),
"sub": total(sub_records, "pipe_400_mm")
},
{
"label": "450 mm",
"client": total(client_records, "pipe_450_mm"),
"sub": total(sub_records, "pipe_450_mm")
},
{
"label": "500 mm",
"client": total(client_records, "pipe_500_mm"),
"sub": total(sub_records, "pipe_500_mm")
},
{
"label": "600 mm",
"client": total(client_records, "pipe_600_mm"),
"sub": total(sub_records, "pipe_600_mm")
},
{
"label": "700 mm",
"client": total(client_records, "pipe_700_mm"),
"sub": total(sub_records, "pipe_700_mm")
},
{
"label": "900 mm",
"client": total(client_records, "pipe_900_mm"),
"sub": total(sub_records, "pipe_900_mm")
},
{
"label": "1200 mm",
"client": total(client_records, "pipe_1200_mm"),
"sub": total(sub_records, "pipe_1200_mm")
}
]
return jsonify({
"title": "Pipe Laying Comparison",
"y_title": "Pipe Length (Mtr)",
"labels": [x["label"] for x in chart_data],
"client_qty": [x["client"] for x in chart_data],
"sub_qty": [x["sub"] for x in chart_data]
})
return render_template("dashboard.html", title="Live Excavation Dashboard")

56
app/routes/engineering_master_routes.py
View File

@@ -1,56 +0,0 @@
from flask import (
Blueprint,
render_template,
request,
redirect,
url_for,
flash
)
from app.models.subcontractor_model import Subcontractor
from app.services.subcontractor_rate_service import SubcontractorRateService
from app.constants.messages import SuccessMessage, ErrorMessage
engi_bp = Blueprint(
"engineering",
__name__,
url_prefix="/engi"
)
@engi_bp.route("/")
def engineering_master():
return render_template(
"engineering/index.html",
title="Engineering Masters"
)
@engi_bp.route("/subcontractor-rate")
def add_subcontractor_rates():
subcontractors = Subcontractor.query.filter_by(status="Active").all()
if request.method == "POST":
try:
SubcontractorRateService.save_rate(request.form)
flash(SuccessMessage.SAVE, "success")
return redirect(url_for("engineering.add_subcontractor_rates"))
except Exception as e:
flash(ErrorMessage.INTERNAL_SERVER_ERROR, "danger")
return render_template(
"engineering/add_rate.html",
title="Subcontractor Rate Master",
subcontractors=subcontractors
)
@engi_bp.route("/client-rate")
def client_rates():
return render_template(
"engineering/client_rate.html",
title="Client Rate Master"
)

6
app/routes/file_format.py
View File

@@ -1,6 +1,5 @@
from flask import Blueprint, render_template, send_from_directory, abort, current_app
from app.utils.helpers import login_required
from app.utils.file_utils import get_download_format_folder
import os
file_format_bp = Blueprint("file_format", __name__)
@@ -15,7 +14,10 @@ def download_format():
@login_required
def download_excel_format(filename):
download_folder = get_download_format_folder()
download_folder = os.path.join(
current_app.root_path, "static", "downloads/format"
)
file_path = os.path.join(download_folder, filename)
if not os.path.exists(file_path):

670
app/routes/file_report.py
View File

@@ -1,12 +1,11 @@
import pandas as pd
import io
from flask import Blueprint, render_template, request, send_file, flash, jsonify,redirect, url_for
import logging
from flask import Blueprint, render_template, request, send_file, flash
from app.utils.helpers import login_required
from app.utils.regex_utils import RegularExpression
from app import db
import re
from app.models.subcontractor_model import Subcontractor
from app.models.manhole_excavation_model import ManholeExcavation
from app.models.trench_excavation_model import TrenchExcavation
from app.models.manhole_domestic_chamber_model import ManholeDomesticChamber
@@ -17,319 +16,12 @@ from app.models.tr_ex_client_model import TrenchExcavationClient
from app.models.mh_dc_client_model import ManholeDomesticChamberClient
from app.models.laying_client_model import LayingClient
from app.services.abstract_service import AbstractReportService
# --- BLUEPRINT DEFINITION ---
file_report_bp = Blueprint("file_report", __name__, url_prefix="/file")
# ---------------- ACTION COLUMN ----------------
def add_action_columns(df, model_key):
if df.empty:
return df
df.insert(0, "Select", df["Id"].apply(
lambda x: f'<input type="checkbox" class="row-check" data-id="{x}">'
))
df["Update"] = df["Id"].apply(
lambda x: f'<a href="/file/edit/{model_key}/{x}" class="btn btn-sm btn-warning edit-btn"><i class="bi bi-pencil-square"></i> Edit</a>'
)
df["Delete"] = df["Id"].apply(
lambda x: f'<button class="btn btn-sm btn-danger delete-btn" data-id="{x}" data-model="{model_key}">Delete</button>'
)
return df
# ---------------- FETCH ----------------
class SubcontractorBill:
def __init__(self):
self.df_tr = pd.DataFrame()
self.df_mh = pd.DataFrame()
self.df_dc = pd.DataFrame()
self.df_laying = pd.DataFrame()
# self.df_abstract = pd.DataFrame() # NEW
def Fetch(self, RA_Bill_No=None, subcontractor_id=None, location=None):
filters = {}
if subcontractor_id:
filters["subcontractor_id"] = subcontractor_id
if RA_Bill_No:
filters["RA_Bill_No"] = RA_Bill_No
# Fetch data in database
trench = TrenchExcavation.query.filter_by(**filters).all()
mh = ManholeExcavation.query.filter_by(**filters).all()
dc = ManholeDomesticChamber.query.filter_by(**filters).all()
lay = Laying.query.filter_by(**filters).all()
# LOCATION FILTER
if location:
search = location.strip().lower()
print("location::",search)
trench = [
t for t in trench
if search in (t.Location or "").strip().lower()
]
mh = [
t for t in mh
if search in (t.Location or "").strip().lower()
]
dc = [
t for t in dc
if search in (t.Location or "").strip().lower()
]
lay = [
t for t in lay
if search in (t.Location or "").strip().lower()
]
# Set dataframe
self.df_tr = pd.DataFrame([c.serialize() for c in trench])
self.df_mh = pd.DataFrame([c.serialize() for c in mh])
self.df_dc = pd.DataFrame([c.serialize() for c in dc])
self.df_laying = pd.DataFrame([c.serialize() for c in lay])
drop_cols = ["11", "_sa_instance_state", "subcontractor_id" , "created_at"]
for df in [self.df_tr, self.df_mh, self.df_dc, self.df_laying]:
if not df.empty:
df.drop(columns=drop_cols, errors="ignore", inplace=True)
format_column_names(df)
name = ""
if subcontractor_id:
sc = Subcontractor.query.get(subcontractor_id)
if sc:
name = sc.subcontractor_name
# ---------------- DELETE ----------------
@file_report_bp.route("/delete_records", methods=["POST"])
@login_required
def delete_records():
data = request.json or {}
model = data.get("model")
ids = data.get("ids", [])
model_map = {
"tr": TrenchExcavation,
"mh": ManholeExcavation,
"dc": ManholeDomesticChamber,
"laying": Laying
}
ModelClass = model_map.get(model)
# validate model BEFORE using it
if not ModelClass:
return jsonify({"status": "error", "message": f"Invalid model '{model}'"}), 400
if not ids:
return jsonify({"status": "error", "message": "No IDs provided"}), 400
try:
for record_id in ids:
obj = ModelClass.query.get(record_id)
if obj:
db.session.delete(obj)
db.session.commit()
return jsonify({"status": "success"})
except Exception as e:
db.session.rollback()
return jsonify({"status": "error", "message": str(e)}), 500
@file_report_bp.route("/edit/<string:model>/<int:record_id>", methods=["GET", "POST"])
@login_required
def edit_record(model, record_id):
model_map = {
"tr": TrenchExcavation,
"mh": ManholeExcavation,
"dc": ManholeDomesticChamber,
"laying": Laying
}
ModelClass = model_map.get(model)
if not ModelClass:
flash("Invalid Model.", "danger")
return redirect(url_for("file_report.report_file"))
record = ModelClass.query.get_or_404(record_id)
if request.method == "POST":
# Update all fields except id
for column in record.__table__.columns:
if column.name == "id":
continue
if column.name in request.form:
setattr(record, column.name, request.form.get(column.name))
try:
db.session.commit()
flash("Record updated successfully.", "success")
# ✅ fixed: correct blueprint name
return redirect(url_for("file_report.report_file"))
except Exception as e:
db.session.rollback()
flash(str(e), "danger")
return render_template(
"edit_record.html",
record=record,
model=model
)
@file_report_bp.route("/Subcontractor_report", methods=["GET", "POST"])
@login_required
def report_file():
# get all subcontractor data
subcontractors = Subcontractor.query.all()
tables = None
abstract_html = ""
selected_sc_id = None
ra_bill_no = ""
location = ""
category = ""
# Search or load data
if request.method == "POST":
# get from data
subcontractor_id = request.form.get("subcontractor_id")
ra_bill_no = request.form.get("ra_bill_no", "").strip()
location = request.form.get("location", "").strip()
category = request.form.get("category", "")
action = request.form.get("action", "preview")
if not subcontractor_id:
flash("Select Subcontractor", "danger")
return render_template(
"subcontractor_report.html",
subcontractors=subcontractors
)
selected_sc_id = subcontractor_id
bill = SubcontractorBill()
if action == "excel_all":
bill.Fetch(subcontractor_id=subcontractor_id)
else:
bill.Fetch(ra_bill_no,subcontractor_id,location)
# -----------------------------------------
# Generate Abstract Report for Web
# -----------------------------------------
abstract_service = AbstractReportService(
subcontractor_id=subcontractor_id,
ra_bill_no=ra_bill_no
)
abstract_html = abstract_service.generate_html()
# ---------------- CATEGORY FILTER ----------------
if category == "tr":
bill.df_mh = bill.df_dc = bill.df_laying = pd.DataFrame()
elif category == "mh":
bill.df_tr = bill.df_dc = bill.df_laying = pd.DataFrame()
elif category == "dc":
bill.df_tr = bill.df_mh = bill.df_laying = pd.DataFrame()
elif category == "laying":
bill.df_tr = bill.df_mh = bill.df_dc = pd.DataFrame()
# ===================================================
# DOWNLOAD EXCEL
# ===================================================
if action in ["excel", "excel_all"]:
output = io.BytesIO()
with pd.ExcelWriter(output,engine="xlsxwriter") as writer:
workbook = writer.book
abstract = AbstractReportService(subcontractor_id=subcontractor_id,ra_bill_no=ra_bill_no)
abstract.generate(workbook)
bill.df_tr.to_excel(writer,sheet_name="Tr.Ex",index=False)
bill.df_mh.to_excel(writer,sheet_name="Mh.Ex",index=False)
bill.df_dc.to_excel(writer,sheet_name="MH & DC",index=False)
bill.df_laying.to_excel(writer,sheet_name="Pipe Laying",index=False)
writer.close()
output.seek(0)
return send_file(
output,
download_name= "subcontractor_Report.xlsx",
as_attachment=True
)
# ===================================================
# PDF
# ===================================================
if action == "pdf":
flash(
"PDF Export Coming Soon.",
"info"
)
# ===================================================
# ADD ACTIONS
# ===================================================
bill.df_tr = add_action_columns(bill.df_tr, "tr")
bill.df_mh = add_action_columns(bill.df_mh, "mh")
bill.df_dc = add_action_columns(bill.df_dc, "dc")
bill.df_laying = add_action_columns(bill.df_laying, "laying")
# this are html classes
# table_class = ( "table " "table-bordered" "table-hover " "table-striped " "table-sm " "align-middle " "datatable " "mb-0")
table_class = (
"table "
"table-bordered "
"table-hover "
"table-striped "
"table-sm "
"align-middle "
"datatable "
"text-nowrap "
"mb-0"
)
# This are showing on web tables
tables = {
"tr": bill.df_tr.to_html(classes=table_class, index=False, escape=False),
"mh": bill.df_mh.to_html(classes=table_class, index=False, escape=False),
"dc": bill.df_dc.to_html(classes=table_class, index=False, escape=False ),
"laying": bill.df_laying.to_html(classes=table_class, index=False, escape=False)
}
return render_template(
"subcontractor_report.html",
subcontractors=subcontractors,
selected_sc_id=selected_sc_id,
selected_ra_bill=ra_bill_no,
selected_location=location,
selected_category=category,
tables=tables,
abstract_html=abstract_html
)
# Configure logging for debugging
logger = logging.getLogger(__name__)
# --- Client class ---
class ClientBill:
@@ -340,170 +32,266 @@ class ClientBill:
self.df_laying = pd.DataFrame()
def Fetch(self, RA_Bill_No):
trench = TrenchExcavationClient.query.filter_by(RA_Bill_No=RA_Bill_No).all()
mh = ManholeExcavationClient.query.filter_by(RA_Bill_No=RA_Bill_No).all()
dc = ManholeDomesticChamberClient.query.filter_by(RA_Bill_No=RA_Bill_No).all()
lay = LayingClient.query.filter_by(RA_Bill_No=RA_Bill_No).all()
logger.info("=" * 60)
logger.info("ClientBill.Fetch() - START")
logger.info("=" * 60)
logger.info(f"Fetching data for RA_Bill_No: '{RA_Bill_No}'")
logger.debug(f" Type of RA_Bill_No: {type(RA_Bill_No)}")
try:
logger.info("Step 1: Fetching TrenchExcavationClient records...")
trench = TrenchExcavationClient.query.filter_by(RA_Bill_No=RA_Bill_No).all()
logger.info(f"✓ Trench records found: {len(trench)}")
logger.info("Step 2: Fetching ManholeExcavationClient records...")
mh = ManholeExcavationClient.query.filter_by(RA_Bill_No=RA_Bill_No).all()
logger.info(f"✓ Manhole records found: {len(mh)}")
logger.info("Step 3: Fetching ManholeDomesticChamberClient records...")
dc = ManholeDomesticChamberClient.query.filter_by(RA_Bill_No=RA_Bill_No).all()
logger.info(f"✓ Domestic Chamber records found: {len(dc)}")
logger.info("Step 4: Fetching LayingClient records...")
lay = LayingClient.query.filter_by(RA_Bill_No=RA_Bill_No).all()
logger.info(f"✓ Laying records found: {len(lay)}")
logger.info("Step 5: Converting to DataFrames...")
self.df_tr = pd.DataFrame([c.serialize() for c in trench])
self.df_mh = pd.DataFrame([c.serialize() for c in mh])
self.df_dc = pd.DataFrame([c.serialize() for c in dc])
self.df_laying = pd.DataFrame([c.serialize() for c in lay])
logger.debug(f" Trench DF shape: {self.df_tr.shape}")
logger.debug(f" Manhole DF shape: {self.df_mh.shape}")
logger.debug(f" Domestic Chamber DF shape: {self.df_dc.shape}")
logger.debug(f" Laying DF shape: {self.df_laying.shape}")
logger.info("Step 6: Cleaning DataFrames...")
drop_cols = ["id", "created_at", "_sa_instance_state"]
for df in [self.df_tr, self.df_mh, self.df_dc, self.df_laying]:
if not df.empty:
df.drop(columns=drop_cols, errors="ignore", inplace=True)
logger.debug(f" Cleaned DF with shape: {df.shape}")
logger.info("✓ ClientBill.Fetch() completed successfully")
logger.info("=" * 60)
except Exception as e:
logger.error("=" * 60)
logger.error(f"ERROR in ClientBill.Fetch(): {str(e)}")
logger.error(f"Error type: {type(e).__name__}")
logger.exception("Full traceback:")
logger.error("=" * 60)
raise
# --- Subcontractor class ---
class SubcontractorBill:
def __init__(self):
self.df_tr = pd.DataFrame()
self.df_mh = pd.DataFrame()
self.df_dc = pd.DataFrame()
self.df_laying = pd.DataFrame()
def Fetch(self, RA_Bill_No=None, subcontractor_id=None):
logger.info("=" * 60)
logger.info("SubcontractorBill.Fetch() - START")
logger.info("=" * 60)
logger.info(f"Parameters:")
logger.info(f" RA_Bill_No: '{RA_Bill_No}' (type: {type(RA_Bill_No)})")
logger.info(f" subcontractor_id: '{subcontractor_id}' (type: {type(subcontractor_id)})")
try:
filters = {}
if subcontractor_id:
filters["subcontractor_id"] = subcontractor_id
logger.debug(f" Added filter - subcontractor_id: {subcontractor_id}")
if RA_Bill_No:
filters["RA_Bill_No"] = RA_Bill_No
logger.debug(f" Added filter - RA_Bill_No: {RA_Bill_No}")
logger.info(f"Applied filters: {filters}")
logger.info("Step 1: Fetching TrenchExcavation records...")
trench = TrenchExcavation.query.filter_by(**filters).all()
logger.info(f"✓ Trench records found: {len(trench)}")
logger.info("Step 2: Fetching ManholeExcavation records...")
mh = ManholeExcavation.query.filter_by(**filters).all()
logger.info(f"✓ Manhole records found: {len(mh)}")
logger.info("Step 3: Fetching ManholeDomesticChamber records...")
dc = ManholeDomesticChamber.query.filter_by(**filters).all()
logger.info(f"✓ Domestic Chamber records found: {len(dc)}")
logger.info("Step 4: Fetching Laying records...")
lay = Laying.query.filter_by(**filters).all()
logger.info(f"✓ Laying records found: {len(lay)}")
logger.info("Step 5: Converting to DataFrames...")
self.df_tr = pd.DataFrame([c.serialize() for c in trench])
self.df_mh = pd.DataFrame([c.serialize() for c in mh])
self.df_dc = pd.DataFrame([c.serialize() for c in dc])
self.df_laying = pd.DataFrame([c.serialize() for c in lay])
logger.debug(f" Trench DF shape: {self.df_tr.shape}")
logger.debug(f" Manhole DF shape: {self.df_mh.shape}")
logger.debug(f" Domestic Chamber DF shape: {self.df_dc.shape}")
logger.debug(f" Laying DF shape: {self.df_laying.shape}")
logger.info("Step 6: Cleaning DataFrames...")
drop_cols = ["id", "created_at", "_sa_instance_state"]
for df in [self.df_tr, self.df_mh, self.df_dc, self.df_laying]:
if not df.empty:
df.drop(columns=drop_cols, errors="ignore", inplace=True)
logger.debug(f" Cleaned DF with shape: {df.shape}")
logger.info("✓ SubcontractorBill.Fetch() completed successfully")
logger.info("=" * 60)
except Exception as e:
logger.error("=" * 60)
logger.error(f"ERROR in SubcontractorBill.Fetch(): {str(e)}")
logger.error(f"Error type: {type(e).__name__}")
logger.exception("Full traceback:")
logger.error("=" * 60)
raise
# --- subcontractor report only ---
@file_report_bp.route("/Subcontractor_report", methods=["GET", "POST"])
@login_required
def report_file():
subcontractors = Subcontractor.query.all()
tables = None
selected_sc_id = None
ra_bill_no = None
download_all = False
# --- CLIENT REPORT (PREVIEW + DOWNLOAD) ---
if request.method == "POST":
subcontractor_id = request.form.get("subcontractor_id")
ra_bill_no = request.form.get("ra_bill_no")
download_all = request.form.get("download_all") == "true"
action = request.form.get("action")
if not subcontractor_id:
flash("Please select a subcontractor.", "danger")
return render_template("subcontractor_report.html", subcontractors=subcontractors)
subcontractor = Subcontractor.query.get(subcontractor_id)
bill_gen = SubcontractorBill()
if download_all:
bill_gen.Fetch(subcontractor_id=subcontractor_id)
file_name = f"{subcontractor.subcontractor_name}_ALL_BILLS.xlsx"
else:
if not ra_bill_no:
flash("Please enter an RA Bill Number.", "danger")
return render_template("subcontractor_report.html", subcontractors=subcontractors)
bill_gen.Fetch(RA_Bill_No=ra_bill_no, subcontractor_id=subcontractor_id)
file_name = f"{subcontractor.subcontractor_name}_RA_{ra_bill_no}_Report.xlsx"
if bill_gen.df_tr.empty and bill_gen.df_mh.empty and bill_gen.df_dc.empty:
flash("No data found for this selection.", "warning")
return render_template("subcontractor_report.html", subcontractors=subcontractors)
# If download is clicked, return file immediately
if action == "download":
output = io.BytesIO()
with pd.ExcelWriter(output, engine="xlsxwriter") as writer:
bill_gen.df_tr.to_excel(writer, index=False, sheet_name="Tr.Ex.")
bill_gen.df_mh.to_excel(writer, index=False, sheet_name="MH.Ex.")
bill_gen.df_dc.to_excel(writer, index=False, sheet_name="MH & DC")
bill_gen.df_laying.to_excel(writer, index=False, sheet_name="Laying")
output.seek(0)
return send_file(output, download_name=file_name, as_attachment=True)
# We add bootstrap classes directly to the pandas output
table_classes = "table table-bordered table-striped table-hover table-sm mb-0"
tables = {
"tr": bill_gen.df_tr.to_html(classes=table_classes, index=False),
"mh": bill_gen.df_mh.to_html(classes=table_classes, index=False),
"dc": bill_gen.df_dc.to_html(classes=table_classes, index=False),
"laying": bill_gen.df_laying.to_html(classes=table_classes, index=False)
}
selected_sc_id = subcontractor_id
return render_template(
"subcontractor_report.html",
subcontractors=subcontractors,
tables=tables,
selected_sc_id=selected_sc_id,
ra_bill_no=ra_bill_no,
download_all=download_all
)
# --- client report only ---
@file_report_bp.route("/client_report", methods=["GET", "POST"])
@login_required
def client_report():
tables = {"tr": None, "mh": None, "dc": None, "laying": None}
def client_vs_all_subcontractor():
tables = {"tr": None, "mh": None, "dc": None}
ra_val = ""
if request.method == "POST":
# ⚠ MUST match HTML name
RA_Bill_No = request.form.get("RA_Bill_No")
action = request.form.get("action")
ra_val = RA_Bill_No
if not RA_Bill_No:
flash("Please enter RA Bill No.", "danger")
return render_template("client_report.html", tables=tables, ra_val=ra_val)
# -------- FETCH CLIENT DATA --------
bill_gen = ClientBill()
bill_gen.Fetch(RA_Bill_No)
clientBill = ClientBill()
clientBill.Fetch(RA_Bill_No=RA_Bill_No)
contractorBill = SubcontractorBill()
contractorBill.Fetch(RA_Bill_No=RA_Bill_No)
# If no data
if (
bill_gen.df_tr.empty and
bill_gen.df_mh.empty and
bill_gen.df_dc.empty and
bill_gen.df_laying.empty
):
# --- SAFETY CHECK: Verify data exists before merging ---
if clientBill.df_tr.empty and clientBill.df_mh.empty:
flash(f"No Client records found for RA Bill {RA_Bill_No}", "warning")
return render_template("client_report.html", tables=tables, ra_val=ra_val)
# -------- DOWNLOAD --------
if action == "download":
qty_cols = [...] # (Keep your existing list)
mh_dc_qty_cols = [...] # (Keep your existing list)
mh_lay_qty_cols =[...]
output = io.BytesIO()
def aggregate_df(df, group_cols, sum_cols):
if df.empty:
# Create an empty DF with the correct columns to avoid Merge/Key Errors
return pd.DataFrame(columns=group_cols + sum_cols)
existing_cols = [c for c in sum_cols if c in df.columns]
# Ensure group_cols exist in the DF
for col in group_cols:
if col not in df.columns:
df[col] = "N/A" # Fill missing join keys
return df.groupby(group_cols, as_index=False)[existing_cols].sum()
with pd.ExcelWriter(output, engine="xlsxwriter") as writer:
bill_gen.df_tr.to_excel(writer, index=False, sheet_name="Trench")
bill_gen.df_mh.to_excel(writer, index=False, sheet_name="MH")
bill_gen.df_dc.to_excel(writer, index=False, sheet_name="MH & DC")
bill_gen.df_laying.to_excel(writer, index=False, sheet_name="Laying")
# Aggregate data
df_sub_tr_grp = aggregate_df(contractorBill.df_tr, ["Location", "MH_NO"], qty_cols)
df_sub_mh_grp = aggregate_df(contractorBill.df_mh, ["Location", "MH_NO"], qty_cols)
df_sub_dc_grp = aggregate_df(contractorBill.df_dc, ["Location", "MH_NO"], mh_dc_qty_cols)
df_sub_lay_grp = aggregate_df(contractorBill.df_dc, ["Location", "MH_NO"], mh_lay_qty_cols)
output.seek(0)
return send_file(
output,
download_name=f"Client_RA_{RA_Bill_No}_Report.xlsx",
as_attachment=True
)
# -------- PREVIEW --------
table_class = "table table-bordered table-striped table-hover table-sm"
tables["tr"] = bill_gen.df_tr.to_html(classes=table_class, index=False)
tables["mh"] = bill_gen.df_mh.to_html(classes=table_class, index=False)
tables["dc"] = bill_gen.df_dc.to_html(classes=table_class, index=False)
tables["laying"] = bill_gen.df_laying.to_html(classes=table_class, index=False)
# --- FINAL MERGE LOGIC ---
# We check if "Location" exists in the client data. If not, we add it to prevent the KeyError.
for df_client in [clientBill.df_tr, clientBill.df_mh, clientBill.df_dc, clientBill.df_laying ]:
if not df_client.empty and "Location" not in df_client.columns:
df_client["Location"] = "Unknown"
try:
df_tr_cmp = clientBill.df_tr.merge(df_sub_tr_grp, on=["Location", "MH_NO"], how="left", suffixes=("_Client", "_Sub"))
df_mh_cmp = clientBill.df_mh.merge(df_sub_mh_grp, on=["Location", "MH_NO"], how="left", suffixes=("_Client", "_Sub"))
df_dc_cmp = clientBill.df_dc.merge(df_sub_dc_grp, on=["Location", "MH_NO"], how="left", suffixes=("_Client", "_Sub"))
df_lay_cmp = clientBill.df_laying.merge(df_sub_lay_grp, on=["Location", "MH_NO"], how="left", suffixes=("_Client", "_Sub"))
except KeyError as e:
flash(f"Merge Error: Missing column {str(e)}. Check if 'Location' is defined in your database models.", "danger")
return render_template("client_report.html", tables=tables, ra_val=ra_val)
def format_column_names(df):
if df.empty:
return df
# Convert to HTML for preview
tables["tr"] = df_tr_cmp.to_html(classes='table table-striped table-hover table-sm', index=False)
tables["mh"] = df_mh_cmp.to_html(classes='table table-striped table-hover table-sm', index=False)
tables["dc"] = df_dc_cmp.to_html(classes='table table-striped table-hover table-sm', index=False)
tables["laying"] = df_lay_cmp.to_html(classes='table table-striped table-hover table-sm', index=False)
new_columns = []
for col in df.columns:
return render_template("client_report.html", tables=tables, ra_val=ra_val)
# ----------------------------------------
# Pipe columns
# pipe_150_mm -> Pipe 150 MM
# ----------------------------------------
if RegularExpression.PIPE_MM_PATTERN.match(col):
m = re.match(r"pipe_(\d+)_mm", col)
new_columns.append(f"Pipe {m.group(1)} MM")
continue
# ----------------------------------------
# Domestic Chamber
# d_0_to_0_75 -> 0.00 To 0.75
# d_1_5_to_3_0 -> 1.50 To 3.00
# ----------------------------------------
if RegularExpression.D_RANGE_PATTERN.match(col):
value = col[2:] # remove d_
value = re.sub(
r'(\d+)_(\d+)',
lambda m: f"{m.group(1)}.{m.group(2)}",
value
)
value = value.replace("_to_", " To ")
new_columns.append(value)
continue
# ----------------------------------------
# Total columns
# Soft_Murum_0_to_1_5_total
# ->
# Soft Murum 0 To 1.5 Total
# ----------------------------------------
if RegularExpression.STR_TOTAL_PATTERN.match(col):
value = col[:-6] # remove _total
value = re.sub(
r'(\d+)_(\d+)',
lambda m: f"{m.group(1)}.{m.group(2)}",
value
)
value = value.replace("_to_", " To ")
value = value.replace("_", " ")
new_columns.append(value.title() + " Total")
continue
# ----------------------------------------
# General columns
# ----------------------------------------
value = col.replace("_", " ").title()
replacements = {
"Mh No": "MH No",
"Ra Bill No": "RA Bill No",
"Cc Length": "CC Length",
"Id Of Mh M": "ID of MH (m)",
"Pipe Dia Mm": "Pipe Dia (MM)",
"Mh Top Level": "MH Top Level",
"Upto Il Depth": "Upto IL Depth",
"Actual Trench Length": "Actual Trench Length",
"Ground Level": "Ground Level",
"Invert Level": "Invert Level",
"Ex Dia Of Manhole": "External Dia of Manhole",
"Area Of Manhole": "Area of Manhole",
"Depth Of Mh": "Depth of MH",
}
value = replacements.get(value, value)
new_columns.append(value)
df.columns = new_columns
return df

155
app/routes/generate_comparison_report.py
View File

@@ -2,27 +2,31 @@ from flask import Blueprint, render_template, request, send_file, flash
from collections import defaultdict
import pandas as pd
import io
from app.utils.helpers import login_required
from app.utils.regex_utils import RegularExpression
# Contractor models import
from app.models.subcontractor_model import Subcontractor
from app.models.trench_excavation_model import TrenchExcavation
from app.models.manhole_excavation_model import ManholeExcavation
from app.models.manhole_domestic_chamber_model import ManholeDomesticChamber
from app.models.laying_model import Laying
# Client models import
from app.models.tr_ex_client_model import TrenchExcavationClient
from app.models.mh_ex_client_model import ManholeExcavationClient
from app.models.mh_dc_client_model import ManholeDomesticChamberClient
from app.models.laying_client_model import LayingClient
from app.utils.helpers import login_required
import re
generate_report_bp = Blueprint("generate_report", __name__, url_prefix="/report")
# sum field of pipe laying (pipe_150_mm)
PIPE_MM_PATTERN = re.compile(r"^pipe_\d+_mm$")
# sum fields of MH dc (d_0_to_0_75)
D_RANGE_PATTERN = re.compile( r"^d_\d+(?:_\d+)?_to_\d+(?:_\d+)?$")
# NORMALIZER
def normalize_key(value):
if value is None:
@@ -76,7 +80,6 @@ def build_comparison(client_rows, contractor_rows, key_field):
used_index = defaultdict(int) # 🔥 THIS FIXES YOUR ISSUE
for c in client_rows:
client_location = normalize_key(c.get("Location"))
client_key = normalize_key(c.get(key_field))
@@ -101,16 +104,16 @@ def build_comparison(client_rows, contractor_rows, key_field):
float(v or 0)
for k, v in c.items()
if k.endswith("_total")
or RegularExpression.D_RANGE_PATTERN.match(k)
or RegularExpression.PIPE_MM_PATTERN.match(k)
or D_RANGE_PATTERN.match(k)
or PIPE_MM_PATTERN.match(k)
)
sub_total = sum(
float(v or 0)
for k, v in s.items()
if k.endswith("_total")
or RegularExpression.D_RANGE_PATTERN.match(k)
or RegularExpression.PIPE_MM_PATTERN.match(k)
or D_RANGE_PATTERN.match(k)
or PIPE_MM_PATTERN.match(k)
)
row = {
@@ -135,36 +138,26 @@ def build_comparison(client_rows, contractor_rows, key_field):
output.append(row)
df = pd.DataFrame(output)
# formatting headers
df.columns = [format_header(col) for col in df.columns]
return df
# EXCEL SHEET WRITER
def write_sheet(writer, df, sheet_name, subcontractor_name):
workbook = writer.book
# write dataframe (data already correct)
df.to_excel(writer, sheet_name=sheet_name, index=False, startrow=3)
ws = writer.sheets[sheet_name]
# formats
title_fmt = workbook.add_format({"bold": True, "font_size": 14})
client_fmt = workbook.add_format({"bold": True, "border": 1, "bg_color": "#D9EDF7"})
sub_fmt = workbook.add_format({"bold": True, "border": 1, "bg_color": "#F7E1D9"})
total_fmt = workbook.add_format({"bold": True, "border": 1, "bg_color": "#FFF2CC"})
diff_fmt = workbook.add_format({"bold": True, "border": 1, "bg_color": "#E2EFDA"})
default_header_fmt = workbook.add_format({
"bold": True,
"border": 1,
"bg_color": "#E7E6E6",
"align": "center",
"valign": "vcenter"
})
client_fmt = workbook.add_format({"bold": True, "border": 1, "bg_color": "#B6DAED"})
sub_fmt = workbook.add_format({"bold": True, "border": 1, "bg_color": "#F3A081"})
total_fmt = workbook.add_format({"bold": True, "border": 1, "bg_color": "#F7D261"})
diff_fmt = workbook.add_format({"bold": True, "border": 1, "bg_color": "#82DD49"})
default_header_fmt = workbook.add_format({"bold": True,"border": 1,"bg_color": "#E7E6E6","align": "center","valign": "vcenter"})
# titles
ws.merge_range(
0, 0, 0, len(df.columns) - 1,
"CLIENT vs SUBCONTRACTOR",
@@ -176,13 +169,13 @@ def write_sheet(writer, df, sheet_name, subcontractor_name):
title_fmt
)
# header formatting
for col_num, col_name in enumerate(df.columns):
if col_name.startswith("Client-"):
ws.write(3, col_num, col_name, client_fmt)
elif col_name.startswith("Subcontractor-"):
ws.write(3, col_num, col_name, sub_fmt)
elif col_name.endswith("Total"):
elif col_name.endswith("_total") or col_name.endswith("_total") :
ws.write(3, col_num, col_name, total_fmt)
elif col_name == "Diff":
ws.write(3, col_num, col_name, diff_fmt)
@@ -224,12 +217,15 @@ def comparison_report():
subcontractor_id=subcontractor_id
).all()]
df_dc = build_comparison(dc_client, dc_sub, "MH_NO")
# df_dc = build_comparison_mh_dc(dc_client, dc_sub, "MH_NO")
lay_client = [r.serialize() for r in LayingClient.query.all()]
lay_sub = [r.serialize() for r in Laying.query.filter_by(
subcontractor_id=subcontractor_id
).all()]
df_lay = build_comparison(lay_client, lay_sub, "MH_NO")
# df_lay = build_comparison_laying(lay_client, lay_sub, "MH_NO")
# -------- EXCEL --------
output = io.BytesIO()
@@ -251,3 +247,106 @@ def comparison_report():
return render_template("generate_comparison_report.html",subcontractors=subcontractors)
# def build_comparison_mh_dc(client_rows, contractor_rows, key_field):
# contractor_lookup = make_lookup(contractor_rows, key_field)
# mh_dc_fields = ManholeDomesticChamberClient.sum_mh_dc_fields()
# output = []
# for c in client_rows:
# loc = normalize_key(c.get("Location"))
# key = normalize_key(c.get(key_field))
# if not loc or not key:
# continue
# s = contractor_lookup.get((loc, key))
# if not s:
# continue
# client_total = sum(float(c.get(f, 0) or 0) for f in mh_dc_fields)
# sub_total = sum(float(s.get(f, 0) or 0) for f in mh_dc_fields)
# row = {
# "Location": loc,
# key_field.replace("_", " "): key
# }
# # CLIENT – ALL FIELDS
# for k, v in c.items():
# if k in ["id", "created_at"]:
# continue
# row[f"Client-{k}"] = v
# row["Client-Total"] = round(client_total, 2)
# row[" "] = ""
# # SUBCONTRACTOR – ALL FIELDS
# for k, v in s.items():
# if k in ["id", "created_at", "subcontractor_id"]:
# continue
# row[f"Subcontractor-{k}"] = v
# row["Subcontractor-Total"] = round(sub_total, 2)
# row["Diff"] = round(client_total - sub_total, 2)
# output.append(row)
# df = pd.DataFrame(output)
# df.columns = [format_header(col) for col in df.columns]
# return df
# def build_comparison_laying(client_rows, contractor_rows, key_field):
# contractor_lookup = make_lookup(contractor_rows, key_field)
# laying_fields = Laying.sum_laying_fields()
# output = []
# for c in client_rows:
# loc = normalize_key(c.get("Location"))
# key = normalize_key(c.get(key_field))
# if not loc or not key:
# continue
# s = contractor_lookup.get((loc, key))
# if not s:
# continue
# client_total = sum(float(c.get(f, 0) or 0) for f in laying_fields)
# sub_total = sum(float(s.get(f, 0) or 0) for f in laying_fields)
# print("--------------",key,"----------")
# print("sum -client_total ",client_total)
# print("sum -sub_total ",sub_total)
# print("Diff ---- ",client_total - sub_total)
# print("------------------------")
# row = {
# "Location": loc,
# key_field.replace("_", " "): key
# }
# # CLIENT – ALL FIELDS
# for k, v in c.items():
# if k in ["id", "created_at"]:
# continue
# row[f"Client-{k}"] = v
# row["Client-Total"] = round(client_total, 2)
# row[" "] = ""
# # SUBCONTRACTOR – ALL FIELDS
# for k, v in s.items():
# if k in ["id", "created_at", "subcontractor_id"]:
# continue
# row[f"Subcontractor-{k}"] = v
# row["Subcontractor-Total"] = round(sub_total, 2)
# row["Diff"] = round(client_total - sub_total, 2)
# output.append(row)
# df = pd.DataFrame(output)
# df.columns = [format_header(col) for col in df.columns]
# return df

186
app/routes/subcontractor_routes.py
View File

@@ -1,141 +1,90 @@
from flask import Blueprint, render_template, request, redirect, flash, current_app, url_for
from app.services.db_service import db
from flask import Blueprint, render_template, request, redirect, flash
from app import db
from app.models.subcontractor_model import Subcontractor
from app.utils.helpers import login_required
subcontractor_bp = Blueprint("subcontractor", __name__, url_prefix="/subcontractor")
# ---------------- ADD -----------------
@subcontractor_bp.route("/add")
@login_required
def add_subcontractor():
current_app.logger.info("Opened Add Subcontractor Page")
return render_template("subcontractor/add.html")
# ---------------- SAVE -----------------
@subcontractor_bp.route("/save", methods=["POST"])
@login_required
def save_subcontractor():
# 1. Get and clean the name from the form
name = request.form.get("subcontractor_name", "").strip()
# 2. Basic validation: Ensure the name isn't empty
if not name:
current_app.logger.warning("Empty subcontractor name submitted")
flash("Subcontractor name cannot be empty.", "danger")
return redirect(url_for("subcontractor.add_subcontractor"))
return redirect("/subcontractor/add")
# 3. Check if a subcontractor with this name already exists
existing_sub = Subcontractor.query.filter_by(subcontractor_name=name).first()
if existing_sub:
current_app.logger.warning(f"Duplicate subcontractor attempt: {name}")
flash(f"Subcontractor with name '{name}' already exists!", "danger")
return redirect(url_for("subcontractor.add_subcontractor"))
return redirect("/subcontractor/add")
# 4. If no duplicate is found, proceed to save
try:
subcontractor = Subcontractor(
subcontractor_name=name,
contact_person=request.form.get("contact_person"),
address=request.form.get("address"),
mobile_no=request.form.get("mobile_no"),
email_id=request.form.get("email_id"),
gst_no=request.form.get("gst_no"),
pan_no=request.form.get("pan_no")
gst_no=request.form.get("gst_no")
)
db.session.add(subcontractor)
db.session.commit()
current_app.logger.info(f"Subcontractor Created Successfully: {name}")
flash("Subcontractor added successfully!", "success")
except Exception:
except Exception as e:
db.session.rollback()
current_app.logger.exception("Error while saving subcontractor")
flash("An error occurred while saving.", "danger")
flash("An error occurred while saving. Please try again.", "danger")
return redirect(url_for("subcontractor.subcontractor_list"))
return redirect("/subcontractor/list")
# ---------------- LIST (UPDATED WITH PAGINATION) -----------------
# ---------------- LIST -----------------
@subcontractor_bp.route("/list")
@login_required
def subcontractor_list():
page = request.args.get("page", 1, type=int)
per_page = 10 # Change how many records per page
pagination = Subcontractor.query.order_by(
Subcontractor.created_at
).paginate(
page=page,
per_page=per_page,
error_out=False
)
subcontractors = pagination.items
current_app.logger.info(f"Viewed Subcontractor List - Page {page}")
return render_template(
"subcontractor/list.html",
subcontractors=subcontractors,
pagination=pagination
)
subcontractors = Subcontractor.query.all()
return render_template("subcontractor/list.html", subcontractors=subcontractors)
# ---------------- EDIT -----------------
@subcontractor_bp.route("/edit/<int:id>")
@login_required
def edit_subcontractor(id):
subcontractor = Subcontractor.query.get_or_404(id)
current_app.logger.info(f"Editing Subcontractor ID: {id}")
return render_template("subcontractor/edit.html", subcontractor=subcontractor)
# ---------------- UPDATE -----------------
@subcontractor_bp.route("/update/<int:id>", methods=["POST"])
@login_required
def update_subcontractor(id):
subcontractor = Subcontractor.query.get_or_404(id)
new_name = request.form.get("subcontractor_name", "").strip()
new_name = request.form.get("subcontractor_name")
# Check if the new name is taken by someone ELSE (not this current ID)
duplicate = Subcontractor.query.filter(
Subcontractor.subcontractor_name == new_name,
Subcontractor.id != id
).first()
if duplicate:
current_app.logger.warning(f"Duplicate update attempt: {new_name}")
flash("Another subcontractor already uses this name.", "danger")
return redirect(url_for("subcontractor.edit_subcontractor", id=id))
try:
old_name = subcontractor.subcontractor_name
return redirect(f"/subcontractor/edit/{id}")
subcontractor.subcontractor_name = new_name
subcontractor.contact_person = request.form.get("contact_person")
subcontractor.address = request.form.get("address")
subcontractor.mobile_no = request.form.get("mobile_no")
subcontractor.email_id = request.form.get("email_id")
subcontractor.gst_no = request.form.get("gst_no")
subcontractor.pan_no = request.form.get("pan_no")
subcontractor.status = request.form.get("status")
db.session.commit()
current_app.logger.info(f"Subcontractor Updated: {old_name} → {new_name}")
flash("Subcontractor updated successfully!", "success")
except Exception:
db.session.rollback()
current_app.logger.exception("Error updating subcontractor")
flash("Update failed!", "danger")
return redirect(url_for("subcontractor.subcontractor_list"))
return redirect("/subcontractor/list")
# ---------------- DELETE -----------------
@subcontractor_bp.route("/delete/<int:id>")
@@ -143,17 +92,100 @@ def update_subcontractor(id):
def delete_subcontractor(id):
subcontractor = Subcontractor.query.get_or_404(id)
try:
name = subcontractor.subcontractor_name
db.session.delete(subcontractor)
db.session.commit()
current_app.logger.info(f"Subcontractor Deleted: {name}")
flash("Subcontractor deleted successfully!", "success")
return redirect("/subcontractor/list")
from flask import Blueprint, render_template, request, redirect, flash
from app import db
from app.models.subcontractor_model import Subcontractor
from app.utils.helpers import login_required
except Exception:
subcontractor_bp = Blueprint("subcontractor", __name__, url_prefix="/subcontractor")
# ---------------- ADD -----------------
@subcontractor_bp.route("/add")
@login_required
def add_subcontractor():
return render_template("subcontractor/add.html")
@subcontractor_bp.route("/save", methods=["POST"])
@login_required
def save_subcontractor():
name = request.form.get("subcontractor_name", "").strip()
if not name:
flash("Subcontractor name cannot be empty.", "danger")
return redirect("/subcontractor/add")
existing_sub = Subcontractor.query.filter_by(subcontractor_name=name).first()
if existing_sub:
flash(f"Subcontractor with name '{name}' already exists!", "danger")
return redirect("/subcontractor/add")
try:
subcontractor = Subcontractor(
subcontractor_name=name,
contact_person=request.form.get("contact_person"),
mobile_no=request.form.get("mobile_no"),
email_id=request.form.get("email_id"),
gst_no=request.form.get("gst_no")
)
db.session.add(subcontractor)
db.session.commit()
flash("Subcontractor added successfully!", "success")
except Exception as e:
db.session.rollback()
current_app.logger.exception("Error deleting subcontractor")
flash("Delete failed!", "danger")
flash("An error occurred while saving. Please try again.", "danger")
return redirect(url_for("subcontractor.subcontractor_list"))
return redirect("/subcontractor/list")
# ---------------- LIST -----------------
@subcontractor_bp.route("/list")
@login_required
def subcontractor_list():
subcontractors = Subcontractor.query.all()
return render_template("subcontractor/list.html", subcontractors=subcontractors)
# ---------------- EDIT -----------------
@subcontractor_bp.route("/edit/<int:id>")
@login_required
def edit_subcontractor(id):
subcontractor = Subcontractor.query.get_or_404(id)
return render_template("subcontractor/edit.html", subcontractor=subcontractor)
# ---------------- UPDATE -----------------
@subcontractor_bp.route("/update/<int:id>", methods=["POST"])
@login_required
def update_subcontractor(id):
subcontractor = Subcontractor.query.get_or_404(id)
new_name = request.form.get("subcontractor_name")
# Check if the new name is taken by someone ELSE (not this current ID)
duplicate = Subcontractor.query.filter(
Subcontractor.subcontractor_name == new_name,
Subcontractor.id != id
).first()
if duplicate:
flash("Another subcontractor already uses this name.", "danger")
return redirect(f"/subcontractor/edit/{id}")
subcontractor.subcontractor_name = new_name
db.session.commit()
flash("Subcontractor updated successfully!", "success")
return redirect("/subcontractor/list")
# ---------------- DELETE -----------------
@subcontractor_bp.route("/delete/<int:id>")
@login_required
def delete_subcontractor(id):
subcontractor = Subcontractor.query.get_or_404(id)
db.session.delete(subcontractor)
db.session.commit()
flash("Subcontractor deleted successfully!", "success")
return redirect("/subcontractor/list")

11
app/routes/user.py Normal file
View File

@@ -0,0 +1,11 @@
from flask import Blueprint, render_template
from app.services.user_service import UserService
from app.utils.helpers import login_required
user_bp = Blueprint("user", __name__, url_prefix="/user")
@user_bp.route("/list")
@login_required
def list_users():
users = UserService.get_all_users()
return render_template("users.html", users=users, title="Users")

50
app/routes/user_routes.py
View File

@@ -1,50 +0,0 @@
# from flask import Blueprint, render_template
# from app.services.user_service import UserService
# from app.utils.helpers import login_required
# from flask import current_app
# user_bp = Blueprint("user", __name__, url_prefix="/user")
# @user_bp.route("/list")
# @login_required
# def list_users():
# current_app.logger.info("User list viewed")
# users = UserService.get_all_users()
# return render_template("/user/users.html", users=users, title="Users | List")
from flask import (Blueprint,render_template,current_app,flash)
from app.services.user_service import UserService
from app.utils.helpers import login_required
from app.constants.messages import SuccessMessage, ErrorMessage
from app.constants.http_status import HTTPStatus
user_bp = Blueprint("user", __name__, url_prefix="/user")
# ==================================================
# User List
# ==================================================
@user_bp.route("/list", methods=["GET"])
@login_required
def list_users():
try:
current_app.logger.info("Fetching user list.")
users = UserService.get_all_users()
current_app.logger.info(f"User list loaded successfully. Total Users: {len(users)}")
return render_template("user/users.html", users=users, title="Users | List")
except Exception as e:
current_app.logger.exception("Failed to load user list.")
flash(ErrorMessage.INTERNAL_SERVER_ERROR,"danger")
return render_template("user/users.html",users=[],title="Users | List"), HTTPStatus.INTERNAL_SERVER_ERROR

359
app/services/abstract_service.py
View File

@@ -1,359 +0,0 @@
from sqlalchemy import func
from app import db
from app.models.subcontractor_model import Subcontractor
from app.models.trench_excavation_model import TrenchExcavation
from app.models.manhole_excavation_model import ManholeExcavation
from app.models.manhole_domestic_chamber_model import ManholeDomesticChamber
from app.models.laying_model import Laying
class AbstractReportService:
def __init__(self, subcontractor_id=None, ra_bill_no=None):
self.subcontractor_id = subcontractor_id
self.ra_bill_no = ra_bill_no
# ---------------------------------------------------------
# FILTER
# ---------------------------------------------------------
def filters(self):
filters = {}
if self.subcontractor_id:
filters["subcontractor_id"] = self.subcontractor_id
if self.ra_bill_no:
filters["RA_Bill_No"] = self.ra_bill_no
return filters
# ---------------------------------------------------------
# CONTRACTOR
# ---------------------------------------------------------
def contractor_name(self):
if not self.subcontractor_id:
return ""
contractor = Subcontractor.query.get(self.subcontractor_id)
if contractor:
return contractor.subcontractor_name
return ""
# ---------------------------------------------------------
# WRITE ABSTRACT SHEET
# ---------------------------------------------------------
def generate(self, workbook):
worksheet = workbook.add_worksheet("Abstract")
title = workbook.add_format({
"bold": True,
"font_size": 16,
"align": "center",
"valign": "vcenter",
"border": 1
})
heading = workbook.add_format({
"bold": True,
"bg_color": "#D9EAD3",
"border": 1,
"align": "center"
})
cell = workbook.add_format({"border": 1})
number = workbook.add_format({"border": 1,"num_format": "#,##0.00"})
# -----------------------------------------------------
# HEADER
# -----------------------------------------------------
worksheet.merge_range(
"A1:D1",
"ABSTRACT OF QUANTITY",
title
)
worksheet.write("A3", "Contractor", heading)
worksheet.write("B3", self.contractor_name(), cell)
worksheet.write("C3", "RA Bill", heading)
worksheet.write("D3", self.ra_bill_no or "", cell)
worksheet.write_row(
"A5",
[
"Sr",
"Description",
"UOM",
"Qty"
],
heading
)
row = 5
sr = 1
# -----------------------------------------------------
# TRENCH
# -----------------------------------------------------
worksheet.write(row, 0, "")
worksheet.write(row, 1, "TRENCH EXCAVATION", heading)
row += 1
for item in self.trench_summary():
worksheet.write(row, 0, sr, cell)
worksheet.write(row, 1, item["Description"], cell)
worksheet.write(row, 2, item["UOM"], cell)
worksheet.write(row, 3, item["Qty"], number)
sr += 1
row += 1
# -----------------------------------------------------
# MANHOLE
# -----------------------------------------------------
worksheet.write(row, 1, "MANHOLE EXCAVATION", heading)
row += 1
for item in self.manhole_summary():
worksheet.write(row, 0, sr, cell)
worksheet.write(row, 1, item["Description"], cell)
worksheet.write(row, 2, item["UOM"], cell)
worksheet.write(row, 3, item["Qty"], number)
sr += 1
row += 1
# -----------------------------------------------------
# DOMESTIC CHAMBER
# -----------------------------------------------------
worksheet.write(row, 1, "DOMESTIC CHAMBER", heading)
row += 1
for item in self.domestic_summary():
worksheet.write(row, 0, sr, cell)
worksheet.write(row, 1, item["Description"], cell)
worksheet.write(row, 2, item["UOM"], cell)
worksheet.write(row, 3, item["Qty"], number)
sr += 1
row += 1
# -----------------------------------------------------
# PIPE LAYING
# -----------------------------------------------------
worksheet.write(row, 1, "PIPE LAYING", heading)
row += 1
for item in self.laying_summary():
worksheet.write(row, 0, sr, cell)
worksheet.write(row, 1, item["Description"], cell)
worksheet.write(row, 2, item["UOM"], cell)
worksheet.write(row, 3, item["Qty"], number)
sr += 1
row += 1
worksheet.set_column("A:A", 8)
worksheet.set_column("B:B", 55)
worksheet.set_column("C:C", 10)
worksheet.set_column("D:D", 18)
# ============================================================
# TRENCH
# ============================================================
def trench_summary(self):
f = self.filters()
data = [
("Soft Murum 0-1.5 mm","Cum",TrenchExcavation.Soft_Murum_0_to_1_5_total),
("Soft Murum 1.5-3.0 mm","Cum",TrenchExcavation.Soft_Murum_1_5_to_3_0_total),
("Soft Murum 3.0-4.5 mm","Cum",TrenchExcavation.Soft_Murum_3_0_to_4_5_total),
("Hard Murum 0-1.5 mm","Cum",TrenchExcavation.Hard_Murum_0_to_1_5_total),
("Hard Murum Above 1.5 mm","Cum",TrenchExcavation.Hard_Murum_1_5_and_above_total),
("Soft Rock 0-1.5 mm","Cum",TrenchExcavation.Soft_Rock_0_to_1_5_total),
("Soft Rock Above 1.5 mm","Cum",TrenchExcavation.Soft_Rock_1_5_and_above_total),
("Hard Rock 0-1.5 mm","Cum",TrenchExcavation.Hard_Rock_0_to_1_5_total),
("Hard Rock 1.5-3.0 mm","Cum",TrenchExcavation.Hard_Rock_1_5_to_3_0_total),
("Hard Rock 3.0-4.5 mm","Cum",TrenchExcavation.Hard_Rock_3_0_to_4_5_total),
("Hard Rock 4.5-6.0 mm","Cum",TrenchExcavation.Hard_Rock_4_5_to_6_0_total),
("Hard Rock 6.0-7.5 mm","Cum",TrenchExcavation.Hard_Rock_6_0_to_7_5_total),
]
return self.make_summary(data, TrenchExcavation, f)
# ============================================================
# MANHOLE
# ============================================================
def manhole_summary(self):
f = self.filters()
data = [
("Soft Murum 0-1.5 mm","Cum",ManholeExcavation.Soft_Murum_0_to_1_5_total),
("Soft Murum 1.5-3.0 mm","Cum",ManholeExcavation.Soft_Murum_1_5_to_3_0_total),
("Soft Murum 3.0-4.5 mm","Cum",ManholeExcavation.Soft_Murum_3_0_to_4_5_total),
("Hard Murum 0-1.5 mm","Cum",ManholeExcavation.Hard_Murum_0_to_1_5_total),
("Hard Murum Above 1.5 mm","Cum",ManholeExcavation.Hard_Murum_1_5_and_above_total),
("Soft Rock 0-1.5 mm","Cum",ManholeExcavation.Soft_Rock_0_to_1_5_total),
("Soft Rock Above 1.5 mm","Cum",ManholeExcavation.Soft_Rock_1_5_and_above_total),
("Hard Rock 0-1.5 mm","Cum",ManholeExcavation.Hard_Rock_0_to_1_5_total),
("Hard Rock 1.5-3.0 mm","Cum",ManholeExcavation.Hard_Rock_1_5_to_3_0_total),
("Hard Rock 3.0-4.5 mm","Cum",ManholeExcavation.Hard_Rock_3_0_to_4_5_total),
("Hard Rock 4.5-6.0 mm","Cum",ManholeExcavation.Hard_Rock_4_5_to_6_0_total),
("Hard Rock 6.0-7.5 mm","Cum",ManholeExcavation.Hard_Rock_6_0_to_7_5_total),
]
return self.make_summary(data, ManholeExcavation, f)
# ============================================================
# DOMESTIC CHAMBER
# ============================================================
def domestic_summary(self):
f = self.filters()
data = [
("0-0.75 mm","Nos",ManholeDomesticChamber.d_0_to_0_75),
("0.76-1.05 mm","Nos",ManholeDomesticChamber.d_0_76_to_1_05),
("1.06-1.65 mm","Nos",ManholeDomesticChamber.d_1_06_to_1_65),
("1.66-2.15 mm","Nos",ManholeDomesticChamber.d_1_66_to_2_15),
("2.16-2.65 mm","Nos",ManholeDomesticChamber.d_2_16_to_2_65),
("2.66-3.15 mm","Nos",ManholeDomesticChamber.d_2_66_to_3_15),
("3.16-3.65 mm","Nos",ManholeDomesticChamber.d_3_16_to_3_65),
("3.66-4.15 mm","Nos",ManholeDomesticChamber.d_3_66_to_4_15),
("4.16-4.65 mm","Nos",ManholeDomesticChamber.d_4_16_to_4_65),
("4.66-5.15 mm","Nos",ManholeDomesticChamber.d_4_66_to_5_15),
("5.16-5.65 mm","Nos",ManholeDomesticChamber.d_5_16_to_5_65),
("5.66-6.15 mm","Nos",ManholeDomesticChamber.d_5_66_to_6_15),
("6.16-6.65 mm","Nos",ManholeDomesticChamber.d_6_16_to_6_65),
("6.66-7.15 mm","Nos",ManholeDomesticChamber.d_6_66_to_7_15),
("7.16-7.65 mm","Nos",ManholeDomesticChamber.d_7_16_to_7_65),
("7.66-8.15 mm","Nos",ManholeDomesticChamber.d_7_66_to_8_15),
("8.16-8.65 mm","Nos",ManholeDomesticChamber.d_8_16_to_8_65),
("8.66-9.15 mm","Nos",ManholeDomesticChamber.d_8_66_to_9_15),
("9.16-9.65 mm","Nos",ManholeDomesticChamber.d_9_16_to_9_65),
]
return self.make_summary(data, ManholeDomesticChamber, f)
# ============================================================
# PIPE LAYING
# ============================================================
def laying_summary(self):
f = self.filters()
data = [
("150 mm Dia","RM",Laying.pipe_150_mm),
("200 mm Dia","RM",Laying.pipe_200_mm),
("250 mm Dia","RM",Laying.pipe_250_mm),
("300 mm Dia","RM",Laying.pipe_300_mm),
("350 mm Dia","RM",Laying.pipe_350_mm),
("400 mm Dia","RM",Laying.pipe_400_mm),
("450 mm Dia","RM",Laying.pipe_450_mm),
("500 mm Dia","RM",Laying.pipe_500_mm),
("600 mm Dia","RM",Laying.pipe_600_mm),
("700 mm Dia","RM",Laying.pipe_700_mm),
("900 mm Dia","RM",Laying.pipe_900_mm),
("1200 mm Dia","RM",Laying.pipe_1200_mm),
]
return self.make_summary(data, Laying, f)
# ============================================================
# COMMON SUMMARY
# ============================================================
def make_summary(self, items, model, filters):
summary = []
for desc, uom, column in items:
qty = (db.session.query(func.sum(column)).filter_by(**filters).scalar())
summary.append({
"Description": desc,
"UOM": uom,
"Qty": float(qty or 0)
})
return summary
def generate_html(self):
html = """
<div class="table-responsive">
<table class="table table-bordered table-hover table-striped">
<thead class="table-success">
<tr>
<th colspan="4" class="text-center fs-4">
ABSTRACT OF QUANTITY
</th>
</tr>
<tr>
<th>Contractor</th>
<td>{}</td>
<th>RA Bill NO</th>
<td>{}</td>
</tr>
<tr>
<th width="8%">Sr</th>
<th>Description</th>
<th width="10%">UOM</th>
<th width="15%">Qty</th>
</tr>
</thead>
<tbody>
""".format(
self.contractor_name(),
self.ra_bill_no or ""
)
sr = 1
sections = [
("TRENCH EXCAVATION", self.trench_summary()),
("MANHOLE EXCAVATION", self.manhole_summary()),
("DOMESTIC CHAMBER", self.domestic_summary()),
("PIPE LAYING", self.laying_summary())
]
for title, rows in sections:
html += f"""
<tr class="table-secondary fw-bold">
<td colspan="4">{title}</td>
</tr>
"""
for item in rows:
html += f"""
<tr>
<td>{sr}</td>
<td>{item['Description']}</td>
<td>{item['UOM']}</td>
<td class="text-end">
{item['Qty']:.2f}
</td>
</tr>
"""
sr += 1
html += """
</tbody>
</table>
</div>
"""
return html

56
app/services/activity_service.py
View File

@@ -1,56 +0,0 @@
import re
from pathlib import Path
# Activity log Service
class ActivityService:
@staticmethod
def read_logs(file_name="", search="", level="", user="", from_date="", to_date=""):
file = Path("logs") / file_name
if not file.exists():
return []
logs = []
with open(file, "r", encoding="utf-8") as f:
for line in reversed(f.readlines()):
# Example:
# 2026-08-01 10:15:55 | INFO | admin | Dashboard | Dashboard Opened
parts = [x.strip() for x in line.split("|")]
if len(parts) < 5:
continue
record = {
"date": parts[0],
"level": parts[1],
"user": parts[2],
"module": parts[3],
"message": "|".join(parts[4:])
}
# Search Filter
if search and search.lower() not in line.lower():
continue
# Level Filter
if level and record["level"] != level:
continue
# User Filter
if user and user.lower() not in record["user"].lower():
continue
# Date Filter
if from_date and record["date"][:10] < from_date:
continue
if to_date and record["date"][:10] > to_date:
continue
logs.append(record)
return logs

204
app/services/comparison_service.py
View File

@@ -1,204 +0,0 @@
# from collections import defaultdict
# import pandas as pd
# from app.utils.regex_utils import RegularExpression
# class ComparisonService:
# TRENCH_MAPPING = [
# {
# "label": "Marshi 0 to 1.5",
# "client": "Client_Marshi_Muddy_Slushy_0_to_1_5_total",
# "sub": None
# },
# {
# "label": "Marshi 1.5 to 3.0",
# "client": "Client_Marshi_Muddy_Slushy_1_5_to_3_0_total",
# "sub": None
# },
# {
# "label": "Marshi 3.0 to 4.5",
# "client": "Client_Marshi_Muddy_Slushy_3_0_to_4_5_total",
# "sub": None
# },
# {
# "label": "Soft Murum 0 to 1.5",
# "client": "Client_Soft_Murum_0_to_1_5_total",
# "sub": "Sub_Soft_Murum_0_to_1_5_total"
# },
# {
# "label": "Soft Murum 1.5 to 3.0",
# "client": "Client_Soft_Murum_1_5_to_3_0_total",
# "sub": "Sub_Soft_Murum_1_5_to_3_0_total"
# },
# {
# "label": "Soft Murum 3.0 to 4.5",
# "client": "Client_Soft_Murum_3_0_to_4_5_total",
# "sub": "Sub_Soft_Murum_3_0_to_4_5_total"
# },
# {
# "label": "Hard Murum 0 to 1.5",
# "client": "Client_Hard_Murum_0_to_1_5_total",
# "sub": "Sub_Hard_Murum_0_to_1_5_total"
# },
# {
# "label": "Hard Murum 1.5+",
# "client": "Client_Hard_Murum_1_5_to_3_0_total",
# "sub": "Sub_Hard_Murum_1_5_and_above_total"
# },
# {
# "label": "Soft Rock 0 to 1.5",
# "client": "Client_Soft_Rock_0_to_1_5_total",
# "sub": "Sub_Soft_Rock_0_to_1_5_total"
# },
# {
# "label": "Soft Rock 1.5+",
# "client": "Client_Soft_Rock_1_5_to_3_0_total",
# "sub": "Sub_Soft_Rock_1_5_and_above_total"
# },
# {
# "label": "Hard Rock 0 to 1.5",
# "client": "Client_Hard_Rock_0_to_1_5_total",
# "sub": "Sub_Hard_Rock_0_to_1_5_total"
# },
# {
# "label": "Hard Rock 1.5 to 3.0",
# "client": "Client_Hard_Rock_1_5_to_3_0_total",
# "sub": "Sub_Hard_Rock_1_5_to_3_0_total"
# },
# {
# "label": "Hard Rock 3.0 to 4.5",
# "client": "Client_Hard_Rock_3_0_to_4_5_total",
# "sub": "Sub_Hard_Rock_3_0_to_4_5_total"
# },
# {
# "label": "Hard Rock 4.5 to 6.0",
# "client": "Client_Hard_Rock_4_5_to_6_0_total",
# "sub": "Sub_Hard_Rock_4_5_to_6_0_total"
# },
# {
# "label": "Hard Rock 6.0 to 7.5",
# "client": "Client_Hard_Rock_6_0_to_7_5_total",
# "sub": "Sub_Hard_Rock_6_0_to_7_5_total"
# }
# ]
# @staticmethod
# def normalize_key(value):
# if value is None:
# return ""
# return str(value).strip().upper()
# @classmethod
# def make_lookup(cls, rows, key_field):
# """
# Create lookup dictionary using:
# (Location, MH_NO)
# """
# lookup = defaultdict(list)
# for row in rows:
# location = cls.normalize_key(row.get("Location"))
# key = cls.normalize_key(row.get(key_field))
# if location and key:
# lookup[(location, key)].append(row)
# return lookup
# @classmethod
# def build_comparison(cls, client_rows, subcontractor_rows, key_field="MH_NO"):
# subcontractor_lookup = cls.make_lookup(
# subcontractor_rows,
# key_field
# )
# used = defaultdict(int)
# output = []
# for client in client_rows:
# location = cls.normalize_key(client.get("Location"))
# key = cls.normalize_key(client.get(key_field))
# if not location or not key:
# continue
# rows = subcontractor_lookup.get((location, key))
# if not rows:
# continue
# index = used[(location, key)]
# if index >= len(rows):
# continue
# subcontractor = rows[index]
# used[(location, key)] += 1
# client_total = sum(
# float(v or 0)
# for k, v in client.items()
# if k.endswith("_total")
# or RegularExpression.D_RANGE_PATTERN.match(k)
# or RegularExpression.PIPE_MM_PATTERN.match(k)
# )
# subcontractor_total = sum(
# float(v or 0)
# for k, v in subcontractor.items()
# if k.endswith("_total")
# or RegularExpression.D_RANGE_PATTERN.match(k)
# or RegularExpression.PIPE_MM_PATTERN.match(k)
# )
# row = {
# "Location": location,
# key_field: key,
# "Client_Total": round(client_total, 2),
# "Subcontractor_Total": round(subcontractor_total, 2),
# "Difference": round(
# client_total - subcontractor_total,
# 2
# )
# }
# # Client Columns
# for column, value in client.items():
# if column in [
# "id",
# "created_at"
# ]:
# continue
# row[f"Client_{column}"] = value
# # Subcontractor Columns
# for column, value in subcontractor.items():
# if column in [
# "id",
# "created_at",
# "subcontractor_id"
# ]:
# continue
# row[f"Sub_{column}"] = value
# output.append(row)
# return pd.DataFrame(output)

19
app/services/file_service.py
View File

@@ -1,8 +1,10 @@
from app import db
import os
import pandas as pd
from werkzeug.utils import secure_filename
from app.utils.file_utils import ensure_upload_folder, get_uploads_folder, ALLOWED_EXTENSIONS
from app.utils.file_utils import ensure_upload_folder
from app.config import Config
from app import db
# Subcontractor models import
from app.models.trench_excavation_model import TrenchExcavation
@@ -22,9 +24,8 @@ class FileService:
# ---------------- COMMON HELPERS ----------------
def allowed_file(self, filename):
return ("." in filename and filename.rsplit(".", 1)[1].lower() in ALLOWED_EXTENSIONS)
return ("." in filename and filename.rsplit(".", 1)[1].lower() in Config.ALLOWED_EXTENSIONS)
# data normalizations
def normalize(self, val):
if val is None or pd.isna(val):
return None
@@ -35,7 +36,6 @@ class FileService:
return val.upper()
# --------------- Sub-contractor service --------------
# ---------------- SUBCONTRACTOR FILE UPLOAD ----------------
def handle_file_upload(self, file, subcontractor_id, RA_Bill_No):
@@ -52,9 +52,8 @@ class FileService:
return False, "Invalid file type! Allowed: CSV, XLSX, XLS"
ensure_upload_folder()
path = get_uploads_folder()
folder = os.path.join(path, f"sub_{subcontractor_id}")
folder = os.path.join(Config.UPLOAD_FOLDER, f"sub_{subcontractor_id}")
os.makedirs(folder, exist_ok=True)
filename = secure_filename(file.filename)
@@ -310,7 +309,8 @@ class FileService:
db.session.commit()
# --------------- Client service --------------
# ---------------- CLIENT FILE UPLOAD ----------------
def handle_client_file_upload(self, file, RA_Bill_No):
@@ -324,9 +324,8 @@ class FileService:
return False, "Invalid file type! Allowed: CSV, XLSX, XLS"
ensure_upload_folder()
path = get_uploads_folder()
folder = os.path.join(path, f"Client_Bill_{RA_Bill_No}")
folder = os.path.join(Config.UPLOAD_FOLDER, f"Client_Bill_{RA_Bill_No}")
os.makedirs(folder, exist_ok=True)
filename = secure_filename(file.filename)

72
app/services/ldap_service.py
View File

@@ -1,72 +0,0 @@
from flask import current_app
from ldap3 import Server, Connection, ALL, SUBTREE
from ldap3.core.exceptions import LDAPException
class LDAPService:
"""
Handles authentication against an LDAP / OpenLDAP server using the
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):
if not username or not password:
return None
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"],
password=current_app.config["LDAP_BIND_PASSWORD"],
auto_bind=True,
)
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:
search_filter = current_app.config["LDAP_SEARCH_FILTER"].format(username=username)
admin_conn.search(
search_base=current_app.config["LDAP_BASE_DN"],
search_filter=search_filter,
search_scope=SUBTREE,
attributes=["cn", "mail", "uid"],
)
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:
current_app.logger.warning(f"LDAP user not found: {username}")
admin_conn.unbind()
return None
entry = admin_conn.entries[0]
user_dn = entry.entry_dn
name = str(entry.cn) if "cn" in entry and entry.cn.value else username
email = (
str(entry.mail)
if "mail" in entry and entry.mail.value
else f"{username}@{current_app.config['LDAP_DOMAIN']}"
)
admin_conn.unbind()
# --- Step 3: the actual auth check - bind AS the user with their password ---
try:
user_conn = Connection(server, user=user_dn, password=password, auto_bind=True)
user_conn.unbind()
except LDAPException as e:
current_app.logger.warning(f"LDAP authentication failed for '{username}': {e}")
return None
return {"username": username, "name": name, "email": email}

149
app/services/logger_service.py
View File

@@ -1,149 +0,0 @@
import os
import logging
from logging.handlers import RotatingFileHandler
from flask import request, session, has_request_context
class RequestContextFilter(logging.Filter):
"""Adds request information to every log record."""
def filter(self, record):
if has_request_context():
record.user = session.get("user_name", "Anonymous")
record.ip = request.remote_addr or "Unknown"
record.method = request.method
record.url = request.url
else:
record.user = "System"
record.ip = "-"
record.method = "-"
record.url = "-"
return True
class LoggerService:
LOG_DIR = "logs"
APP_LOG = "app.log"
ERROR_LOG = "error.log"
DEBUG_LOG = "debug.log"
MAX_BYTES = 10 * 1024 * 1024 # 10 MB
BACKUP_COUNT = 10
@classmethod
def init_app(cls, app):
os.makedirs(cls.LOG_DIR, exist_ok=True)
formatter = logging.Formatter(
fmt=(
"%(asctime)s | "
"%(levelname)-8s | "
"User=%(user)s | "
"IP=%(ip)s | "
"%(method)s | "
"%(url)s | "
"%(message)s"
),
datefmt="%Y-%m-%d %H:%M:%S"
)
context_filter = RequestContextFilter()
# Remove default handlers
app.logger.handlers.clear()
# ==========================
# Application Log
# ==========================
app_handler = RotatingFileHandler(
os.path.join(cls.LOG_DIR, cls.APP_LOG),
maxBytes=cls.MAX_BYTES,
backupCount=cls.BACKUP_COUNT,
encoding="utf-8"
)
app_handler.setLevel(logging.INFO)
app_handler.setFormatter(formatter)
app_handler.addFilter(context_filter)
# ==========================
# Error Log
# ==========================
error_handler = RotatingFileHandler(
os.path.join(cls.LOG_DIR, cls.ERROR_LOG),
maxBytes=cls.MAX_BYTES,
backupCount=cls.BACKUP_COUNT,
encoding="utf-8"
)
error_handler.setLevel(logging.ERROR)
error_handler.setFormatter(formatter)
error_handler.addFilter(context_filter)
# ==========================
# Debug Log
# ==========================
debug_handler = RotatingFileHandler(
os.path.join(cls.LOG_DIR, cls.DEBUG_LOG),
maxBytes=cls.MAX_BYTES,
backupCount=cls.BACKUP_COUNT,
encoding="utf-8"
)
debug_handler.setLevel(logging.DEBUG)
debug_handler.setFormatter(formatter)
debug_handler.addFilter(context_filter)
# ==========================
# Console Log
# ==========================
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
console_handler.setFormatter(formatter)
console_handler.addFilter(context_filter)
# ==========================
# Logger Configuration
# ==========================
app.logger.setLevel(logging.DEBUG)
app.logger.addHandler(app_handler)
app.logger.addHandler(error_handler)
app.logger.addHandler(debug_handler)
app.logger.addHandler(console_handler)
# ==========================
# Automatic Request Logging
# ==========================
@app.before_request
def before_request():
app.logger.info("Request Started")
@app.after_request
def after_request(response):
app.logger.info(
f"Request Completed | Status={response.status_code}"
)
return response
# ==========================
# Exception Logging
# ==========================
@app.errorhandler(Exception)
def log_exception(error):
app.logger.exception(
f"Unhandled Exception: {str(error)}"
)
raise error
app.logger.info("=" * 70)
app.logger.info("Application Started Successfully")
app.logger.info("=" * 70)

65
app/services/subcontractor_rate_service.py
View File

@@ -1,65 +0,0 @@
from app.services.db_service import db
from app.models.subcontractor_rate_model import SubcontractorRate
class SubcontractorRateService:
@staticmethod
def save_rate(form):
rate = SubcontractorRate(
subcontractor_id=form.get("subcontractor_id"),
category=form.get("category"),
item_code=form.get("item_code"),
item_name=form.get("item_name"),
unit=form.get("unit"),
rate=form.get("rate"),
effective_from=form.get("effective_from"),
effective_to=form.get("effective_to") or None,
status=form.get("status")
)
db.session.add(rate)
db.session.commit()
return rate
@staticmethod
def get_all_rates():
return (
SubcontractorRate.query
.order_by(SubcontractorRate.created_at.desc())
.all()
)
@staticmethod
def get_rate(rate_id):
return SubcontractorRate.query.get_or_404(rate_id)
@staticmethod
def update_rate(rate_id, form):
rate = SubcontractorRate.query.get_or_404(rate_id)
rate.subcontractor_id = form.get("subcontractor_id")
rate.category = form.get("category")
rate.item_code = form.get("item_code")
rate.item_name = form.get("item_name")
rate.unit = form.get("unit")
rate.rate = form.get("rate")
rate.effective_from = form.get("effective_from")
rate.effective_to = form.get("effective_to") or None
rate.status = form.get("status")
db.session.commit()
return rate
@staticmethod
def delete_rate(rate_id):
rate = SubcontractorRate.query.get_or_404(rate_id)
db.session.delete(rate)
db.session.commit()

45
app/services/user_service.py
View File

@@ -1,7 +1,5 @@
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
class UserService:
@@ -10,7 +8,7 @@ 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)
@@ -18,49 +16,12 @@ class UserService:
return user
@staticmethod
def validate_login(identifier, password):
"""
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()
def validate_login(email, password):
user = User.query.filter_by(email=email).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()

BIN
app/static/downloads/format/client_format.xlsx
View File

Binary file not shown.

BIN
app/static/downloads/format/subcontractor_format.xlsx
View File

Binary file not shown.

208
app/templates/activity/activity_log.html
View File

@@ -1,208 +0,0 @@
{% extends "base.html" %}
{% block content %}
<div class="container-fluid py-4">
<!-- HEADER -->
<div class="card shadow-sm border-0 mb-4">
<div class="card-body">
<div class="d-flex flex-column flex-lg-row justify-content-between align-items-lg-center">
<div class="mb-3 mb-lg-0">
<h3 class="fw-bold text-primary mb-1"> <i class="bi bi-clock-history me-2"></i> Activity Logs </h3>
<small class="text-muted"> View application logs, search records and download log files. </small>
</div>
<div class="d-flex flex-wrap gap-2">
<a id="downloadLogBtn" href="{{ url_for('activity.download_log') }}?file={{ file_name }}" class="btn btn-success">
<i class="bi bi-download me-1"></i>
Download Log
</a>
<a href="{{ url_for('activity.activity') }}" class="btn btn-outline-primary">
<i class="bi bi-arrow-clockwise me-1"></i>
Refresh
</a>
</div>
</div>
</div>
</div>
<!-- FILTERS -->
<div class="card shadow-sm mb-4">
<div class="card-header bg-primary text-white">
<h5 class="mb-0">
<i class="bi bi-funnel-fill me-2"></i> Filters
</h5>
</div>
<div class="card-body">
<form method="GET">
<div class="row g-3">
<!-- Log File select -->
<div class="col-xl-2 col-lg-4 col-md-6">
<label class="form-label fw-bold">Log File</label>
<select class="form-select" name="file">
<option value="app.log" {% if file_name=="app.log" %}selected{% endif %}> Application </option>
<option value="debug.log" {% if file_name=="debug.log" %}selected{% endif %}> Debug </option>
<option value="error.log" {% if file_name=="error.log" %}selected{% endif %}> Error </option>
</select>
</div>
<!-- User search -->
<div class="col-xl-2 col-lg-4 col-md-6">
<label class="form-label fw-bold">User</label>
<input type="text" class="form-control" name="user" value="{{ user }}" placeholder="Username">
</div>
<!-- Level -->
<div class="col-xl-2 col-lg-4 col-md-6">
<label class="form-label fw-bold">Level</label>
<select class="form-select" name="level">
<option value="">All</option>
<option value="INFO"
{% if level=="INFO" %}selected{% endif %}>
INFO
</option>
<option value="WARNING"
{% if level=="WARNING" %}selected{% endif %}>
WARNING
</option>
<option value="ERROR"
{% if level=="ERROR" %}selected{% endif %}>
ERROR
</option>
</select>
</div>
<!-- From Date -->
<div class="col-xl-2 col-lg-4 col-md-6">
<label class="form-label fw-bold">From Date</label>
<input type="date" class="form-control" name="from_date" value="{{ from_date }}">
</div>
<!-- To Date -->
<div class="col-xl-2 col-lg-4 col-md-6">
<label class="form-label fw-bold">To Date</label>
<input type="date" class="form-control" name="to_date" value="{{ to_date }}">
</div>
<!-- Search button -->
<div class="col-xl-2 col-lg-12">
<label class="form-label fw-bold">Search</label>
<input type="text" class="form-control" name="search" value="{{ search }}" placeholder="Search">
</div>
</div>
<hr>
<!-- Search and Reset button -->
<div class="d-flex gap-2">
<button class="btn btn-primary">
<i class="bi bi-search"></i> Search
</button>
<button type="reset" class="btn btn-secondary">
<i class="bi bi-arrow-clockwise"></i> Reset
</button>
</div>
</form>
</div>
</div>
<!-- LOG TABLE -->
<div class="card shadow-sm">
<!-- Log Entries -->
<div class="card-header bg-dark text-white">
<div class="d-flex justify-content-between align-items-center">
<h5 class="mb-0">
<i class="bi bi-list-ul me-2"></i>
Log Entries
</h5>
<span class="badge bg-light text-dark">
{{ logs|length }} Records
</span>
</div>
</div>
<!-- Show table Entries -->
<div class="card-body p-0">
<div class="table-responsive" style="max-height:600px; overflow-y:auto; font-size:12px;">
<table class="table table-striped table-hover table-bordered align-middle mb-0 small">
<thead class="table-dark sticky-top">
<tr>
<th>Sr No</th>
<th>Date & Time</th>
<th>User</th>
<th>Level</th>
<th>Module</th>
<th>Activity</th>
</tr>
</thead>
<tbody>
{% for log in logs %}
<tr>
<td>{{ loop.index }}</td>
<td>{{ log.date }}</td>
<td>{{ log.user }}</td>
<td>
{% if log.level=="INFO" %}
<span class="badge bg-success">INFO</span>
{% elif log.level=="WARNING" %}
<span class="badge bg-warning text-dark">WARNING</span>
{% else %}
<span class="badge bg-danger">ERROR</span>
{% endif %}
</td>
<td>{{ log.module }}</td>
<td>{{ log.message }}</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
</div>
</div>
<script>
document.addEventListener("DOMContentLoaded", function () {
const fileSelect = document.querySelector('select[name="file"]');
const downloadBtn = document.getElementById("downloadLogBtn");
function updateDownloadLink() {
downloadBtn.href =
"{{ url_for('activity.download_log') }}?file=" +
encodeURIComponent(fileSelect.value);
}
updateDownloadLink();
fileSelect.addEventListener("change", updateDownloadLink);
});
</script>
{% endblock %}

275
app/templates/base.html
View File

@@ -5,23 +5,18 @@
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>{{ title if title else "Comparison Software" }}</title>
<link rel="icon" type="image/png" href="{{ url_for('static', filename='images/lcepl.png') }}">
<!-- Bootstrap CSS -->
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css">
<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
<!-- Bootstrap Icons -->
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons/font/bootstrap-icons.css" >
<link rel="stylesheet" href="https://cdn.datatables.net/1.13.6/css/jquery.dataTables.min.css">
<link rel="stylesheet" href="https://cdn.datatables.net/buttons/2.4.1/css/buttons.dataTables.min.css">
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-multiselect@1.1.2/dist/css/bootstrap-multiselect.min.css">
<link href="https://cdn.jsdelivr.net/npm/bootstrap-icons/font/bootstrap-icons.css" rel="stylesheet">
</head>
<body class="bg-light">
<!-- NAVBAR -->
<!-- <nav class="navbar navbar-expand-lg navbar-dark bg-dark shadow-sm"> -->
<nav class="navbar navbar-expand-lg navbar-dark bg-dark shadow-sm fixed-top">
<div class="container-fluid">
@@ -43,24 +38,24 @@
<!-- Dashboard -->
<li class="nav-item">
<a class="nav-link" href="/dashboard">
<i class="bi bi-speedometer2 me-1"></i> Dashboard
<i class="bi bi-speedometer2 me-1"></i> Dashboard - Anish
</a>
</li>
<!-- Subcontractor Model -->
<li class="nav-item dropdown">
<a class="nav-link dropdown-toggle" data-bs-toggle="dropdown" href="#">
<i class="bi bi-people-fill me-1"></i> Subcontractor List
<i class="bi bi-people-fill me-1"></i> Subcontractor Model
</a>
<ul class="dropdown-menu dropdown-menu-dark">
<li>
<a class="dropdown-item" href="/subcontractor/add">
<i class="bi bi-plus-circle me-2"></i> New Add
<i class="bi bi-plus-circle me-2"></i> Add Subcontractor
</a>
</li>
<li>
<a class="dropdown-item" href="/subcontractor/list">
<i class="bi bi-list-ul me-2"></i> List
<i class="bi bi-list-ul me-2"></i> Subcontractor List
</a>
</li>
</ul>
@@ -69,15 +64,9 @@
<!-- Subcontractor File System -->
<li class="nav-item dropdown">
<a class="nav-link dropdown-toggle" data-bs-toggle="dropdown" href="#">
<i class="bi bi-folder-fill me-1"></i>Subcontractor RA Bills
<i class="bi bi-folder-fill me-1"></i>Subcontractor File System
</a>
<ul class="dropdown-menu dropdown-menu-dark">
<li>
<a class="dropdown-item" href="/dashboard/subcontractor_dashboard">
<i class="bi bi-speedometer2 me-2"></i> Subcontractor Dashboard
</a>
</li>
<li>
<a class="dropdown-item" href="/file/import_Subcontractor">
<i class="bi bi-upload me-2"></i> Import File
@@ -85,7 +74,13 @@
</li>
<li>
<a class="dropdown-item" href="/file/Subcontractor_report">
<i class="bi bi-arrow-left-right me-2"></i> Show Reports
<i class="bi bi-download me-2"></i> Show Reports
</a>
</li>
<li>
<a class="dropdown-item" href="/dashboard/subcontractor_dashboard">
<i class="bi bi-speedometer2 me-2"></i> Subcontractor Dashboard
</a>
</li>
@@ -95,7 +90,7 @@
<!-- Client System -->
<li class="nav-item dropdown">
<a class="nav-link dropdown-toggle" data-bs-toggle="dropdown" href="#">
<i class="bi bi-building me-1"></i> Client RA Bills
<i class="bi bi-building me-1"></i> Client File System
</a>
<ul class="dropdown-menu dropdown-menu-dark">
<li>
@@ -115,38 +110,23 @@
<!-- Reports -->
<li class="nav-item dropdown">
<a class="nav-link dropdown-toggle" data-bs-toggle="dropdown" href="#">
<i class="bi bi-building me-1"></i> Comparison Report
<i class="bi bi-building me-1"></i> Reports
</a>
<ul class="dropdown-menu dropdown-menu-dark">
<li>
<a class="dropdown-item" href="/report/comparison_report">
<i class="bi bi-arrow-left-right me-2"></i> Client vs Subcontractor
<i class="bi bi-arrow-left-right me-2"></i> client vs sub-cont. Comparison Report
</a>
</li>
<!-- <li>
<a class="dropdown-item" href="/file/client_vs_subcont">
<i class="bi bi-arrow-left-right me-2"></i> Comparison Report
</a>
</li> -->
</ul>
</li>
<!-- Masters -->
<li class="nav-item dropdown">
<a class="nav-link dropdown-toggle" data-bs-toggle="dropdown" href="/engi">
<i class="bi bi-gear me-2"></i> Masters
</a>
<ul class="dropdown-menu dropdown-menu-dark">
<!-- Client Standard Rates -->
<li class="nav-item">
<a class="nav-link" href="/engi/subcontractor-rate">
<i class="bi bi-file-earmark-text me-1"></i> Rate Master
</a>
</li>
<!-- Client Standard Rates -->
<li class="nav-item">
<a class="nav-link" href="/engi/client-rate">
<i class="bi bi-file-earmark-text me-1"></i> Client Standard Rates
</a>
</li>
<!-- Formats -->
<li class="nav-item">
@@ -155,78 +135,44 @@
</a>
</li>
</ul>
</li>
<!-- USER DROPDOWN -->
<li class="nav-item dropdown">
{% if session.get("user_id") %}
<li class="nav-item dropdown ms-lg-3">
<a class="nav-link dropdown-toggle d-flex align-items-center text-white"
href="#" id="profileDropdown" role="button" data-bs-toggle="dropdown" aria-expanded="false">
<i class="bi bi-person-circle fs-4"></i>
<span class="ms-2 fw-semibold">
<a class="nav-link dropdown-toggle d-flex align-items-center gap-2" href="#"
data-bs-toggle="dropdown">
<i class="bi bi-person-circle fs-5"></i>
<span class="d-none d-lg-inline">
{{ session.get("user_name") }}
</span>
</a>
<ul class="dropdown-menu dropdown-menu-end dropdown-menu-dark border-0 shadow-lg bg-dark p-0"
style="width:320px;">
<ul class="dropdown-menu dropdown-menu-end dropdown-menu-dark shadow">
<!-- Profile Header -->
<li class="text-center py-4 border-bottom border-secondary">
<i class="bi bi-person-circle text-light" style="font-size:60px;"></i>
<h5 class="mt-2 mb-0 fw-bold">
<!-- User card -->
<li class="px-3 py-3 text-center border-bottom">
<i class="bi bi-person-circle fs-1"></i>
<div class="fw-semibold mt-1">
{{ session.get("user_name") }}
</h5>
<small class="text-secondary">
{{ session.get("email") }}
</small>
</div>
<small class="text-muted">Logged in user</small>
</li>
<!-- Dashboard -->
<li>
<a class="dropdown-item text-light py-2" href="{{ url_for('dashboard.dashboard') }}">
<a class="dropdown-item" href="/dashboard">
<i class="bi bi-speedometer2 me-2"></i> Dashboard
</a>
</li>
<!-- Activity Log page -->
<li>
<a class="dropdown-item text-light py-2" href="{{ url_for('activity.activity') }}">
<i class="bi bi-clock-history me-2"></i> Activity Log
<a class="dropdown-item text-warning" href="/logout">
<i class="bi bi-box-arrow-right me-2"></i> Logout
</a>
</li>
<!-- Manage Account -->
<li>
<a class="dropdown-item py-2" href="#">
<i class="bi bi-gear me-2"></i> Manage Account
</a>
</li>
<li><hr class="dropdown-divider border-secondary m-0"></li>
<!-- Logout Account -->
<li>
<a class="dropdown-item text-warning py-2" href="{{ url_for('auth.logout') }}">
<i class="bi bi-box-arrow-right me-2"></i>
Logout
</a>
</li>
<!-- Footer -->
<li class="text-center py-3 bg-secondary bg-opacity-10 border-top border-secondary">
<small class="text-light">
<i class="bi bi-shield-check text-success"></i>
Secured by <strong>LCEPL</strong>
</small>
</li>
</ul>
</li>
{% endif %}
</ul>
</div>
@@ -237,64 +183,20 @@
<!-- PAGE CONTENT -->
<div class="container-fluid vh-100 pt-5 overflow-hidden">
<!-- FLASH MESSAGES -->
<div class="position-fixed top-0 end-0 p-2 p-md-3 mt-5" style="z-index:1080; width:min(95vw,500px);">
<div class="container mt-3">
{% with messages = get_flashed_messages(with_categories=true) %}
{% if messages %}
{% for category, message in messages %}
<div class="alert alert-{{ category }} alert-dismissible fade show shadow notification-alert mb-2"
role="alert">
<div class="d-flex align-items-start flex-wrap">
{% if category == 'success' %}
<i class="bi bi-check-circle-fill me-2 fs-5 flex-shrink-0"></i>
{% elif category == 'danger' %}
<i class="bi bi-x-circle-fill me-2 fs-5 flex-shrink-0"></i>
{% elif category == 'warning' %}
<i class="bi bi-exclamation-triangle-fill me-2 fs-5 flex-shrink-0"></i>
{% elif category == 'info' %}
<i class="bi bi-info-circle-fill me-2 fs-5 flex-shrink-0"></i>
{% endif %}
<div class="flex-grow-1">
<div class="fw-semibold">
{% if category == 'success' %}
Success
{% elif category == 'danger' %}
Error
{% elif category == 'warning' %}
Warning
{% elif category == 'info' %}
Information
{% endif %}
</div>
<div>
<div class="alert alert-{{ category }} alert-dismissible fade show">
{{ message }}
<button class="btn-close" data-bs-dismiss="alert"></button>
</div>
<!-- Timeline -->
<div class="progress mt-2" style="height:5px;">
<div class="progress-bar progress-bar-striped progress-bar-animated timer-bar" role="progressbar" style="width:100%">
</div>
</div>
</div>
</div>
<button type="button" class="btn-close" data-bs-dismiss="alert">
</button>
</div>
{% endfor %}
{% endif %}
{% endwith %}
</div>
<div class="overflow-auto h-100">
<div class="container mt-4">
{% block content %}{% endblock %}
@@ -302,99 +204,10 @@
</div>
</div>
<!-- Global Loading Overlay -->
<div id="globalLoader"
class="position-fixed top-0 start-0 w-100 h-100 bg-dark bg-opacity-50 d-none"
style="z-index:9999;">
<div class="d-flex justify-content-center align-items-center h-100">
<div class="card shadow-lg border-0 rounded-4" style="width:430px;">
<div class="card-body text-center p-5">
<div class="spinner-border text-primary" style="width:70px;height:70px;"role="status">
</div>
<h4 class="fw-bold mt-4 mb-2">Please Wait...</h4>
<p id="loaderMessage" class="text-muted mb-4">Processing your request...</p>
<div class="progress" style="height:8px;">
<div class="progress-bar progress-bar-striped progress-bar-animated"
style="width:100%">
</div>
</div>
</div>
</div>
</div>
</div>
<!-- Bootstrap JS -->
<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
<script src="https://code.jquery.com/jquery-3.7.0.min.js"></script>
<script src="https://cdn.datatables.net/1.13.6/js/jquery.dataTables.min.js"></script>
<script src="https://cdn.datatables.net/buttons/2.4.1/js/dataTables.buttons.min.js"></script>
<script src="https://cdn.datatables.net/buttons/2.4.1/js/buttons.html5.min.js"></script>
<script src="https://cdn.datatables.net/buttons/2.4.1/js/buttons.print.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/bootstrap-multiselect@1.1.2/dist/js/bootstrap-multiselect.min.js"></script>
<script>
// show alert msg
document.addEventListener("DOMContentLoaded", function () {
document.querySelectorAll(".notification-alert").forEach(function(alert){
const progressBar = alert.querySelector(".timer-bar");
let width = 100;
const interval = setInterval(function() {
width -= 2;
progressBar.style.width = width + "%";
if(width <= 0){
clearInterval(interval);
const bsAlert = bootstrap.Alert.getOrCreateInstance(alert);
bsAlert.close();
}
}, 100);
});
});
// show msg Processing your request
function showLoader(message = "Processing your request...") {
document.getElementById("loaderMessage").innerHTML = message;
document.getElementById("globalLoader").classList.remove("d-none");
}
// Automatically hide
function hideLoader(){
document.getElementById("globalLoader").classList.add("d-none");
}
// Automatically apply to all forms having class="loading-form"
document.addEventListener("DOMContentLoaded", function () {
document.querySelectorAll(".loading-form").forEach(function(form){
form.addEventListener("submit", function(){
if(!this.checkValidity())
return;
showLoader();
const btn = this.querySelector("button[type='submit']");
if(btn){
btn.disabled = true;
btn.innerHTML = `
<span class="spinner-border spinner-border-sm me-2"></span>
Processing...
`;
}
});
});
});
</script>
</body>
</html>

29
app/templates/client_report.html
View File

@@ -2,10 +2,10 @@
{% block content %}
<div class="container-fluid mt-4">
<h2 class="mb-4">Client RA Bills Reports</h2>
<h2 class="mb-4">Client File Reports</h2>
<div class="card p-4 shadow-sm mb-5">
<form method="POST" class="loading-form">
<form method="POST">
<label class="form-label fw-bold">RA Bill No</label>
<input type="text" name="RA_Bill_No" class="form-control mb-3" value="{{ ra_val }}" required>
@@ -15,32 +15,34 @@
Data</button>
</div>
<div class="col-md-6">
<button type="submit" name="action" value="download" class="btn btn-primary w-100">Download Excel Report</button>
<button type="submit" name="action" value="download" class="btn btn-primary w-100">Download Excel
Report</button>
</div>
</div>
</form>
</div>
{% if tables.tr or tables.mh or tables.dc or tables.laying %}
<div class="card shadow-sm p-4">
<h4 class="mb-3">Table Preview</h4>
<div class="card shadow-sm p-3">
<h4 class="mb-3">Comparison Preview</h4>
<ul class="nav nav-tabs" id="reportTabs" role="tablist">
<li class="nav-item">
<button class="nav-link active" id="tr-tab" data-bs-toggle="tab" data-bs-target="#tr"
type="button">Tr.Ex </button>
type="button">Tr.Ex Comparison</button>
</li>
<li class="nav-item">
<button class="nav-link" id="mh-tab" data-bs-toggle="tab" data-bs-target="#mh" type="button">
Mh.Ex</button>
<button class="nav-link" id="mh-tab" data-bs-toggle="tab" data-bs-target="#mh" type="button">Mh.Ex
Comparison</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>
<button class="nav-link" id="dc-tab" data-bs-toggle="tab" data-bs-target="#dc" type="button">MH & DC
Comparison</button>
</li>
<li class="nav-item">
<button class="nav-link" id="laying-tab" data-bs-toggle="tab" data-bs-target="#laying"type="button">
Laying & Bedding </button>
<button class="nav-link" id="laying-tab" data-bs-toggle="tab" data-bs-target="#laying"
type="button">Laying
& Bedding Comparison</button>
</ul>
<div class="tab-content mt-3" id="reportTabsContent">
@@ -69,5 +71,4 @@
{% endif %}
</div>
</div>
{% endblock %}
{% endblock %}

435
app/templates/dashboard.html
View File

@@ -1,51 +1,82 @@
{% extends "base.html" %}
{% block content %}
<div class="container-fluid px-2 px-md-4">
<h4 class="mb-3 text-center text-md-start">Comparison Software Solapur (UGD) - Live Dashboard</h4>
<div class="row g-3 mb-4">
<div class="col-12 col-md-4">
<div class="card text-white bg-primary shadow h-100">
<div class="card-body text-center text-md-start">
<h6>Trenching Units</h6>
<h3 class="fw-bold" id="card-trench">0</h3>
</div>
</div>
</div>
<div class="col-12 col-md-4">
<div class="card text-white bg-success shadow h-100">
<div class="card-body text-center text-md-start">
<h6>Manhole Units</h6>
<h3 class="fw-bold" id="card-manhole">0</h3>
</div>
</div>
</div>
<div class="col-12 col-md-4">
<div class="card text-dark bg-warning shadow h-100">
<div class="card-body text-center text-md-start">
<h6>Laying Units</h6>
<h3 class="fw-bold" id="card-laying">0</h3>
</div>
</div>
</div>
</div>
<div class="container-fluid py-4" style="background-color: #f8f9fa;">
<h3 class="mb-4 fw-bold text-uppercase">Abstract Excavation Dashboard</h3>
<div class="card shadow-sm mb-4">
<div class="card-body bg-white">
<div class="row g-3">
<div class="col-12 col-md-6">
<div class="card shadow-sm h-100">
<div class="card-header bg-dark text-white">Live Category Bar Chart</div>
<div class="card-body">
<canvas id="liveBarChart" style="max-height:300px;"></canvas>
<div class="col-md-2">
<label class="form-label fw-bold">Comparison Type</label>
<select id="filter-table" class="form-select" onchange="loadDashboardData()">
<option value="trench">Trench Excavation</option>
<option value="manhole">Manhole Excavation</option>
<option value="laying">Laying</option>
</select>
</div>
<div class="col-md-3">
<label class="form-label fw-bold">Subcontractor</label>
<select id="filter-subcon" class="form-select" onchange="loadDashboardData()">
<option value="All">All Subcontractors</option>
</select>
</div>
<div class="col-md-3">
<label class="form-label fw-bold">RA Bill No</label>
<select id="filter-ra" class="form-select" onchange="loadDashboardData()">
<option value="Cumulative">Cumulative (All Bills)</option>
</select>
</div>
<div class="col-md-4 d-flex align-items-end gap-2">
<button class="btn btn-primary flex-grow-1" onclick="loadDashboardData()">🔄 Refresh</button>
<button class="btn btn-secondary flex-grow-1" onclick="clearDashboard()">🗑️ Clear</button>
</div>
</div>
</div>
</div>
<div class="col-12 col-md-6">
<!-- Empty State (Shown on page load) -->
<div id="empty-state" class="alert alert-info text-center py-5">
<h5>📊 Select filters to display data</h5>
<p>Choose a Subcontractor and/or RA Bill to see the excavation abstract comparison.</p>
</div>
<!-- Data Display Area (Hidden by default) -->
<div id="data-area" style="display: none;">
<div class="row">
<div class="col-lg-8">
<div class="card shadow-sm h-100">
<div class="card-header bg-dark text-white">Location Distribution Pie Chart</div>
<div class="card-body">
<canvas id="livePieChart" style="max-height:300px;"></canvas>
<div class="card-header bg-primary text-white fw-bold d-flex justify-content-between align-items-center">
<span id="chart-title">Excavation Comparison: Client vs Subcontractor Qty</span>
<small class=\"fw-normal\">(Horizontal Bar Chart)</small>
</div>
<div class=\"card-body\" style=\"position: relative; height: 700px; overflow-y: auto;\">
<canvas id="groupedBarChart"></canvas>
</div>
</div>
</div>
<div class="col-lg-4">
<div class="card shadow-sm h-100">
<div class="card-header bg-success text-white fw-bold">Excavation Abstract Table</div>
<div class="card-body p-0">
<div class="table-responsive" style="max-height: 500px; overflow-y: auto;">
<table class="table table-hover mb-0" id="abstract-table">
<thead class="table-light sticky-top">
<tr>
<th class="small">Soil / Depth</th>
<th class="small">Client (m³)</th>
<th class="small">Subcon (m³)</th>
<th class="small">Diff</th>
</tr>
</thead>
<tbody></tbody>
<tfoot class="table-light fw-bold position-sticky bottom-0">
<tr id="table-totals" class="bg-light"></tr>
</tfoot>
</table>
</div>
</div>
</div>
</div>
</div>
@@ -55,64 +86,290 @@
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<script>
// 2. Initialize the Bar Chart
const barCtx = document.getElementById('liveBarChart').getContext('2d');
let liveBarChart = new Chart(barCtx, {
type: 'bar',
let comparisonChart;
// Define color palette - ONLY 2 COLORS
const colorPalette = {
'client': '#003D7A', // Dark Blue for Client (RA Bill)
'subcon': '#87CEEB' // Light Sky Blue for Subcontractor
};
// 1. Function to Initialize or Update the Chart (VERTICAL BARS - 2 COLORS ONLY)
function updateChartUI(labels, clientData, subconData) {
const ctx = document.getElementById('groupedBarChart').getContext('2d');
if (comparisonChart) comparisonChart.destroy();
comparisonChart = new Chart(ctx, {
type: 'bar', // Vertical bar chart
data: {
labels: ['Trenching', 'Manholes', 'Laying'],
datasets: [{
label: 'Units Completed',
data: [0, 0, 0],
backgroundColor: ['#0d6efd', '#198754', '#ffc107']
}]
labels: labels,
datasets: [
{
label: 'Client Qty (m³)',
data: clientData,
backgroundColor: colorPalette.client,
borderColor: '#001F4D',
borderWidth: 1,
borderRadius: 4,
hoverBackgroundColor: '#002A5C',
hoverBorderWidth: 2
},
options: { responsive: true, maintainAspectRatio: false }
});
// 3. Initialize the Pie Chart
const pieCtx = document.getElementById('livePieChart').getContext('2d');
let livePieChart = new Chart(pieCtx, {
type: 'pie',
data: {
labels: [], // Will be filled from SQL
datasets: [{
data: [],
backgroundColor: ['#0d6efd', '#198754', '#ffc107', '#6f42c1', '#fd7e14']
}]
{
label: 'Subcontractor Qty (m³)',
data: subconData,
backgroundColor: colorPalette.subcon,
borderColor: '#4A90B8',
borderWidth: 1,
borderRadius: 4,
hoverBackgroundColor: '#6BB3D9',
hoverBorderWidth: 2
}
]
},
options: { responsive: true, maintainAspectRatio: false }
options: {
indexAxis: 'x', // Vertical bars (default)
responsive: true,
maintainAspectRatio: false,
interaction: {
intersect: false,
mode: 'index'
},
plugins: {
legend: {
position: 'top',
labels: {
font: { size: 14, weight: 'bold' },
padding: 15,
usePointStyle: true,
boxWidth: 15
}
},
tooltip: {
backgroundColor: '#2c3e50',
padding: 12,
titleFont: { size: 13, weight: 'bold' },
bodyFont: { size: 12 },
borderColor: '#fff',
borderWidth: 1,
displayColors: true,
callbacks: {
label: function(context) {
let label = context.dataset.label || '';
if (label) label += ': ';
label += Number(context.parsed.y).toLocaleString('en-IN', {
minimumFractionDigits: 2,
maximumFractionDigits: 2
}) + ' m³';
return label;
}
}
}
},
scales: {
x: {
stacked: false,
grid: {
display: false
},
ticks: {
font: { size: 11 },
maxRotation: 45,
minRotation: 0
}
},
y: {
stacked: false,
beginAtZero: true,
grid: {
color: '#ecf0f1',
drawBorder: false
},
ticks: {
font: { size: 11 },
callback: function(value) {
return Number(value).toLocaleString('en-IN');
}
},
title: {
display: true,
text: 'Excavation Quantity (m³)',
font: { size: 12, weight: 'bold' }
}
}
}
}
});
}
// 4. Function to Fetch Live Data from your Python API
function fetchLiveData() {
fetch('/dashboard/api/live-stats') // This matches the route we created in the "Kitchen"
.then(response => response.json())
.then(data => {
// Update the Summary Cards
document.getElementById('card-trench').innerText = data.summary.trench;
document.getElementById('card-manhole').innerText = data.summary.manhole;
document.getElementById('card-laying').innerText = data.summary.laying;
// Update Bar Chart
liveBarChart.data.datasets[0].data = [
data.summary.trench,
data.summary.manhole,
data.summary.laying
];
liveBarChart.update();
// Update Pie Chart (Location stats)
livePieChart.data.labels = Object.keys(data.locations);
livePieChart.data.datasets[0].data = Object.values(data.locations);
livePieChart.update();
// 2. Function to fetch unique filters (Subcontractors & RA Bills) from DB
function loadFilters() {
console.log("🔄 Loading filters from /dashboard/api/filters...");
fetch('/dashboard/api/filters')
.then(res => {
console.log(`Response status: ${res.status}`);
return res.json();
})
.catch(err => console.error("Error fetching live data:", err));
.then(data => {
console.log("✓ Filter data received:", data);
const raSelect = document.getElementById('filter-ra');
// CRITICAL: This clears the "RA-01", "RA-02" you typed in manually
raSelect.innerHTML = '<option value="Cumulative">Cumulative (All Bills)</option>';
if (data.ra_bills && data.ra_bills.length > 0) {
console.log(`Adding ${data.ra_bills.length} RA bills to dropdown`);
data.ra_bills.forEach(billNo => {
let opt = document.createElement('option');
opt.value = billNo;
opt.innerText = billNo; // This will show exactly what's in the DB
raSelect.appendChild(opt);
console.log(` + Added RA Bill: ${billNo}`);
});
} else {
console.warn("❌ No RA bills found in response");
}
// 5. Check for updates every 10 seconds (Real-time effect)
setInterval(fetchLiveData, 10000);
fetchLiveData(); // Load immediately on page open
</script>
// Repeat same for subcontractor dropdown
const subconSelect = document.getElementById('filter-subcon');
subconSelect.innerHTML = '<option value="All">All Subcontractors</option>';
if (data.subcontractors && data.subcontractors.length > 0) {
data.subcontractors.forEach(name => {
let opt = document.createElement('option');
opt.value = name;
opt.innerText = name;
subconSelect.appendChild(opt);
});
}
console.log("✓ Filters loaded successfully");
})
.catch(err => {
console.error("❌ Error loading filters:", err);
});
}
// 3. Main function to load data and reflect in UI
function loadDashboardData() {
const tableType = document.getElementById('filter-table').value;
const subcon = document.getElementById('filter-subcon').value;
const ra = document.getElementById('filter-ra').value;
console.log(`📊 Filter values: Table="${tableType}", Subcon="${subcon}", RA="${ra}"`);
// If still on default values, don't load
if (subcon === 'All' && ra === 'Cumulative') {
console.warn("⚠️ Please select filters first");
return;
}
// Update chart title
const tableNames = {
'trench': 'Trench Excavation',
'manhole': 'Manhole Excavation',
'laying': 'Laying'
};
const chartTitle = document.getElementById('chart-title');
if (chartTitle) {
chartTitle.textContent = `${tableNames[tableType]}: Client (RA Bill) vs Subcontractor Qty`;
}
console.log(`📊 Loading dashboard data: Table="${tableType}", Subcon="${subcon}", RA="${ra}"`);
const url = `/dashboard/api/excavation-abstract?table_type=${encodeURIComponent(tableType)}&subcontractor=${encodeURIComponent(subcon)}&ra_bill=${encodeURIComponent(ra)}`;
console.log(`Fetching from URL: ${url}`);
fetch(url)
.then(res => {
console.log(`Response status: ${res.status}`);
if (!res.ok) {
throw new Error(`HTTP Error: ${res.status}`);
}
return res.json();
})
.then(data => {
console.log("✓ Dashboard data received:", data);
if (!Array.isArray(data)) {
console.error("❌ Response is not an array:", data);
return;
}
if (data.length === 0) {
console.warn("⚠️ No data returned for this filter combination");
alert("No data found for selected filters");
return;
}
const labels = [];
const clientData = [];
const subconData = [];
const tableBody = document.querySelector("#abstract-table tbody");
tableBody.innerHTML = "";
let tClient = 0, tSub = 0, tDiff = 0;
data.forEach(item => {
// Label format: "Soil Type Depth"
const label = `${item.soil_type}\n${item.depth}`;
labels.push(label);
clientData.push(item.client_qty || 0);
subconData.push(item.subcon_qty || 0);
tClient += item.client_qty || 0;
tSub += item.subcon_qty || 0;
tDiff += (item.difference || 0);
const diffColor = (item.difference || 0) < 0 ? 'text-danger' : 'text-success';
tableBody.innerHTML += `
<tr>
<td class="small">
<strong>${item.soil_type}</strong>
<br>
<span class="text-muted small">${item.depth}</span>
</td>
<td class="small text-primary fw-bold">${(item.client_qty || 0).toLocaleString('en-IN', {maximumFractionDigits: 2})}</td>
<td class="small text-success fw-bold">${(item.subcon_qty || 0).toLocaleString('en-IN', {maximumFractionDigits: 2})}</td>
<td class="small fw-bold ${diffColor}">${(item.difference || 0).toLocaleString('en-IN', {maximumFractionDigits: 2})}</td>
</tr>
`;
});
const totalDiffColor = tDiff < 0 ? 'text-danger' : 'text-success';
document.getElementById('table-totals').innerHTML = `
<td class="small fw-bold">TOTAL</td>
<td class="small fw-bold text-primary">${tClient.toLocaleString('en-IN', {maximumFractionDigits: 2})}</td>
<td class="small fw-bold text-success">${tSub.toLocaleString('en-IN', {maximumFractionDigits: 2})}</td>
<td class="small fw-bold ${totalDiffColor}">${tDiff.toLocaleString('en-IN', {maximumFractionDigits: 2})}</td>
`;
// Show data area
document.getElementById('empty-state').style.display = 'none';
document.getElementById('data-area').style.display = 'block';
updateChartUI(labels, clientData, subconData);
console.log("✓ Chart and table updated successfully");
})
.catch(err => {
console.error("❌ Error loading dashboard data:", err);
alert(`Failed to load dashboard data: ${err.message}`);
});
}
// Clear dashboard
function clearDashboard() {
console.log("🗑️ Clearing dashboard...");
document.getElementById('filter-table').value = 'trench';
document.getElementById('filter-subcon').value = 'All';
document.getElementById('filter-ra').value = 'Cumulative';
document.getElementById('empty-state').style.display = 'block';
document.getElementById('data-area').style.display = 'none';
if (comparisonChart) comparisonChart.destroy();
}
// Start: Load filters only, don't auto-load data
document.addEventListener("DOMContentLoaded", () => {
console.log("🚀 Dashboard initialized");
loadFilters();
// Don't auto-load data - keep dashboard blank until filters selected
});
</script>
{% endblock %}

84
app/templates/edit_record.html
View File

@@ -1,84 +0,0 @@
{% extends "base.html" %}
{% block content %}
<div class="container-fluid py-4">
<!-- Page Header -->
<div class="card shadow-sm border-0 mb-4">
<div class="card-body d-flex justify-content-between align-items-center">
<div>
<h2 class="fw-bold text-primary mb-1">
<i class="bi bi-pencil-square"></i>
Edit Record
</h2>
<small class="text-muted">
Model: <strong>{{ model|upper }}</strong> &nbsp;|&nbsp; Record ID: {{ record.id }}
</small>
</div>
<a href="{{ url_for('file_report.report_file') }}" class="btn btn-secondary">
<i class="bi bi-arrow-left"></i> Back to Report
</a>
</div>
</div>
<!-- Edit Form -->
<div class="card shadow-sm border-0">
<div class="card-header bg-primary text-white">
<h5 class="mb-0">
<i class="bi bi-card-checklist"></i>
Update Record Details
</h5>
</div>
<div class="card-body">
<form method="POST">
<div class="row g-3">
{% for column in record.__table__.columns %}
{% if column.name != "id" %}
<div class="col-lg-4">
<label class="form-label fw-semibold">
{{ column.name.replace('_', ' ')|title }}
</label>
{% set value = record|attr(column.name) %}
{% if column.type.python_type.__name__ == 'bool' %}
<select name="{{ column.name }}" class="form-select">
<option value="true" {% if value %}selected{% endif %}>Yes</option>
<option value="false" {% if not value %}selected{% endif %}>No</option>
</select>
{% elif column.type.python_type.__name__ in ['int', 'float', 'Decimal'] %}
<input type="number" step="any" name="{{ column.name }}"
class="form-control" value="{{ value if value is not none else '' }}">
{% elif column.type.python_type.__name__ == 'date' %}
<input type="date" name="{{ column.name }}"
class="form-control" value="{{ value if value is not none else '' }}">
{% else %}
<input type="text" name="{{ column.name }}"
class="form-control" value="{{ value if value is not none else '' }}">
{% endif %}
</div>
{% endif %}
{% endfor %}
</div>
<div class="mt-4 d-flex justify-content-end gap-2">
<button type="submit" class="btn btn-primary">
<i class="bi bi-check-circle"></i> Save Changes
</button>
<a href="{{ url_for('file_report.report_file') }}" class="btn btn-secondary">
<i class="bi bi-x-circle"></i> Cancel
</a>
</div>
</form>
</div>
</div>
</div>
{% endblock %}

236
app/templates/engineering/add_rate.html
View File

@@ -1,236 +0,0 @@
{% extends "base.html" %}
{% block content %}
<div class="container-fluid mt-4">
<div class="card shadow">
<div class="card-header bg-primary text-white">
<h4 class="mb-0">
<i class="bi bi-currency-rupee"></i>
Subcontractor Rate Master
</h4>
</div>
<div class="card-body">
<form method="POST">
<div class="row">
<!-- Subcontractor -->
<div class="col-md-4 mb-3">
<label class="form-label fw-bold">
Subcontractor
</label>
<select name="subcontractor_id"
class="form-select"
required>
<option value="">
Select Subcontractor
</option>
{% for sub in subcontractors %}
<option value="{{ sub.id }}">
{{ sub.subcontractor_name }}
</option>
{% endfor %}
</select>
</div>
<!-- Category -->
<div class="col-md-4 mb-3">
<label class="form-label fw-bold">
Category
</label>
<select name="category"
class="form-select"
required>
<option value="">
Select Category
</option>
<option value="TR_EX">
Trench Excavation
</option>
<option value="MH_EX">
Manhole Excavation
</option>
<option value="MH_DC">
Manhole & Domestic Chamber
</option>
<option value="LAYING">
Pipe Laying
</option>
</select>
</div>
<!-- Status -->
<div class="col-md-4 mb-3">
<label class="form-label fw-bold">
Status
</label>
<select name="status"
class="form-select">
<option value="Active">
Active
</option>
<option value="Inactive">
Inactive
</option>
</select>
</div>
</div>
<div class="row">
<!-- Item Code -->
<div class="col-md-3 mb-3">
<label class="form-label fw-bold">
Item Code
</label>
<input type="text"
name="item_code"
class="form-control"
placeholder="SM01"
required>
</div>
<!-- Item Name -->
<div class="col-md-5 mb-3">
<label class="form-label fw-bold">
Item Name
</label>
<input type="text"
name="item_name"
class="form-control"
placeholder="Soft Murum 0-1.5"
required>
</div>
<!-- Unit -->
<div class="col-md-2 mb-3">
<label class="form-label fw-bold">
Unit
</label>
<select name="unit"
class="form-select">
<option value="Cum">Cum</option>
<option value="Nos">Nos</option>
<option value="Rmt">Rmt</option>
<option value="Sqm">Sqm</option>
</select>
</div>
<!-- Rate -->
<div class="col-md-2 mb-3">
<label class="form-label fw-bold">
Rate (₹)
</label>
<input type="number"
step="0.01"
min="0"
name="rate"
class="form-control"
placeholder="0.00"
required>
</div>
</div>
<div class="row">
<!-- Effective From -->
<div class="col-md-3 mb-3">
<label class="form-label fw-bold">
Effective From
</label>
<input type="date"
name="effective_from"
class="form-control"
required>
</div>
<!-- Effective To -->
<div class="col-md-3 mb-3">
<label class="form-label fw-bold">
Effective To
</label>
<input type="date"
name="effective_to"
class="form-control">
</div>
</div>
<hr>
<div class="text-end">
<button type="reset"
class="btn btn-secondary">
<i class="bi bi-arrow-clockwise"></i>
Reset
</button>
<button type="submit"
class="btn btn-success">
<i class="bi bi-check-circle"></i>
Save Rate
</button>
</div>
</form>
</div>
</div>
</div>
{% endblock %}

83
app/templates/engineering/index.html
View File

@@ -1,83 +0,0 @@
{% extends "base.html" %}
{% block content %}
<div class="container-fluid mt-4">
<div class="row mb-4">
<div class="col-12">
<h3 class="fw-bold">
<i class="bi bi-gear-fill text-primary"></i>
Engineering Masters
</h3>
<hr>
</div>
</div>
<div class="row g-4">
<!-- Subcontractor Rate Master -->
<div class="col-lg-4 col-md-6">
<div class="card shadow h-100">
<div class="card-body text-center">
<i class="bi bi-cash-stack text-success"
style="font-size:55px;"></i>
<h5 class="mt-3">
Subcontractor Rate Master
</h5>
<p class="text-muted">
Manage subcontractor-wise rates.
</p>
<a href="{{ url_for('engineering.add_subcontractor_rates') }}"
class="btn btn-success">
<i class="bi bi-arrow-right-circle"></i>
Open Module
</a>
</div>
</div>
</div>
<!-- Client Rate Master -->
<div class="col-lg-4 col-md-6">
<div class="card shadow h-100">
<div class="card-body text-center">
<i class="bi bi-building text-primary"
style="font-size:55px;"></i>
<h5 class="mt-3">
Client Standard Rate Master
</h5>
<p class="text-muted">
Manage client standard rates.
</p>
<a href="{{ url_for('engineering.client_rates') }}"
class="btn btn-primary">
<i class="bi bi-arrow-right-circle"></i>
Open Module
</a>
</div>
</div>
</div>
</div>
</div>
{% endblock %}

0
app/templates/engineering/list.html
View File

158
app/templates/file_import_client.html
View File

@@ -1,145 +1,41 @@
{% extends "base.html" %}
{% block content %}
<h2 class="mb-4">Client File Import</h2>
<div class="container-fluid py-4">
<div class="card p-4 shadow-sm">
<!-- Page Header -->
<div class="row mb-4">
<form method="POST" enctype="multipart/form-data">
<div class="col-12">
<!-- 1. SELECT SUBCONTRACTOR -->
<!-- <label class="form-label">Select Subcontractor vs Client</label>
<select name="subcontractor_id" id="subcontractor_id" class="form-select mb-3" required>
<option value="">-- Select Subcontractor --</option>
<div class="card border-0 shadow-sm bg-success text-white">
{% for sc in subcontractors %}
<option value="{{ sc.id }}">{{ sc.subcontractor_name }}</option>
{% endfor %}
</select> -->
<div class="card-body d-flex justify-content-between align-items-center">
<!-- 2. FILE TYPE (MODEL NAME) -->
<!-- <label class="form-label">Select File Type</label>
<select name="file_type" id="file_type" class="form-select mb-3" required>
<option value="">-- Select File Type --</option>
<option value="">Sheet</option>
<option value="tr_ex_client">Tr. Ex</option>
<option value="mh_ex_client">Mh. Ex </option>
<option value="mh_dc_client">MH & DC </option>
<option value="">Laying Sheet</option>
</select> -->
<div>
<h3 class="fw-bold mb-1">
<i class="bi bi-building-fill-up me-2"></i>
Client RA Bill Import
</h3>
<p class="mb-0 opacity-75">
Upload the Client RA Bill Excel file for comparison.
</p>
</div>
<div class="display-5">
<i class="bi bi-file-earmark-excel-fill"></i>
</div>
</div>
</div>
</div>
</div>
<!-- Upload Card -->
<div class="row justify-content-center">
<div class="col-lg-7">
<div class="card border-0 shadow">
<div class="card-header bg-light">
<h5 class="mb-0 fw-bold text-success">
<i class="bi bi-upload me-2"></i>
Upload Details
</h5>
</div>
<div class="card-body p-4">
<form method="POST"
enctype="multipart/form-data"
class="loading-form"
onsubmit="showLoader('Reading Excel file...<br>Validating records...<br>Saving data to database...')">
<!-- RA Bill -->
<div class="mb-4">
<label class="form-label fw-semibold">
<i class="bi bi-receipt-cutoff text-success me-2"></i>
RA Bill No
<span class="text-danger">*</span>
</label>
<input
type="text"
name="RA_Bill_No"
class="form-control"
placeholder="Enter RA Bill Number"
required>
</div>
<!-- Upload -->
<div class="mb-4">
<label class="form-label fw-semibold">
<i class="bi bi-file-earmark-arrow-up text-primary me-2"></i>
Select Excel File
<span class="text-danger">*</span>
</label>
<input
type="file"
name="file"
class="form-control"
accept=".xlsx,.xls,.csv"
required>
<div class="form-text">
Supported Formats:
<strong>.xlsx</strong>,
<strong>.xls</strong>,
<strong>.csv</strong>
</div>
</div>
<hr>
<!-- Action Buttons -->
<div class="d-flex justify-content-between">
<button
type="submit"
class="btn btn-success px-5">
<i class="bi bi-cloud-upload-fill me-2"></i>
Upload File
</button>
</div>
<label class="form-label">RA Bill No</label>
<input type="text" name="RA_Bill_No" class="form-control mb-3" required>
<!-- 3. FILE UPLOAD -->
<label class="form-label">Choose File</label>
<input type="file" name="file" class="form-control mb-3" required>
<button class="btn btn-primary w-100">Upload</button>
</form>
</div>
</div>
</div>
</div>
</div>
{% endblock %}

123
app/templates/file_import_subcontractor.html
View File

@@ -1,125 +1,32 @@
{% extends "base.html" %}
{% block content %}
<h2 class="mb-4">Sub-Contractor File Import</h2>
<div class="container-fluid py-4">
<div class="card p-4 shadow-sm">
<!-- Page Header -->
<div class="row mb-4">
<div class="col-lg-12">
<div class="card border-0 shadow-sm bg-primary text-white">
<div class="card-body d-flex justify-content-between align-items-center">
<form method="POST" enctype="multipart/form-data">
<div>
<h3 class="mb-1 fw-bold">
<i class="bi bi-cloud-arrow-up-fill me-2"></i>
Sub-Contractor File Import
</h3>
<!-- 1. SELECT SUBCONTRACTOR -->
<label class="form-label">Select Subcontractor</label>
<select name="subcontractor_id" id="subcontractor_id" class="form-select mb-3" required>
<option value="">-- Select Subcontractor --</option>
<p class="mb-0 opacity-75">
Upload RA Bill Excel file for the selected subcontractor.
</p>
</div>
<div class="display-5">
<i class="bi bi-file-earmark-excel-fill"></i>
</div>
</div>
</div>
</div>
</div>
<!-- Upload Card -->
<div class="row justify-content-center">
<div class="col-lg-8">
<div class="card border-0 shadow">
<div class="card-header bg-light">
<h5 class="mb-0 fw-bold text-primary">
<i class="bi bi-upload me-2"></i>
Upload Details
</h5>
</div>
<div class="card-body p-4">
<form method="POST"
enctype="multipart/form-data"
class="loading-form"
onsubmit="showLoader('Reading Excel file...<br>Saving data to database...')">
<!-- Select Subcontractor -->
<div class="mb-4">
<label class="form-label fw-semibold">
<i class="bi bi-building me-1 text-primary"></i>
Select Subcontractor
<span class="text-danger">*</span>
</label>
<select name="subcontractor_id" id="subcontractor_id"
class="form-select" required>
<option value=""> -- Select Subcontractor -- </option>
{% for sc in subcontractors %}
<option value="{{ sc.id }}">{{ sc.subcontractor_name }} </option>
<option value="{{ sc.id }}">{{ sc.subcontractor_name }}</option>
{% endfor %}
</select>
</div>
<!-- RA Bill No -->
<div class="mb-4">
<label class="form-label fw-semibold">
<i class="bi bi-receipt me-1 text-success"></i>
RA Bill No
<span class="text-danger">*</span>
</label>
<!-- 2. RA bill no -->
<label class="form-label">RA Bill No</label>
<input type="text" name="RA_Bill_No" class="form-control mb-3" required>
<input type="text"
name="RA_Bill_No"
class="form-control"
placeholder="Enter RA Bill Number"
required>
</div>
<!-- 3. FILE UPLOAD -->
<label class="form-label">Choose File</label>
<input type="file" name="file" class="form-control mb-3" required>
<!-- File Upload -->
<div class="mb-4">
<label class="form-label fw-semibold">
<i class="bi bi-file-earmark-arrow-up me-1 text-warning"></i>
Upload Excel File
<span class="text-danger">*</span>
</label>
<input type="file"
name="file"
class="form-control"
accept=".xlsx,.xls,.csv"
required>
<div class="form-text">
Supported formats:
<strong>.xlsx</strong>,
<strong>.xls</strong>,
<strong>.csv</strong>
</div>
</div>
<hr>
<!-- Buttons -->
<div class="d-flex justify-content-between">
<button type="submit" class="btn btn-primary px-5">
<i class="bi bi-cloud-upload-fill me-2"></i>
Upload File
</button>
</div>
<button class="btn btn-primary w-100">Upload</button>
</form>
</div>
</div>
</div>
</div>
</div>
{% endblock %}

13
app/templates/generate_comparison_report.html
View File

@@ -5,9 +5,22 @@
<h2 class="mb-4">Subcontractor vs Client Comparison</h2>
<!-- FLASH MESSAGES -->
{% with messages = get_flashed_messages(with_categories=true) %}
{% if messages %}
{% for category, message in messages %}
<div class="alert alert-{{ category }} alert-dismissible fade show" role="alert">
{{ message }}
<button type="button" class="btn-close" data-bs-dismiss="alert"></button>
</div>
{% endfor %}
{% endif %}
{% endwith %}
<div class="card p-4 shadow-sm">
<form method="POST">
<!-- SELECT SUBCONTRACTOR -->
<label class="form-label fw-semibold">Select Subcontractor</label>
<select name="subcontractor_id" id="subcontractor_id" class="form-select mb-3" required>

191
app/templates/login.html
View File

@@ -8,200 +8,75 @@
<!-- Bootstrap CSS -->
<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
<link href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.3/font/bootstrap-icons.css" rel="stylesheet">
</head>
<body class="bg-light">
<!-- Flash Messages -->
<div class="position-fixed top-0 end-0 p-3"
style="z-index:1080; width:min(95vw,420px);">
<div class="container-fluid vh-100">
<div class="row h-100 justify-content-center align-items-center">
<!-- Increased column width -->
<div class="col-12 col-sm-10 col-md-8 col-lg-5 col-xl-4">
<div class="card shadow-lg border-0">
<!-- Increased padding -->
<div class="card-body p-5">
<!-- Branding -->
<div class="text-center mb-4">
<img src="{{ url_for('static', filename='images/lcepl.png') }}" alt="LCEPL Logo"
class="img-fluid mb-3" style="max-height:80px;">
<h4 class="fw-bold mb-1">
Laxmi Civil Engineering Services Pvt Ltd
</h4>
<p class="text-muted mb-0">
Data Comparison Software Solapur(UGD)
</p>
</div>
<!-- Flash messages -->
{% with messages = get_flashed_messages(with_categories=true) %}
{% if messages %}
{% for category, message in messages %}
<div class="alert alert-{{ category }} alert-dismissible fade show shadow notification-alert">
<strong>
{% if category=="success" %}
<i class="bi bi-check-circle-fill me-2"></i>Success
{% elif category=="danger" %}
<i class="bi bi-x-circle-fill me-2"></i>Error
{% elif category=="warning" %}
<i class="bi bi-exclamation-triangle-fill me-2"></i>Warning
{% else %}
<i class="bi bi-info-circle-fill me-2"></i>Information
{% endif %}
</strong>
<div>{{ message }}</div>
<div class="progress mt-2" style="height:4px;">
<div class="progress-bar progress-bar-striped progress-bar-animated timer-bar"
style="width:100%"></div>
<div class="alert alert-{{ category }} alert-dismissible fade show" role="alert">
{{ message }}
<button type="button" class="btn-close" data-bs-dismiss="alert"></button>
</div>
<button class="btn-close"
data-bs-dismiss="alert">
</button>
</div>
{% endfor %}
{% endif %}
{% endwith %}
</div>
<div class="container">
<div class="row justify-content-center align-items-center min-vh-100">
<div class="col-12 col-sm-10 col-md-8 col-lg-6 col-xl-5">
<div class="card shadow-lg border-0">
<div class="card-body p-5">
<div class="text-center mb-4">
<img src="{{ url_for('static', filename='images/lcepl.png') }}"
class="img-fluid mb-3"
style="max-height:100px;">
<h3 class="fw-bold text-success">Laxmi Civil Engineering Services Pvt Ltd</h3>
<p class="text-muted">Data Comparison Software (UGD)</p>
</div>
<!-- Login Form -->
<form method="POST">
<div class="mb-3">
<label class="form-label fw-semibold">Username</label>
<div class="input-group">
<span class="input-group-text">
<i class="bi bi-envelope-fill"></i>
</span>
<input
type="text"
name="email"
class="form-control"
placeholder="Enter Domain Username"
autocomplete="username"
<div class="mb-4">
<label class="form-label fw-semibold">User Name</label>
<input type="email" name="email" class="form-control " placeholder="Enter email"
required>
</div>
</div>
</div>
<div class="mb-4">
<label class="form-label fw-semibold">Password</label>
<div class="input-group">
<span class="input-group-text">
<i class="bi bi-lock-fill"></i>
</span>
<input
type="password"
id="password"
name="password"
class="form-control"
placeholder="Enter Password"
<input type="password" name="password" class="form-control" placeholder="Enter password"
required>
<button
type="button"
id="togglePassword"
class="input-group-text bg-white border-start-0"
style="cursor:pointer;">
<i class="bi bi-eye text-secondary"></i>
</button>
</div>
</div>
<button
class="btn btn-success w-100 btn-lg">
<i class="bi bi-box-arrow-in-right me-2"></i>
<button class="btn btn-success btn-lg w-100">
Login
</button>
<div class="text-center mt-3">
<a href="#">Forgot Password?</a>
</div>
</form>
</div>
</div>
<div class="text-center mt-3">
<small class="text-muted">
© 2026 Laxmi Civil Engineering Services Pvt Ltd
</small>
</div>
</div>
</div>
</div>
<!-- Bootstrap JS -->
<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
<script>
document.addEventListener("DOMContentLoaded", function () {
// Password Show / Hide
const togglePassword = document.getElementById("togglePassword");
const password = document.getElementById("password");
if (togglePassword && password) {
togglePassword.addEventListener("click", function () {
const type =
password.getAttribute("type") === "password"
? "text"
: "password";
password.setAttribute("type", type);
this.innerHTML =
type === "password"
? '<i class="bi bi-eye"></i>'
: '<i class="bi bi-eye-slash"></i>';
});
}
// Auto Close Notification after 5 sec
document.querySelectorAll(".notification-alert").forEach(function (alert) {
const progressBar = alert.querySelector(".timer-bar");
let width = 100;
const interval = setInterval(function () {
width -= 2;
progressBar.style.width = width + "%";
if (width <= 0) {
clearInterval(interval);
bootstrap.Alert
.getOrCreateInstance(alert)
.close();
}
}, 100);
});
});
</script>
</body>
</html>

172
app/templates/subcontractor/add.html
View File

@@ -1,170 +1,40 @@
{% extends "base.html" %}
{% block content %}
<div class="container-fluid">
<div class="card shadow-sm p-4">
<!-- Page Header -->
<div class="d-flex justify-content-between align-items-center mb-4">
<div>
<h3 class="fw-bold mb-1">
<i class="bi bi-person-plus-fill text-success me-2"></i>
Add New Subcontractor
</h3>
<p class="text-muted mb-0">
Enter the subcontractor details below.
</p>
<h4 class="mb-3">Add New Subcontractor</h4>
<form action="/subcontractor/save" method="POST">
<div class="mb-3">
<label class="form-label">Subcontractor Name</label>
<input type="text" class="form-control" name="subcontractor_name" required>
</div>
<a href="{{ url_for('subcontractor.subcontractor_list') }}"
class="btn btn-outline-secondary">
<i class="bi bi-arrow-left me-2"></i>
Back to List
</a>
<div class="mb-3">
<label class="form-label">Contact Person Name</label>
<input type="text" class="form-control" name="contact_person">
</div>
<div class="card shadow border-0">
<div class="card-header bg-success text-white">
<h5 class="mb-0">
<i class="bi bi-building-fill-add me-2"></i>
Subcontractor Information
</h5>
<div class="mb-3">
<label class="form-label">Mobile</label>
<input type="text" class="form-control" name="mobile_no">
</div>
<div class="card-body">
<form action="{{ url_for('subcontractor.save_subcontractor') }}"
method="POST"
class="loading-form">
<div class="row g-4">
<!-- Subcontractor Name -->
<div class="col-md-6">
<label class="form-label fw-semibold">
<i class="bi bi-building me-1"></i>
Subcontractor Name
<span class="text-danger">*</span>
</label>
<input type="text"
class="form-control"
name="subcontractor_name"
placeholder="Enter Subcontractor Name"
required>
<div class="mb-3">
<label class="form-label">Email</label>
<input type="email" class="form-control" name="email_id">
</div>
<!-- Contact Person -->
<div class="col-md-6">
<label class="form-label fw-semibold">
<i class="bi bi-person-fill me-1"></i>
Contact Person
</label>
<input type="text"
class="form-control"
name="contact_person"
placeholder="Enter Contact Person">
</div>
<!-- Mobile -->
<div class="col-md-6">
<label class="form-label fw-semibold">
<i class="bi bi-telephone-fill me-1"></i>
Mobile Number
</label>
<input type="text"
class="form-control"
name="mobile_no"
maxlength="10"
placeholder="Enter Mobile Number">
</div>
<!-- Email -->
<div class="col-md-6">
<label class="form-label fw-semibold">
<i class="bi bi-envelope-fill me-1"></i>
Email Address
</label>
<input type="email"
class="form-control"
name="email_id"
placeholder="Enter Email Address">
</div>
<!-- GST -->
<div class="col-md-6">
<label class="form-label fw-semibold">
<i class="bi bi-receipt-cutoff me-1"></i>
GST Number
</label>
<input type="text"
class="form-control"
name="gst_no"
placeholder="Enter GST Number">
</div>
<!-- PAN -->
<div class="col-md-6">
<label class="form-label fw-semibold">
<i class="bi bi-credit-card-2-front-fill me-1"></i>
PAN Number
</label>
<input type="text"
class="form-control"
name="pan_no"
placeholder="Enter PAN Number">
</div>
<!-- Address -->
<div class="col-12">
<label class="form-label fw-semibold">
<i class="bi bi-geo-alt-fill me-1"></i>
Address
</label>
<textarea class="form-control"
rows="4"
name="address"
placeholder="Enter Complete Address"></textarea>
</div>
</div>
<hr class="my-4">
<div class="d-flex justify-content-end gap-2">
<button type="reset"
class="btn btn-outline-warning">
<i class="bi bi-arrow-clockwise me-2"></i>
Reset
</button>
<a href="{{ url_for('subcontractor.subcontractor_list') }}"
class="btn btn-outline-secondary">
<i class="bi bi-x-circle me-2"></i>
Cancel
</a>
<button type="submit"
class="btn btn-success">
<i class="bi bi-check-circle-fill me-2"></i>
Save Subcontractor
</button>
<div class="mb-3">
<label class="form-label">GST No</label>
<input type="text" class="form-control" name="gst_no">
</div>
<button class="btn btn-success">Save</button>
</form>
</div>
</div>
</div>
{% endblock %}

36
app/templates/subcontractor/edit.html
View File

@@ -4,58 +4,36 @@
<div class="card shadow-sm p-4">
<h4 class="mb-3">Edit Subcontractor</h4>
<form action="{{ url_for('subcontractor.update_subcontractor', id=subcontractor.id) }}" method="POST">
<form action="/subcontractor/update/{{ subcontractor.id }}" method="POST">
<div class="mb-3">
<label class="form-label">Subcontractor Name:</label>
<label class="form-label">Subcontractor Name</label>
<input type="text" class="form-control" name="subcontractor_name"
value="{{ subcontractor.subcontractor_name }}" required>
</div>
<div class="mb-3">
<label class="form-label">Contact Person Name:</label>
<label class="form-label">Contact Person</label>
<input type="text" class="form-control" name="contact_person" value="{{ subcontractor.contact_person }}">
</div>
<div class="mb-3">
<label class="form-label">Address:</label>
<input type="text" class="form-control" name="address" value="{{ subcontractor.address }}">
</div>
<div class="mb-3">
<label class="form-label">Mobile No:</label>
<label class="form-label">Mobile</label>
<input type="text" class="form-control" name="mobile_no" value="{{ subcontractor.mobile_no }}">
</div>
<div class="mb-3">
<label class="form-label">Email:</label>
<label class="form-label">Email</label>
<input type="email" class="form-control" name="email_id" value="{{ subcontractor.email_id }}">
</div>
<div class="mb-3">
<label class="form-label">GST No:</label>
<label class="form-label">GST No</label>
<input type="text" class="form-control" name="gst_no" value="{{ subcontractor.gst_no }}">
</div>
<div class="mb-3">
<label class="form-label">PAN No:</label>
<input type="text" class="form-control" name="pan_no" value="{{ subcontractor.pan_no }}">
</div>
<div class="mb-3">
<label class="form-label">Status:</label>
<select name="status" class="form-control">
<option value="Active" {% if subcontractor.status=="Active" %}selected{% endif %}>
Active
</option>
<option value="Inactive" {% if subcontractor.status=="Inactive" %}selected{% endif %}>
Inactive
</option>
</select>
</div>
<button class="btn btn-success">Update</button>
<a href="{{ url_for('subcontractor.subcontractor_list') }}" class="btn btn-secondary">Back</a>
<a href="/subcontractor/list" class="btn btn-secondary">Back</a>
</form>
</div>

193
app/templates/subcontractor/list.html
View File

@@ -1,162 +1,91 @@
{% extends "base.html" %}
{% block content %}
<div class="container mt-4">
<div class="card shadow-sm p-3 p-md-4">
<div class="d-flex flex-column flex-md-row justify-content-between align-items-md-center mb-3">
<h4 class="mb-3 mb-md-0">Subcontractor List</h4>
<a href="{{ url_for('subcontractor.add_subcontractor') }}" class="btn btn-primary btn-sm">
+ Add Subcontractor
</a>
<!-- Header -->
<div class="row mb-3 align-items-center">
<div class="col-12 col-md-6 ">
<h4 class="mb-2 mb-md-0 text-center text-md-start">
Subcontractor List
</h4>
</div>
<div class="card shadow-sm">
<div class="card-body p-2 p-md-3">
<div class="col-12 col-md-3 text-center text-md-end">
<a href="/subcontractor/add" class="btn btn-success w-100 w-md-auto">
➕ Add Subcontractor
</a>
</div>
</div>
<!-- Desktop Table View -->
<div class="table-responsive d-none d-md-block">
<table class="table table-bordered table-hover align-middle">
<div class="table-responsive">
<table class="table table-bordered table-striped align-middle text-nowrap">
<thead class="table-dark">
<tr>
<th>Sr. No</th>
<th>Subcontractor Name</th>
<th>GST No</th>
<th>Mobile</th>
<th>Email</th>
<th>Status</th>
<th width="150">Action</th>
<th>ID</th>
<th>Name</th>
<th class="d-none d-md-table-cell">Mobile</th>
<th class="d-none d-lg-table-cell">Email</th>
<th class="d-none d-lg-table-cell">GST No</th>
<th class="text-center">Action</th>
</tr>
</thead>
<tbody>
{% for s in subcontractors %}
<tr>
<td>{{ s.id }}</td>
<td>{{ s.subcontractor_name }}</td>
<td>{{ s.gst_no }}</td>
<td>{{ s.mobile_no }}</td>
<td>{{ s.email_id }}</td>
<td>
{% if s.status == "Active" %}
<span class="badge bg-success">Active</span>
{% else %}
<span class="badge bg-danger">Inactive</span>
{% endif %}
<td class="fw-semibold text-wrap">
{{ s.subcontractor_name }}
</td>
<td>
<a href="{{ url_for('subcontractor.edit_subcontractor', id=s.id) }}"
class="btn btn-sm btn-warning mb-1">
<td class="d-none d-md-table-cell">
{{ s.mobile_no }}
</td>
<td class="d-none d-lg-table-cell">
{{ s.email_id }}
</td>
<td class="d-none d-lg-table-cell">
{{ s.gst_no }}
</td>
<!-- Action Buttons -->
<td class="text-center">
<div class="d-flex flex-column gap-1">
<a href="/subcontractor/edit/{{ s.id }}" class="btn btn-sm btn-warning">
Edit
</a>
<a href="{{ url_for('subcontractor.delete_subcontractor', id=s.id) }}"
class="btn btn-sm btn-danger" onclick="return confirm('Are you sure to delete?')">
<a href="/subcontractor/delete/{{ s.id }}" class="btn btn-sm btn-danger"
onclick="return confirm('Are you sure?')">
Delete
</a>
</div>
</td>
</tr>
{% endfor %}
</tbody>
<!-- TOTAL ROW -->
<tfoot>
<tr class="table-secondary fw-bold">
<td colspan="2" class="text-end"> Total Subcontractors</td>
<td class="d-none d-lg-table-cell">-</td>
<td class="d-none d-lg-table-cell">-</td>
<td class="d-none d-lg-table-cell">-</td>
<td class="text-center">{{ subcontractors|length }}</td>
</tr>
</tfoot>
</table>
</div>
<!-- Mobile Card View -->
<div class="d-md-none">
{% for s in subcontractors %}
<div class="card mb-3 shadow-sm">
<div class="card-body p-3">
<h5 class="fw-bold mb-2">{{ s.subcontractor_name }}</h5>
<p class="mb-1"><strong>GST No:</strong> {{ s.gst_no }}</p>
<p class="mb-1"><strong>Mobile:</strong> {{ s.mobile_no }}</p>
<p class="mb-1"><strong>Email:</strong> {{ s.email_id }}</p>
<p class="mb-2">
<strong>Status:</strong>
{% if s.status == "Active" %}
<span class="badge bg-success">Active</span>
{% else %}
<span class="badge bg-danger">Inactive</span>
{% endif %}
</p>
<div class="d-flex gap-2">
<a href="{{ url_for('subcontractor.edit_subcontractor', id=s.id) }}"
class="btn btn-sm btn-warning w-50">
Edit
</a>
<a href="{{ url_for('subcontractor.delete_subcontractor', id=s.id) }}"
class="btn btn-sm btn-danger w-50" onclick="return confirm('Are you sure to delete?')">
Delete
</a>
</div>
</div>
</div>
{% endfor %}
</div>
<!-- Pagination -->
<nav>
<ul class="pagination justify-content-center flex-wrap mt-4">
{% if pagination.has_prev %}
<li class="page-item">
<a class="page-link" href="{{ url_for('subcontractor.subcontractor_list', page=1) }}">
First
</a>
</li>
<li class="page-item">
<a class="page-link"
href="{{ url_for('subcontractor.subcontractor_list', page=pagination.prev_num) }}">
Prev
</a>
</li>
{% endif %}
{% for page_num in pagination.iter_pages() %}
{% if page_num %}
{% if page_num != pagination.page %}
<li class="page-item">
<a class="page-link" href="{{ url_for('subcontractor.subcontractor_list', page=page_num) }}">
{{ page_num }}
</a>
</li>
{% else %}
<li class="page-item active">
<span class="page-link">{{ page_num }}</span>
</li>
{% endif %}
{% else %}
<li class="page-item disabled">
<span class="page-link">...</span>
</li>
{% endif %}
{% endfor %}
{% if pagination.has_next %}
<li class="page-item">
<a class="page-link"
href="{{ url_for('subcontractor.subcontractor_list', page=pagination.next_num) }}">
Next
</a>
</li>
<li class="page-item">
<a class="page-link"
href="{{ url_for('subcontractor.subcontractor_list', page=pagination.pages) }}">
Last
</a>
</li>
{% endif %}
</ul>
</nav>
</div>
</div>
</div>
{% endblock %}

372
app/templates/subcontractor_dashboard.html
View File

@@ -1,379 +1,29 @@
{% extends "base.html" %}
{% block content %}
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/choices.js/public/assets/styles/choices.min.css">
<script src="https://cdn.jsdelivr.net/npm/choices.js/public/assets/scripts/choices.min.js"></script>
<div class="container-fluid px-2 px-md-4">
<h4 class="mb-3 text-center text-md-start">Subcontractor Dashboard </h4>
<div class="container-fluid py-4">
<!-- HEADER -->
<div class="card shadow border-0 mb-4">
<div class="card-body">
<div class="d-flex justify-content-between align-items-center">
<div>
<h3 class="fw-bold text-primary">
<i class="bi bi-bar-chart-fill"></i>
RA Bill Analytics Dashboard
</h3>
<small class="text-muted">
Compare Quantity, Depth & RA Bill Analytics
</small>
</div>
<div>
<button class="btn btn-success" id="exportExcel">
<i class="bi bi-file-earmark-excel"></i>
Excel
</button>
<button class="btn btn-danger" id="exportPDF">
<i class="bi bi-file-earmark-pdf"></i>
PDF
</button>
</div>
</div>
</div>
</div>
<!-- FILTERS -->
<div class="card shadow-sm mb-4">
<div class="card-header bg-primary text-white">
<h5 class="mb-0">
<i class="bi bi-funnel-fill"></i>
Filters
</h5>
</div>
<div class="card-body">
<!-- Charts -->
<div class="row g-3">
<!-- Contractor -->
<div class="col-lg-4">
<label class="form-label fw-bold"> Subcontractor </label>
<select class="form-select" id="subcontractor">
<option value="">--- select contractor ---</option>
{% for s in subcontractors %}
<option value="{{s.id}}">
{{s.subcontractor_name}}
</option>
{% endfor %}
</select>
<!-- Bar Chart -->
<div class="col-12 col-md-6">
<div class="card shadow-sm h-100">
<div class="card-header bg-dark text-white text-center text-md-start">
Work Category Bar Chart
</div>
<!-- Category -->
<div class="col-lg-4">
<label class="form-label fw-bold">Category</label>
<select class="form-select" id="category">
<option value="">--- select category ---</option>
<option value="trench_excavation">Trench Excavation</option>
<option value="manhole_excavation">Manhole Excavation</option>
<option value="Manhole_Domestic_Chamber">Manhole Domestic Chamber</option>
<option value="Laying">Pipe Laying</option>
</select>
<div class="card-body text-center">
<img src="data:image/png;base64,{{ bar_chart }}" class="img-fluid" style="max-height:300px;">
</div>
<!-- RA Bill -->
<div class="col-lg-4">
<label class="form-label fw-bold"> RA Bills</label>
<select id="ra_bill" class="form-select" multiple></select>
</div>
</div>
<hr>
<!-- Search button -->
<button class="btn btn-primary" id="searchBtn">
<i class="bi bi-search"></i>Search
</button>
<!-- Reset button -->
<button class="btn btn-secondary" id="resetBtn">
<i class="bi bi-arrow-clockwise"></i>Reset
</button>
</div>
</div>
<!-- TABS -->
<div class="card shadow">
<div class="card-header">
<ul class="nav nav-pills">
<!--Bar Chart Tab -->
<li class="nav-item">
<button class="nav-link active"
data-bs-toggle="tab"
data-bs-target="#barTab">
<i class="bi bi-bar-chart"></i> Bar Chart
</button>
</li>
<!-- Data Table Tab -->
<li class="nav-item">
<button class="nav-link"
data-bs-toggle="tab"
data-bs-target="#tableTab">
<i class="bi bi-table"></i> Data Table
</button>
</li>
</ul>
</div>
<div class="card-body">
<div class="tab-content">
<!-- BAR TAB -->
<div class="tab-pane fade show active" id="barTab">
<div style="height:600px">
<canvas id="barChart"></canvas>
</div>
</div>
<!-- TABLE TAB -->
<div class="tab-pane fade" id="tableTab">
<div class="table-responsive">
<table class="table table-bordered table-hover" id="resultTable">
<thead class="table-dark">
<tr>
<th>Sr No</th>
<th>Strata Type & Depth</th>
<th class="text-end">Client Qty</th>
<th class="text-end">Sub Contractor Qty</th>
<th class="text-end">Difference</th>
</tr>
</thead>
<tbody></tbody>
</table>
</div>
</div>
</div>
</div>
</div>
</div>
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<script src="https://code.jquery.com/jquery-3.7.1.min.js"></script>
<script>
let barChart;
let raBillChoice;
/* Load RA Bills */
function loadRABills(){
let subcontractor = document.getElementById("subcontractor").value
let category = document.getElementById("category").value
if (!raBillChoice)
return;
if (!subcontractor || !category) {
raBillChoice.clearStore();
return;
}
fetch(`/dashboard/api/get-ra-bills?subcontractor=${subcontractor}&category=${category}`)
.then(res => res.json())
.then(data => {
raBillChoice.clearStore();
let choices = [];
data.ra_bills.forEach(function(bill){
choices.push({
value: bill,
label: bill
});
});
raBillChoice.setChoices(
choices,
"value",
"label",
true
);
});
}
/* Search */
function loadDashboard() {
const subcontractor = document.getElementById("subcontractor").value;
const category = document.getElementById("category").value;
let raBills = [];
if (raBillChoice) {
raBills = raBillChoice.getValue(true);
}
let apiUrl = "";
switch (category) {
case "trench_excavation":
apiUrl = "/dashboard/api/tr-analysis";
break;
case "manhole_excavation":
apiUrl = "/dashboard/api/mh-analysis";
break;
case "Manhole_Domestic_Chamber":
apiUrl = "/dashboard/api/mdc-analysis";
break;
case "Laying":
apiUrl = "/dashboard/api/laying-analysis";
break;
default:
alert("Please select category");
return;
}
fetch(`${apiUrl}?subcontractor=${subcontractor}&category=${category}&ra_bill=${raBills.join(",")}`)
.then(response => response.json())
.then(data => {
drawBar(data);
drawTable(data);
})
.catch(err => console.error(err));
}
/* BAR */
function drawBar(data) {
if (barChart) {
barChart.destroy();
}
const ctx = document.getElementById("barChart");
barChart = new Chart(ctx, {
type: "bar",
data: {
labels: data.labels,
datasets: [
{
label: "Client Qty",
data: data.client_qty,
backgroundColor: "#0d6efd",
borderColor: "#0d6efd",
borderWidth: 1
},
{
label: "Sub-Contractor Qty",
data: data.sub_qty,
backgroundColor: "#fd7e14",
borderColor: "#fd7e14",
borderWidth: 1
}
]
},
options: {
responsive: true,
maintainAspectRatio: false,
interaction: {
mode: "index",
intersect: false
},
plugins: {
title: {
display: true,
text: data.title
},
legend: {
position: "bottom"
}
},
scales: {
x: {
ticks: {
autoSkip: false,
maxRotation: 45,
minRotation: 45
}
},
y: {
beginAtZero: true,
title: {
display: true,
text: data.y_title
}
}
}
}
});
}
/* TABLE */
function drawTable(data){
let html='';
for(let i=0;i<data.labels.length;i++){
const clientQty = Number(data.client_qty[i] || 0);
const subQty = Number(data.sub_qty[i] || 0);
const diff = clientQty - subQty;
html+=`
<tr>
<td class="text-center">${i + 1}</td>
<td>${data.labels[i]}</td>
<td class="text-end">${data.client_qty[i]}</td>
<td class="text-end">${data.sub_qty[i]}</td>
<td class="text-end fw-bold ${diff >= 0 ? 'text-success' : 'text-danger'}">${diff.toFixed(2)}</td>
</tr>
`;
}
document.querySelector("#resultTable tbody").innerHTML = html;
}
/* EVENTS */
document.getElementById("subcontractor").addEventListener("change", loadRABills);
document.getElementById("category").addEventListener("change", loadRABills);
document.getElementById("searchBtn").addEventListener("click", loadDashboard);
document.getElementById("resetBtn").addEventListener("click", function () {location.reload();});
document.addEventListener("DOMContentLoaded", function () {
raBillChoice = new Choices("#ra_bill", {
removeItemButton: true,
searchEnabled: true,
searchPlaceholderValue: "Search RA Bills",
placeholder: true,
placeholderValue: "Select RA Bills",
shouldSort: false,
itemSelectText: ""
});
});
</script>
{% endblock %}

338
app/templates/subcontractor_report.html
View File

@@ -1,253 +1,117 @@
{% extends "base.html" %}
{% block content %}
<div class="container my-4">
<div class="container-fluid py-4">
<h2 class="text-center mb-4">Generate Subcontractor Report</h2>
<!-- Page Header -->
<div class="card shadow-sm border-0 mb-4">
<div class="card-body">
<div class="d-flex justify-content-between align-items-center">
<div>
<h2 class="fw-bold text-primary mb-1">
<i class="bi bi-file-earmark-bar-graph"></i>
Subcontractor Report
</h2>
<small class="text-muted">
View, Filter, Edit and Delete Subcontractor Records
</small>
</div>
</div>
</div>
</div>
<!-- FORM -->
<div class="card shadow-sm p-3 p-md-4 mx-auto" style="max-width:600px;">
<form method="POST">
<!-- Filter Card -->
<div class="card shadow-sm border-0">
<div class="card-header bg-primary text-white">
<h5 class="mb-0">
<i class="bi bi-funnel-fill"></i>
Report Filters
</h5>
</div>
<div class="card-body">
<form method="POST" class="loading-form">
<div class="row g-3">
<div class="col-lg-3">
<label class="form-label fw-semibold">
Subcontractor
<span class="text-danger">*</span>
</label>
<div class="mb-3">
<label class="form-label fw-semibold">Select Subcontractor</label>
<select name="subcontractor_id" class="form-select" required>
<option value="">--- Select Contractor ---</option>
<option value="">-- Select Subcontractor --</option>
{% for sc in subcontractors %}
<option value="{{ sc.id }}"
{% if selected_sc_id|string == sc.id|string %}selected{% endif %}>
<option value="{{ sc.id }}" {% if selected_sc_id==sc.id|string %}selected{% endif %}>
{{ sc.subcontractor_name }}
</option>
{% endfor %}
</select>
</div>
<div class="col-lg-3">
<label class="form-label fw-semibold"> RA Bill No</label>
<input
type="text"
name="ra_bill_no"
class="form-control"
placeholder="Enter RA Bill"
value="{{ selected_ra_bill or '' }}">
<div class="form-check form-switch mb-3">
<input class="form-check-input" type="checkbox" id="downloadAllSwitch" name="download_all" value="true"
{% if download_all %}checked{% endif %}>
<label class="form-check-label fw-bold text-primary">
Download All RA Bills
</label>
</div>
<div class="col-lg-3">
<label class="form-label fw-semibold"> Location </label>
<input
type="text"
name="location"
class="form-control"
placeholder="Project Location"
value="{{ selected_location or '' }}">
<div class="mb-4" id="ra_bill_container">
<label class="form-label fw-semibold">RA Bill Number</label>
<input type="text" name="ra_bill_no" id="ra_bill_input" class="form-control"
value="{{ ra_bill_no or '' }}">
</div>
<div class="col-lg-3">
<label class="form-label fw-semibold">Work Category</label>
<select name="category" class="form-select">
<option value="all">All Categories</option>
<option value="tr"
{% if request.form.get('category')=='tr' %}selected{% endif %}>
Trench Excavation
</option>
<option value="mh"
{% if request.form.get('category')=='mh' %}selected{% endif %}>
Manhole Excavation
</option>
<option value="dc"
{% if request.form.get('category')=='dc' %}selected{% endif %}>
Manhole Domestic Chamber
</option>
<option value="laying"
{% if request.form.get('category')=='laying' %}selected{% endif %}>
Pipe Laying
</option>
</select>
</div>
</div>
<div class="mt-4 d-flex justify-content-end gap-2">
<!-- Preview -->
<button type="submit" name="action" value="preview"class="btn btn-primary">
<i class="bi bi-search"></i>
Preview Report
<div class="row g-2">
<div class="col-12 col-md-6">
<button class="btn btn-outline-primary w-100" name="action" value="preview">
Preview Data
</button>
<!-- Download -->
<div class="btn-group">
<button type="button" class="btn btn-success dropdown-toggle"data-bs-toggle="dropdown">
<i class="bi bi-download"></i>
Download Report
</button>
<ul class="dropdown-menu dropdown-menu-end">
<li>
<button class="dropdown-item"type="submit" name="action" value="excel">
<i class="bi bi-file-earmark-excel text-success"></i>
</div>
<div class="col-12 col-md-6">
<button class="btn btn-primary w-100" name="action" value="download">
Download Excel
</button>
</li>
<li>
<button class="dropdown-item" type="submit" name="action"
value="excel_all">
<i class="bi bi-file-earmark-spreadsheet text-primary"></i>
Download All Excel
</button>
</li>
<li><hr class="dropdown-divider"></li>
<li>
<button class="dropdown-item"type="submit"name="action" value="pdf">
<i class="bi bi-file-earmark-pdf text-danger"></i>
PDF (Coming Soon)
</button>
</li>
</ul>
</div>
</div>
<button type="reset" class="btn btn-secondary" id="resetBtn">
<i class="bi bi-arrow-clockwise"></i>
Reset
</button>
</div>
</form>
</div>
</div>
{% if tables %}
<!-- Tabs -->
<div class="card shadow-sm border-0 mt-4">
<div class="card-header bg-light">
<ul class="nav nav-pills">
<!-- REPORT PREVIEW -->
<div class="mt-5">
<h3 class="text-center mb-3">Report Preview</h3>
<div class="card shadow-sm">
<!-- MOBILE SCROLLABLE TABS -->
<div class="card-header p-0">
<ul class="nav nav-tabs flex-nowrap overflow-auto">
<li class="nav-item">
<button class="nav-link active" data-bs-toggle="tab" data-bs-target="#abstract">
<i class="bi bi-file-earmark-text"></i> Abstract
<button class="nav-link active" data-bs-toggle="tab" data-bs-target="#tr">
Trench Excavation
</button>
</li>
<li class="nav-item">
<button class="nav-link " data-bs-toggle="tab" data-bs-target="#tr">
<i class="bi bi-cone-striped"></i> Trench Excavation
</button>
</li>
<li class="nav-item">
<button class="nav-link" data-bs-toggle="tab" data-bs-target="#mh">
<i class="bi bi-nut"></i> Manhole Excavation
Manhole Excavation
</button>
</li>
<li class="nav-item">
<button class="nav-link" data-bs-toggle="tab" data-bs-target="#dc">
<i class="bi bi-grid-3x3"></i> Manhole & Domestic Chambers Construction
Manhole & Domestic Chambers
</button>
</li>
<li class="nav-item">
<button class="nav-link" data-bs-toggle="tab" data-bs-target="#laying">
<i class="bi bi-bezier2"></i> Pipe Laying
Pipe Laying
</button>
</li>
</ul>
</div>
<div class="card-body">
<div class="tab-content">
<!-- TAB CONTENT -->
<div class="card-body tab-content">
<div class="tab-pane fade show active" id="abstract">
{{ abstract_html|safe }}
</div>
<!-- Trench -->
<div class="tab-pane fade "id="tr">
<div class="mb-3">
<button onclick="deleteSelected('tr')" class="btn btn-danger">
<i class="bi bi-trash"></i> Delete Selected
</button>
</div>
<div class="table-responsive border rounded shadow-sm">
{{ tables.tr|safe }}
<div class="tab-pane fade show active" id="tr">
<div class="table-responsive overflow-auto">
{{ tables.tr | safe }}
</div>
</div>
<!-- MH -->
<div class="tab-pane fade" id="mh">
<div class="mb-3">
<button onclick="deleteSelected('mh')" class="btn btn-danger">
<i class="bi bi-trash"></i>Delete Selected
</button>
</div>
<div class="table-responsive border rounded shadow-sm">
{{ tables.mh|safe }}
<div class="table-responsive overflow-auto">
{{ tables.mh | safe }}
</div>
</div>
<!-- DC -->
<div class="tab-pane fade" id="dc">
<div class="mb-3">
<button onclick="deleteSelected('dc')"class="btn btn-danger">
<i class="bi bi-trash"></i>
Delete Selected
</button>
</div>
<div class="table-responsive border rounded shadow-sm">
{{ tables.dc|safe }}
<div class="table-responsive overflow-auto">
{{ tables.dc | safe }}
</div>
</div>
<!-- Laying -->
<div class="tab-pane fade" id="laying">
<div class="mb-3">
<button onclick="deleteSelected('laying')"
class="btn btn-danger">
<i class="bi bi-trash"></i>
Delete Selected
</button>
</div>
<div class="table-responsive border rounded shadow-sm">
{{ tables.laying|safe }}
<div class="table-responsive overflow-auto">
{{ tables.laying | safe }}
</div>
</div>
</div>
</div>
</div>
@@ -255,90 +119,24 @@
</div>
<!-- BOOTSTRAP-ONLY JS -->
<script>
// Reset
document.getElementById("resetBtn").addEventListener("click", function () {location.reload();});
function toggleRAInput() {
const checkbox = document.getElementById("downloadAllSwitch");
const input = document.getElementById("ra_bill_input");
const container = document.getElementById("ra_bill_container");
// DATATABLE
$(document).ready(function () {
$('.datatable').DataTable({
pageLength: 10,
dom: 'Bfrtip',
buttons: ['copy', 'csv', 'excel', 'print']
});
setTimeout(() => {
$("table thead tr th:first-child").html('<input type="checkbox" id="select-all">');
}, 500);
});
// SELECT ALL
$(document).on("change", "#select-all", function () {
$(".row-check").prop("checked", this.checked);
});
// GET IDS
function getSelectedIds() {
let ids = [];
$(".row-check:checked").each(function () {
ids.push($(this).data("id"));
});
return ids;
}
// BULK DELETE
function deleteSelected(model) {
let ids = getSelectedIds();
if (ids.length === 0) return alert("Select records");
if (!confirm(`Delete ${ids.length} record(s)?`)) return;
fetch("/file/delete_records", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ model: model, ids: ids })
})
.then(res => res.json().then(data => ({ ok: res.ok, data })))
.then(({ ok, data }) => {
if (ok && data.status === "success") {
alert("Deleted Successfully");
location.reload();
if (checkbox.checked) {
input.value = "";
input.disabled = true;
container.classList.add("opacity-50");
} else {
alert("Delete failed: " + (data.message || "Unknown error"));
input.disabled = false;
container.classList.remove("opacity-50");
}
})
.catch(err => {
alert("Delete request failed: " + err);
});
}
// SINGLE DELETE
$(document).on("click", ".delete-btn", function () {
let id = $(this).data("id");
let model = $(this).data("model");
if (!confirm("Are you sure you want to delete this record?")) return;
fetch("/file/delete_records", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ model: model, ids: [id] })
})
.then(res => res.json().then(data => ({ ok: res.ok, data })))
.then(({ ok, data }) => {
if (ok && data.status === "success") {
alert("Deleted Successfully");
location.reload();
} else {
alert("Delete failed: " + (data.message || "Unknown error"));
}
})
.catch(err => {
alert("Delete request failed: " + err);
});
});
document.addEventListener("DOMContentLoaded", toggleRAInput);
document.getElementById("downloadAllSwitch").addEventListener("change", toggleRAInput);
</script>
{% endblock %}

0
app/templates/user/users.html → app/templates/users.htm
View File

8
app/utils/exceptions.py
View File

@@ -1,8 +0,0 @@
from app.constants.http_status import HTTPStatus
class APIException(Exception):
def __init__(self, message, status_code=HTTPStatus.BAD_REQUEST, errors=None):
self.message = message
self.status_code = status_code
self.errors = errors
super().__init__(self.message)

40
app/utils/file_utils.py
View File

@@ -1,40 +1,6 @@
import os
from flask import current_app
# file extension
ALLOWED_EXTENSIONS = {"xlsx", "xls", "csv"}
# .log file allowed
ALLOWED_LOG_FILE = {
"app.log",
"debug.log",
"error.log"
}
# Get path of format excel folder
def get_download_format_folder():
return os.path.join(
current_app.root_path,
"static",
"downloads",
"format"
)
# Get path of uploads folder
def get_uploads_folder():
return os.path.join(
current_app.root_path,
"static",
"uploads"
)
from app.config import Config
def ensure_upload_folder():
if not os.path.exists(get_uploads_folder()):
os.makedirs(get_uploads_folder())
# Get path of logs folder
def get_logs_folder():
project_root = os.path.dirname(current_app.root_path)
return os.path.join(project_root, "logs")
if not os.path.exists(Config.UPLOAD_FOLDER):
os.makedirs(Config.UPLOAD_FOLDER)

12
app/utils/regex_utils.py
View File

@@ -1,12 +0,0 @@
import re
class RegularExpression:
# sum fields of TrEx, MhEx (_total)
STR_TOTAL_PATTERN = re.compile(r".*_total$")
# sum fields of pipe laying (pipe_150_mm)
PIPE_MM_PATTERN = re.compile(r"^pipe_\d+_mm$")
# sum fields of MH dc (d_0_to_0_75)
D_RANGE_PATTERN = re.compile( r"^d_\d+(?:_\d+)?_to_\d+(?:_\d+)?$")

23
app/utils/response_handler.py
View File

@@ -1,23 +0,0 @@
from flask import jsonify
from app.constants.http_status import HTTPStatus
class ResponseHandler:
@staticmethod
def success(message, data=None, status_code=HTTPStatus.OK):
return jsonify({
"status": "success",
"message": message,
"data": data if data else {},
"errors": []
}), status_code
@staticmethod
def error(message, errors=None, status_code=HTTPStatus.BAD_REQUEST):
return jsonify({
"status": "error",
"message": message,
"data": {},
"errors": errors if errors else []
}), status_code

10
docker-compose.yml
View File

@@ -6,7 +6,7 @@ services:
container_name: comparison_db
restart: always
environment:
MYSQL_ROOT_PASSWORD: root
MYSQL_ROOT_PASSWORD: admin
MYSQL_DATABASE: comparisondb
ports:
- "3307:3306"
@@ -17,11 +17,9 @@ services:
build: .
container_name: comparison_app
restart: always
env_file:
- .env
environment:
FLASK_ENV: production
FLASK_DEBUG: "False"
FLASK_ENV: development
FLASK_DEBUG: "True"
FLASK_HOST: "0.0.0.0"
FLASK_PORT: "5001"
@@ -31,7 +29,7 @@ services:
DB_PORT: 3306
DB_NAME: comparisondb
DB_USER: root
DB_PASSWORD: root
DB_PASSWORD: admin
ports:
- "5001:5001"

BIN
instance/comparisondb.db Normal file
View File

Binary file not shown.

3218
logs/app.log
View File

File diff suppressed because it is too large Load Diff

1
requirements.txt
View File

@@ -1,5 +1,4 @@
Flask
ldap3
pandas
openpyxl
xlrd

4
run.py
View File

@@ -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")),

68
test_ra_bills.py Normal file
View File

@@ -0,0 +1,68 @@
#!/usr/bin/env python3
"""
Test script to verify RA bill fetching from both client and subcontractor tables
"""
import sys
import os
sys.path.insert(0, os.path.dirname(__file__))
from app import create_app, db
from app.models.trench_excavation_model import TrenchExcavation
from app.models.tr_ex_client_model import TrenchExcavationClient
app = create_app()
with app.app_context():
print("=" * 70)
print("RA BILL FETCHING TEST")
print("=" * 70)
# Test 1: Count total records
print("\n✓ TEST 1: Total Records in Both Tables")
subcon_count = db.session.query(TrenchExcavation).count()
client_count = db.session.query(TrenchExcavationClient).count()
print(f" Subcontractor (TrenchExcavation): {subcon_count} records")
print(f" Client (TrenchExcavationClient): {client_count} records")
# Test 2: Check RA bills in Subcontractor table
print("\n✓ TEST 2: RA Bills in Subcontractor Table")
subcon_bills = db.session.query(TrenchExcavation.RA_Bill_No)\
.filter(TrenchExcavation.RA_Bill_No != None)\
.filter(TrenchExcavation.RA_Bill_No != "")\
.distinct().all()
print(f" Distinct RA Bills found: {len(subcon_bills)}")
print(f" Bills: {[str(r[0]) for r in subcon_bills]}")
# Test 3: Check RA bills in Client table
print("\n✓ TEST 3: RA Bills in Client Table")
client_bills = db.session.query(TrenchExcavationClient.RA_Bill_No)\
.filter(TrenchExcavationClient.RA_Bill_No != None)\
.filter(TrenchExcavationClient.RA_Bill_No != "")\
.distinct().all()
print(f" Distinct RA Bills found: {len(client_bills)}")
print(f" Bills: {[str(r[0]) for r in client_bills]}")
# Test 4: Combined unique RA bills
print("\n✓ TEST 4: Combined Unique RA Bills (Union)")
combined_bills = db.session.query(TrenchExcavation.RA_Bill_No)\
.filter(TrenchExcavation.RA_Bill_No != None)\
.filter(TrenchExcavation.RA_Bill_No != "")\
.union(
db.session.query(TrenchExcavationClient.RA_Bill_No)\
.filter(TrenchExcavationClient.RA_Bill_No != None)\
.filter(TrenchExcavationClient.RA_Bill_No != "")
).order_by(TrenchExcavation.RA_Bill_No).all()
print(f" Total unique RA Bills: {len(combined_bills)}")
print(f" Bills: {[str(r[0]) for r in combined_bills]}")
# Test 5: Sample data from both tables
print("\n✓ TEST 5: Sample RA Bills from Tables")
sample_subcon = db.session.query(TrenchExcavation.RA_Bill_No).limit(5).all()
sample_client = db.session.query(TrenchExcavationClient.RA_Bill_No).limit(5).all()
print(f" Subcontractor samples: {[str(r[0]) for r in sample_subcon]}")
print(f" Client samples: {[str(r[0]) for r in sample_client]}")
print("\n" + "=" * 70)
print("✅ TEST COMPLETE")
print("=" * 70)