Resolved merge conflicts

Reviewed-on: #10

.gitignore

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

app/config.py

@@ -1,4 +1,6 @@
 import os
+# project base url
+BASE_DIR = os.path.abspath(os.path.dirname(__file__))
 
 class Config:
     # secret key
@@ -21,4 +23,7 @@ class Config:
     )
 
     SQLALCHEMY_TRACK_MODIFICATIONS = False
-   
+    # uploads folder path
+    UPLOAD_FOLDER = os.path.join(BASE_DIR, "static", "uploads")
+    # file extension
+    ALLOWED_EXTENSIONS = {"xlsx", "xls", "csv"}

app/models/laying_client_model.py

@@ -1,7 +1,9 @@
 from app import db
 from datetime import datetime
 from sqlalchemy import event
-from app.utils.regex_utils import RegularExpression
+import re
+# REGEX PATTERN
+PIPE_MM_PATTERN = re.compile(r"^pipe_\d+_mm$")
 
 class LayingClient(db.Model):
     __tablename__ = "laying_client"
@@ -11,33 +13,33 @@ class LayingClient(db.Model):
     # Basic Fields
     Location = db.Column(db.String(500))
     MH_NO = db.Column(db.String(100))
-    CC_length = db.Column(db.Numeric(10, 4), default=0)
+    CC_length = db.Column(db.Float)
     # Bedding Qty.
-    Outer_dia_of_MH_m = db.Column(db.Numeric(10, 4), default=0)
+    Outer_dia_of_MH_m = db.Column(db.Float)
-    Bedding_Length = db.Column(db.Numeric(10, 4), default=0)
+    Bedding_Length = db.Column(db.Float)
-    Width = db.Column(db.Numeric(10, 4), default=0)
+    Width = db.Column(db.Float)
-    Depth = db.Column(db.Numeric(10, 4), default=0)
+    Depth = db.Column(db.Float)
-    Qty = db.Column(db.Numeric(10, 4), default=0)
+    Qty = db.Column(db.Float)
  
     #  PIPE LAYING Qty. 
-    Pipe_Dia_mm = db.Column(db.Numeric(10, 4), default=0)
+    Pipe_Dia_mm = db.Column(db.Float)
-    ID_of_MH_m = db.Column(db.Numeric(10, 4), default=0)
+    ID_of_MH_m = db.Column(db.Float)
-    Laying_Length = db.Column(db.Numeric(10, 4), default=0)
+    Laying_Length = db.Column(db.Float)
 
-    pipe_150_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_150_mm = db.Column(db.Float)
-    pipe_200_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_200_mm = db.Column(db.Float)
-    pipe_250_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_250_mm = db.Column(db.Float)
-    pipe_300_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_300_mm = db.Column(db.Float)
-    pipe_350_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_350_mm = db.Column(db.Float)
-    pipe_400_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_400_mm = db.Column(db.Float)
-    pipe_450_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_450_mm = db.Column(db.Float)
-    pipe_500_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_500_mm = db.Column(db.Float)
-    pipe_600_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_600_mm = db.Column(db.Float)
-    pipe_700_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_700_mm = db.Column(db.Float)
-    pipe_900_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_900_mm = db.Column(db.Float)
-    pipe_1200_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_1200_mm = db.Column(db.Float)
     
-    Total = db.Column(db.Numeric(12, 4), default=0)
+    Total = db.Column(db.Float)
     Remarks = db.Column(db.String(500))
     RA_Bill_No=db.Column(db.String(500))
     
@@ -50,14 +52,26 @@ class LayingClient(db.Model):
     def serialize(self):
         return {c.name: getattr(self, c.name) for c in self.__table__.columns}
 
-
+    
+    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"
+        ]
+    
+# ===============================
 # AUTO TOTAL USING REGEX
+# ===============================
 def calculate_laying_total(mapper, connection, target):
     total = 0
+
     for column in target.__table__.columns:
-        if RegularExpression.PIPE_MM_PATTERN.match(column.name):
+        if PIPE_MM_PATTERN.match(column.name):
             total += getattr(target, column.name) or 0
-    target.Total = round(total)
+
+    target.Total = total
 
 event.listen(LayingClient, "before_insert", calculate_laying_total)
 event.listen(LayingClient, "before_update", calculate_laying_total)

app/models/laying_model.py

@@ -1,7 +1,9 @@
 from app import db
 from datetime import datetime
 from sqlalchemy import event
-from app.utils.regex_utils import RegularExpression
+import re
+# REGEX PATTERN
+PIPE_MM_PATTERN = re.compile(r"^pipe_\d+_mm$")
 
 class Laying(db.Model):
     __tablename__ = "laying"
@@ -15,25 +17,25 @@ class Laying(db.Model):
     # Pipe Laying Fields
     Location = db.Column(db.String(500))
     MH_NO = db.Column(db.String(100))
-    CC_length = db.Column(db.Numeric(10, 4), default=0)
+    CC_length = db.Column(db.Float)
-    Pipe_Dia_mm = db.Column(db.Numeric(10, 4), default=0)
+    Pipe_Dia_mm = db.Column(db.Float)
-    ID_of_MH_m = db.Column(db.Numeric(10, 4), default=0)
+    ID_of_MH_m = db.Column(db.Float)
-    Laying_Length = db.Column(db.Numeric(10, 4), default=0)
+    Laying_Length = db.Column(db.Float)
 
-    pipe_150_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_150_mm = db.Column(db.Float)
-    pipe_200_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_200_mm = db.Column(db.Float)
-    pipe_250_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_250_mm = db.Column(db.Float)
-    pipe_300_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_300_mm = db.Column(db.Float)
-    pipe_350_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_350_mm = db.Column(db.Float)
-    pipe_400_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_400_mm = db.Column(db.Float)
-    pipe_450_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_450_mm = db.Column(db.Float)
-    pipe_500_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_500_mm = db.Column(db.Float)
-    pipe_600_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_600_mm = db.Column(db.Float)
-    pipe_700_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_700_mm = db.Column(db.Float)
-    pipe_900_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_900_mm = db.Column(db.Float)
-    pipe_1200_mm = db.Column(db.Numeric(10, 4), default=0)
+    pipe_1200_mm = db.Column(db.Float)
     
-    Total = db.Column(db.Numeric(12, 4), default=0)
+    Total = db.Column(db.Float)
     Remarks = db.Column(db.String(500))
     RA_Bill_No=db.Column(db.String(500))
     
@@ -47,13 +49,25 @@ class Laying(db.Model):
         return {c.name: getattr(self, c.name) for c in self.__table__.columns}
     
 
+    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"
+        ]
+
+# ===============================
 # AUTO TOTAL USING REGEX
+# ===============================
 def calculate_laying_total(mapper, connection, target):
     total = 0
+
     for column in target.__table__.columns:
-        if RegularExpression.PIPE_MM_PATTERN.match(column.name):
+        if PIPE_MM_PATTERN.match(column.name):
             total += getattr(target, column.name) or 0
-    target.Total = round(total)
+
+    target.Total = total
 
 event.listen(Laying, "before_insert", calculate_laying_total)
 event.listen(Laying, "before_update", calculate_laying_total)

app/models/manhole_domestic_chamber_model.py

@@ -1,7 +1,10 @@
 from app import db
 from datetime import datetime
 from sqlalchemy import event
-from app.utils.regex_utils import RegularExpression
+import re
+
+# REGEX PATTERN
+D_RANGE_PATTERN = re.compile(r"^d_\d+(?:_\d+)?_to_\d+(?:_\d+)?$")
 
 class ManholeDomesticChamber(db.Model):
     __tablename__ = "manhole_domestic_chamber"
@@ -15,35 +18,35 @@ class ManholeDomesticChamber(db.Model):
     # Basic Fields
     Location = db.Column(db.String(500))
     MH_NO = db.Column(db.String(100))
-    Depth_of_MH = db.Column(db.Numeric(10, 4), default=0)
+    Depth_of_MH = db.Column(db.Float)
  
     # Excavation categories 
-    d_0_to_0_75 = db.Column(db.Numeric(10, 4), default=0)
+    d_0_to_0_75 = db.Column(db.Float)
-    d_0_76_to_1_05 = db.Column(db.Numeric(10, 4), default=0)
+    d_0_76_to_1_05 = db.Column(db.Float)
-    d_1_06_to_1_65 = db.Column(db.Numeric(10, 4), default=0)
+    d_1_06_to_1_65 = db.Column(db.Float)
-    d_1_66_to_2_15 = db.Column(db.Numeric(10, 4), default=0)
+    d_1_66_to_2_15 = db.Column(db.Float)
-    d_2_16_to_2_65 = db.Column(db.Numeric(10, 4), default=0)
+    d_2_16_to_2_65 = db.Column(db.Float)
-    d_2_66_to_3_15 = db.Column(db.Numeric(10, 4), default=0)
+    d_2_66_to_3_15 = db.Column(db.Float)
-    d_3_16_to_3_65= db.Column(db.Numeric(10, 4), default=0)
+    d_3_16_to_3_65= db.Column(db.Float)
-    d_3_66_to_4_15 = db.Column(db.Numeric(10, 4), default=0)
+    d_3_66_to_4_15 = db.Column(db.Float)
-    d_4_16_to_4_65 = db.Column(db.Numeric(10, 4), default=0)
+    d_4_16_to_4_65 = db.Column(db.Float)
-    d_4_66_to_5_15 = db.Column(db.Numeric(10, 4), default=0)
+    d_4_66_to_5_15 = db.Column(db.Float)
-    d_5_16_to_5_65 = db.Column(db.Numeric(10, 4), default=0)
+    d_5_16_to_5_65 = db.Column(db.Float)
-    d_5_66_to_6_15 = db.Column(db.Numeric(10, 4), default=0)
+    d_5_66_to_6_15 = db.Column(db.Float)
-    d_6_16_to_6_65 = db.Column(db.Numeric(10, 4), default=0)
+    d_6_16_to_6_65 = db.Column(db.Float)
-    d_6_66_to_7_15 = db.Column(db.Numeric(10, 4), default=0)
+    d_6_66_to_7_15 = db.Column(db.Float)
-    d_7_16_to_7_65 = db.Column(db.Numeric(10, 4), default=0)
+    d_7_16_to_7_65 = db.Column(db.Float)
-    d_7_66_to_8_15 = db.Column(db.Numeric(10, 4), default=0)
+    d_7_66_to_8_15 = db.Column(db.Float)
-    d_8_16_to_8_65 = db.Column(db.Numeric(10, 4), default=0)
+    d_8_16_to_8_65 = db.Column(db.Float)
-    d_8_66_to_9_15 = db.Column(db.Numeric(10, 4), default=0)
+    d_8_66_to_9_15 = db.Column(db.Float)
-    d_9_16_to_9_65 = db.Column(db.Numeric(10, 4), default=0)
+    d_9_16_to_9_65 = db.Column(db.Float)
 
-    Domestic_Chambers = db.Column(db.Numeric(10, 4), default=0)
+    Domestic_Chambers = db.Column(db.Float)
-    DWC_Pipe_Length = db.Column(db.Numeric(10, 4), default=0)
+    DWC_Pipe_Length = db.Column(db.Float)
-    UPVC_Pipe_Length = db.Column(db.Numeric(10, 4), default=0)
+    UPVC_Pipe_Length = db.Column(db.Float)
     RA_Bill_No=db.Column(db.String(500))
 
-    Total = db.Column(db.Numeric(12, 4), default=0)
+    Total = db.Column(db.Float)
     created_at = db.Column(db.DateTime, default=datetime.today)
 
     def __repr__(self):
@@ -53,13 +56,28 @@ class ManholeDomesticChamber(db.Model):
         return {c.name: getattr(self, c.name) for c in self.__table__.columns}
     
     
+    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"]
+
+# ===============================
 # AUTO TOTAL USING REGEX
+# ===============================
 def calculate_mh_dc_total(mapper, connection, target):
     total = 0
+
     for column in target.__table__.columns:
-        if RegularExpression.D_RANGE_PATTERN.match(column.name):
+        if D_RANGE_PATTERN.match(column.name):
             total += getattr(target, column.name) or 0
-    target.Total = round(total)
+
+    target.Total = total
+
 
 event.listen(ManholeDomesticChamber, "before_insert", calculate_mh_dc_total)
 event.listen(ManholeDomesticChamber, "before_update", calculate_mh_dc_total)

app/models/manhole_excavation_model.py

@@ -1,7 +1,6 @@
 from app import db
 from datetime import datetime
 from sqlalchemy import event
-from app.utils.regex_utils import RegularExpression
 
 class ManholeExcavation(db.Model):
     __tablename__ = "manhole_excavation"
@@ -16,47 +15,47 @@ class ManholeExcavation(db.Model):
     Location = db.Column(db.String(500))
     MH_NO = db.Column(db.String(100))
    
-    Upto_IL_Depth = db.Column(db.Numeric(10, 4), default=0)
+    Upto_IL_Depth = db.Column(db.Float)
-    Cutting_Depth = db.Column(db.Numeric(10, 4), default=0)
+    Cutting_Depth = db.Column(db.Float)
-    ID_of_MH_m = db.Column(db.Numeric(10, 4), default=0)
+    ID_of_MH_m = db.Column(db.Float)
-    Ex_Dia_of_Manhole = db.Column(db.Numeric(10, 4), default=0)
+    Ex_Dia_of_Manhole = db.Column(db.Float)
-    Area_of_Manhole = db.Column(db.Numeric(10, 4), default=0)
+    Area_of_Manhole = db.Column(db.Float)
    
     # Excavation categories
-    Soft_Murum_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_0_to_1_5 = db.Column(db.Float)
-    Soft_Murum_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_1_5_to_3_0 = db.Column(db.Float)
-    Soft_Murum_3_0_to_4_5 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_3_0_to_4_5 = db.Column(db.Float)
 
-    Hard_Murum_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_0_to_1_5 = db.Column(db.Float)
-    Hard_Murum_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_1_5_to_3_0 = db.Column(db.Float)
 
-    Soft_Rock_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_0_to_1_5 = db.Column(db.Float)
-    Soft_Rock_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_1_5_to_3_0 = db.Column(db.Float)
 
-    Hard_Rock_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_0_to_1_5 = db.Column(db.Float)
-    Hard_Rock_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_1_5_to_3_0 = db.Column(db.Float)
-    Hard_Rock_3_0_to_4_5 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_3_0_to_4_5 = db.Column(db.Float)
-    Hard_Rock_4_5_to_6_0 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_4_5_to_6_0 = db.Column(db.Float)
-    Hard_Rock_6_0_to_7_5 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_6_0_to_7_5 = db.Column(db.Float)
 
     # Totals
-    Soft_Murum_0_to_1_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_0_to_1_5_total = db.Column(db.Float)
-    Soft_Murum_1_5_to_3_0_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_1_5_to_3_0_total = db.Column(db.Float)
-    Soft_Murum_3_0_to_4_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_3_0_to_4_5_total = db.Column(db.Float)
 
-    Hard_Murum_0_to_1_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_0_to_1_5_total = db.Column(db.Float)
-    Hard_Murum_1_5_and_above_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_1_5_and_above_total = db.Column(db.Float)
 
-    Soft_Rock_0_to_1_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_0_to_1_5_total = db.Column(db.Float)
-    Soft_Rock_1_5_and_above_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_1_5_and_above_total = db.Column(db.Float)
 
-    Hard_Rock_0_to_1_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_0_to_1_5_total = db.Column(db.Float)
-    Hard_Rock_1_5_to_3_0_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_1_5_to_3_0_total = db.Column(db.Float)
-    Hard_Rock_3_0_to_4_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_3_0_to_4_5_total = db.Column(db.Float)
-    Hard_Rock_4_5_to_6_0_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_4_5_to_6_0_total = db.Column(db.Float)
-    Hard_Rock_6_0_to_7_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_6_0_to_7_5_total = db.Column(db.Float)
 
-    Total = db.Column(db.Numeric(12, 4), default=0)
+    Total = db.Column(db.Float)
     Remarks = db.Column(db.String(500))
     RA_Bill_No=db.Column(db.String(500))
 
@@ -68,13 +67,15 @@ class ManholeExcavation(db.Model):
     def serialize(self):
         return {c.name: getattr(self, c.name) for c in self.__table__.columns}
 
-# AUTO TOTAL USING REGEX
+# ==========================================
+# AUTO CALCULATE GRAND TOTAL
+# ==========================================
 def calculate_Manhole_total(mapper, connection, target):
     total = 0
     for column in target.__table__.columns:
-        if RegularExpression.STR_TOTAL_PATTERN.match(column.name):
+        if column.name.endswith("_total"):
             total += getattr(target, column.name) or 0
-    target.Total = round(total)
+    target.Total = total
 
 
 event.listen(ManholeExcavation, "before_insert", calculate_Manhole_total)

app/models/mh_dc_client_model.py

@@ -1,37 +1,45 @@
 from app import db
 from datetime import datetime
 from sqlalchemy import event
-from app.utils.regex_utils import RegularExpression
+import re
+
+# REGEX PATTERN
+D_RANGE_PATTERN = re.compile(r"^d_\d+(?:_\d+)?_to_\d+(?:_\d+)?$")
 
 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))
     Location = db.Column(db.String(500))
     MH_NO = db.Column(db.String(100))
-    MH_TOP_LEVEL = db.Column(db.Numeric(10, 4), default=0)
+    MH_TOP_LEVEL = db.Column(db.Float)
-    MH_IL_LEVEL = db.Column(db.Numeric(10, 4), default=0)
+    MH_IL_LEVEL = db.Column(db.Float)
-    Depth_of_MH = db.Column(db.Numeric(10, 4), default=0)
+    Depth_of_MH = db.Column(db.Float)
    
+ 
     # Excavation categories 
-    d_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    d_0_to_1_5 = db.Column(db.Float)
-    d_1_5_to_2_0 = db.Column(db.Numeric(10, 4), default=0)
+    d_1_5_to_2_0 = db.Column(db.Float)
-    d_2_0_to_2_5 = db.Column(db.Numeric(10, 4), default=0)
+    d_2_0_to_2_5 = db.Column(db.Float)
-    d_2_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    d_2_5_to_3_0 = db.Column(db.Float)
-    d_3_0_to_3_5 = db.Column(db.Numeric(10, 4), default=0)
+    d_3_0_to_3_5 = db.Column(db.Float)
-    d_3_5_to_4_0 = db.Column(db.Numeric(10, 4), default=0)
+    d_3_5_to_4_0 = db.Column(db.Float)
-    d_4_0_to_4_5= db.Column(db.Numeric(10, 4), default=0)
+    d_4_0_to_4_5= db.Column(db.Float)
-    d_4_5_to_5_0 = db.Column(db.Numeric(10, 4), default=0)
+    d_4_5_to_5_0 = db.Column(db.Float)
-    d_5_0_to_5_5 = db.Column(db.Numeric(10, 4), default=0)
+    d_5_0_to_5_5 = db.Column(db.Float)
-    d_5_5_to_6_0 = db.Column(db.Numeric(10, 4), default=0)
+    d_5_5_to_6_0 = db.Column(db.Float)
-    d_6_0_to_6_5 = db.Column(db.Numeric(10, 4), default=0)
+    d_6_0_to_6_5 = db.Column(db.Float)
 
-    Domestic_Chambers = db.Column(db.Numeric(10, 4), default=0)
+    Domestic_Chambers = db.Column(db.Float)
 
-    Total = db.Column(db.Numeric(12, 4), default=0)
+    Total = db.Column(db.Float)
     created_at = db.Column(db.DateTime, default=datetime.today)
 
     def __repr__(self):
@@ -41,14 +49,28 @@ class ManholeDomesticChamberClient(db.Model):
     def serialize(self):
         return {c.name: getattr(self, c.name) for c in self.__table__.columns}
 
-
+    
+    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" ]
+    
+# ===============================
 # AUTO TOTAL USING REGEX
+# ===============================
 def calculate_mh_dc_total(mapper, connection, target):
     total = 0
+
     for column in target.__table__.columns:
-        if RegularExpression.D_RANGE_PATTERN.match(column.name):
+        if D_RANGE_PATTERN.match(column.name):
             total += getattr(target, column.name) or 0
-    target.Total = round(total)
+
+    target.Total = total
 
 
 event.listen(ManholeDomesticChamberClient, "before_insert", calculate_mh_dc_total)

app/models/mh_ex_client_model.py

@@ -1,76 +1,79 @@
 from app import db
 from datetime import datetime
 from sqlalchemy import event
-from app.utils.regex_utils import RegularExpression
 
 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))
     Location = db.Column(db.String(500))
     MH_NO = db.Column(db.String(100))
-    Ground_Level = db.Column(db.Numeric(10, 4), default=0)
+    Ground_Level = db.Column(db.Float)
-    MH_Invert_Level = db.Column(db.Numeric(10, 4), default=0)
+    MH_Invert_Level = db.Column(db.Float)
-    MH_Top_Level = db.Column(db.Numeric(10, 4), default=0)
+    MH_Top_Level = db.Column(db.Float)
-    Ex_Level = db.Column(db.Numeric(10, 4), default=0)
+    Ex_Level = db.Column(db.Float)
-    Cutting_Depth = db.Column(db.Numeric(10, 4), default=0)
+    Cutting_Depth = db.Column(db.Float)
-    MH_Depth = db.Column(db.Numeric(10, 4), default=0)
+    MH_Depth = db.Column(db.Float)
-    ID_of_MH_m = db.Column(db.Numeric(10, 4), default=0)
+    ID_of_MH_m = db.Column(db.Float)
 
-    Dia_of_MH_Cutting = db.Column(db.Numeric(10, 4), default=0)
+    Dia_of_MH_Cutting = db.Column(db.Float)
-    Area_of_Manhole = db.Column(db.Numeric(10, 4), default=0)
+    Area_of_Manhole = db.Column(db.Float)
    
     # Excavation categories
-    Marshi_Muddy_Slushy_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Marshi_Muddy_Slushy_0_to_1_5 = db.Column(db.Float)
-    Marshi_Muddy_Slushy_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Marshi_Muddy_Slushy_1_5_to_3_0 = db.Column(db.Float)
-    Marshi_Muddy_Slushy_3_0_to_4_5 = db.Column(db.Numeric(10, 4), default=0)
+    Marshi_Muddy_Slushy_3_0_to_4_5 = db.Column(db.Float)
 
-    Soft_Murum_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_0_to_1_5 = db.Column(db.Float)
-    Soft_Murum_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_1_5_to_3_0 = db.Column(db.Float)
-    Soft_Murum_3_0_to_4_5 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_3_0_to_4_5 = db.Column(db.Float)
 
-    Hard_Murum_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_0_to_1_5 = db.Column(db.Float)
-    Hard_Murum_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_1_5_to_3_0 = db.Column(db.Float)
-    Hard_Murum_3_0_to_4_5 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_3_0_to_4_5 = db.Column(db.Float)
 
-    Soft_Rock_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_0_to_1_5 = db.Column(db.Float)
-    Soft_Rock_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_1_5_to_3_0 = db.Column(db.Float)
-    Soft_Murum_3_0_to_4_5 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_3_0_to_4_5 = db.Column(db.Float)
 
-    Hard_Rock_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_0_to_1_5 = db.Column(db.Float)
-    Hard_Rock_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_1_5_to_3_0 = db.Column(db.Float)
-    Hard_Rock_3_0_to_4_5 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_3_0_to_4_5 = db.Column(db.Float)
-    Hard_Rock_4_5_to_6_0 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_4_5_to_6_0 = db.Column(db.Float)
-    Hard_Rock_6_0_to_7_5 = db.Column(db.Numeric(10, 4), default=0)
+    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, 4), default=0)
+    Marshi_Muddy_Slushy_0_to_1_5_total = db.Column(db.Float)
-    Marshi_Muddy_Slushy_1_5_to_3_0_total = db.Column(db.Numeric(10, 4), default=0)
+    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.Numeric(10, 4), default=0)
+    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, 4), default=0)
+    Soft_Murum_0_to_1_5_total = db.Column(db.Float)
-    Soft_Murum_1_5_to_3_0_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_1_5_to_3_0_total = db.Column(db.Float)
-    Soft_Murum_3_0_to_4_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_3_0_to_4_5_total = db.Column(db.Float)
 
-    Hard_Murum_0_to_1_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_0_to_1_5_total = db.Column(db.Float)
-    Hard_Murum_1_5_to_3_0_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_1_5_to_3_0_total = db.Column(db.Float)
-    Hard_Murum_3_0_to_4_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_3_0_to_4_5_total = db.Column(db.Float)
 
-    Soft_Rock_0_to_1_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_0_to_1_5_total = db.Column(db.Float)
-    Soft_Rock_1_5_to_3_0_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_1_5_to_3_0_total = db.Column(db.Float)
-    Soft_Rock_3_0_to_4_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_3_0_to_4_5_total = db.Column(db.Float)
 
-    Hard_Rock_0_to_1_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_0_to_1_5_total = db.Column(db.Float)
-    Hard_Rock_1_5_to_3_0_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_1_5_to_3_0_total = db.Column(db.Float)
-    Hard_Rock_3_0_to_4_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_3_0_to_4_5_total = db.Column(db.Float)
-    Hard_Rock_4_5_to_6_0_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_4_5_to_6_0_total = db.Column(db.Float)
-    Hard_Rock_6_0_to_7_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_6_0_to_7_5_total = db.Column(db.Float)
 
     Remarks = db.Column(db.String(500))
-    Total = db.Column(db.Numeric(12, 4), default=0)
+    Total = db.Column(db.Float)
 
     created_at = db.Column(db.DateTime, default=datetime.today)
 
@@ -81,13 +84,15 @@ class ManholeExcavationClient(db.Model):
         return {c.name: getattr(self, c.name) for c in self.__table__.columns}
 
 
-# AUTO TOTAL USING REGEX
+# ==========================================
+# AUTO CALCULATE GRAND TOTAL
+# ==========================================
 def calculate_Manhole_total(mapper, connection, target):
     total = 0
     for column in target.__table__.columns:
-        if RegularExpression.STR_TOTAL_PATTERN.match(column.name):
+        if column.name.endswith("_total"):
             total += getattr(target, column.name) or 0
-    target.Total = round(total)
+    target.Total = total
 
 
 event.listen(ManholeExcavationClient, "before_insert", calculate_Manhole_total)

app/models/tr_ex_client_model.py

@@ -1,7 +1,6 @@
 from app import db
 from datetime import datetime
 from sqlalchemy import event
-from app.utils.regex_utils import RegularExpression
 
 class TrenchExcavationClient(db.Model):
     __tablename__ = "tr_ex_client"
@@ -12,69 +11,69 @@ class TrenchExcavationClient(db.Model):
     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, 4), default=0)
+    CC_length = db.Column(db.Float)
-    Actual_Trench_Length = db.Column(db.Numeric(10, 4), default=0)
+    Actual_Trench_Length = db.Column(db.Float)
-    Ground_Level = db.Column(db.Numeric(10, 4), default=0)
+    Ground_Level = db.Column(db.Float)
-    Invert_Level = db.Column(db.Numeric(10, 4), default=0)
+    Invert_Level = db.Column(db.Float)
-    Excavated_level = db.Column(db.Numeric(10, 4), default=0)
+    Excavated_level = db.Column(db.Float)
-    Cutting_Depth = db.Column(db.Numeric(10, 4), default=0)
+    Cutting_Depth = db.Column(db.Float)
-    Avg_Depth = db.Column(db.Numeric(10, 4), default=0)
+    Avg_Depth = db.Column(db.Float)
-    Pipe_Dia_mm = db.Column(db.Numeric(10, 4), default=0)
+    Pipe_Dia_mm = db.Column(db.Float)
  
     # width
-    Width_0_to_1_5_m = db.Column(db.Numeric(10, 4), default=0)
+    Width_0_to_1_5_m = db.Column(db.Float)
-    Width_1_5_to_3_0_m = db.Column(db.Numeric(10, 4), default=0)
+    Width_1_5_to_3_0_m = db.Column(db.Float)
-    Width_3_0_to_4_5_m = db.Column(db.Numeric(10, 4), default=0)
+    Width_3_0_to_4_5_m = db.Column(db.Float)
-    Width_4_5_to_6_0_m = db.Column(db.Numeric(10, 4), default=0)
+    Width_4_5_to_6_0_m = db.Column(db.Float)
-    Width_6_0_to_7_5_m = db.Column(db.Numeric(10, 4), default=0)
+    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, 4), default=0)
+    Marshi_Muddy_Slushy_0_to_1_5 = db.Column(db.Float)
-    Marshi_Muddy_Slushy_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Marshi_Muddy_Slushy_1_5_to_3_0 = db.Column(db.Float)
-    Marshi_Muddy_Slushy_3_0_to_4_5 = db.Column(db.Numeric(10, 4), default=0)
+    Marshi_Muddy_Slushy_3_0_to_4_5 = db.Column(db.Float)
 
-    Soft_Murum_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_0_to_1_5 = db.Column(db.Float)
-    Soft_Murum_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_1_5_to_3_0 = db.Column(db.Float)
-    Soft_Murum_3_0_to_4_5 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_3_0_to_4_5 = db.Column(db.Float)
 
-    Hard_Murum_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_0_to_1_5 = db.Column(db.Float)
-    Hard_Murum_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_1_5_to_3_0 = db.Column(db.Float)
-    Hard_Murum_3_0_to_4_5 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_3_0_to_4_5 = db.Column(db.Float)
 
-    Soft_Rock_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_0_to_1_5 = db.Column(db.Float)
-    Soft_Rock_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_1_5_to_3_0 = db.Column(db.Float)
-    Soft_Rock_3_0_to_4_5 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_3_0_to_4_5 = db.Column(db.Float)
 
-    Hard_Rock_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_0_to_1_5 = db.Column(db.Float)
-    Hard_Rock_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_1_5_to_3_0 = db.Column(db.Float)
-    Hard_Rock_3_0_to_4_5 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_3_0_to_4_5 = db.Column(db.Float)
-    Hard_Rock_4_5_to_6_0 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_4_5_to_6_0 = db.Column(db.Float)
-    Hard_Rock_6_0_to_7_5 = db.Column(db.Numeric(10, 4), default=0)
+    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, 4), default=0)
+    Marshi_Muddy_Slushy_0_to_1_5_total = db.Column(db.Float)
-    Marshi_Muddy_Slushy_1_5_to_3_0_total = db.Column(db.Numeric(10, 4), default=0)
+    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.Numeric(10, 4), default=0)
+    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, 4), default=0)
+    Soft_Murum_0_to_1_5_total = db.Column(db.Float)
-    Soft_Murum_1_5_to_3_0_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_1_5_to_3_0_total = db.Column(db.Float)
-    Soft_Murum_3_0_to_4_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_3_0_to_4_5_total = db.Column(db.Float)
 
-    Hard_Murum_0_to_1_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_0_to_1_5_total = db.Column(db.Float)
-    Hard_Murum_1_5_to_3_0_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_1_5_to_3_0_total = db.Column(db.Float)
-    Hard_Murum_3_0_to_4_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_3_0_to_4_5_total = db.Column(db.Float)
 
-    Soft_Rock_0_to_1_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_0_to_1_5_total = db.Column(db.Float)
-    Soft_Rock_1_5_to_3_0_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_1_5_to_3_0_total = db.Column(db.Float)
-    Soft_Rock_3_0_to_4_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_3_0_to_4_5_total = db.Column(db.Float)
 
-    Hard_Rock_0_to_1_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_0_to_1_5_total = db.Column(db.Float)
-    Hard_Rock_1_5_to_3_0_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_1_5_to_3_0_total = db.Column(db.Float)
-    Hard_Rock_3_0_to_4_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_3_0_to_4_5_total = db.Column(db.Float)
-    Hard_Rock_4_5_to_6_0_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_4_5_to_6_0_total = db.Column(db.Float)
-    Hard_Rock_6_0_to_7_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_6_0_to_7_5_total = db.Column(db.Float)
 
-    Total = db.Column(db.Numeric(12, 4), default=0)
+    Total = db.Column(db.Float)
     Remarks = db.Column(db.String(500))
 
     created_at = db.Column(db.DateTime, default=datetime.today)
@@ -86,13 +85,17 @@ class TrenchExcavationClient(db.Model):
             return {c.name: getattr(self, c.name) for c in self.__table__.columns}
 
 
-# AUTO TOTAL USING REGEX
+# ==========================================
+# AUTO CALCULATE GRAND TOTAL
+# ==========================================
+
 def calculate_trench_client_total(mapper, connection, target):
     total = 0
     for column in target.__table__.columns:
-        if RegularExpression.STR_TOTAL_PATTERN.match(column.name):
+        if column.name.endswith("_total"):
             total += getattr(target, column.name) or 0
-    target.Total = round(total)
+    target.Total = total
+
 
 event.listen(TrenchExcavationClient, "before_insert", calculate_trench_client_total)
 event.listen(TrenchExcavationClient, "before_update", calculate_trench_client_total)

app/models/trench_excavation_model.py

@@ -1,7 +1,6 @@
 from app import db
 from datetime import datetime
 from sqlalchemy import event
-from app.utils.regex_utils import RegularExpression
 
 class TrenchExcavation(db.Model):
     __tablename__ = "trench_excavation"
@@ -15,59 +14,59 @@ class TrenchExcavation(db.Model):
     # Basic Fields
     Location = db.Column(db.String(500))
     MH_NO = db.Column(db.String(100))
-    CC_length = db.Column(db.Numeric(10, 4), default=0)
+    CC_length = db.Column(db.Float)
-    Invert_Level = db.Column(db.Numeric(10, 4), default=0)
+    Invert_Level = db.Column(db.Float)
-    MH_Top_Level = db.Column(db.Numeric(10, 4), default=0)
+    MH_Top_Level = db.Column(db.Float)
-    Ground_Level = db.Column(db.Numeric(10, 4), default=0)
+    Ground_Level = db.Column(db.Float)
-    ID_of_MH_m = db.Column(db.Numeric(10, 4), default=0)
+    ID_of_MH_m = db.Column(db.Float)
-    Actual_Trench_Length = db.Column(db.Numeric(10, 4), default=0)
+    Actual_Trench_Length = db.Column(db.Float)
-    Pipe_Dia_mm = db.Column(db.Numeric(10, 4), default=0)
+    Pipe_Dia_mm = db.Column(db.Float)
 
     # width
-    Width_0_to_2_5 = db.Column(db.Numeric(10, 4), default=0)
+    Width_0_to_2_5 = db.Column(db.Float)
-    Width_2_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Width_2_5_to_3_0 = db.Column(db.Float)
-    Width_3_0_to_4_5 = db.Column(db.Numeric(10, 4), default=0)
+    Width_3_0_to_4_5 = db.Column(db.Float)
-    Width_4_5_to_6_0 = db.Column(db.Numeric(10, 4), default=0)
+    Width_4_5_to_6_0 = db.Column(db.Float)
 
-    Upto_IL_Depth = db.Column(db.Numeric(10, 4), default=0)
+    Upto_IL_Depth = db.Column(db.Float)
-    Cutting_Depth = db.Column(db.Numeric(10, 4), default=0)
+    Cutting_Depth = db.Column(db.Float)
-    Avg_Depth = db.Column(db.Numeric(10, 4), default=0)
+    Avg_Depth = db.Column(db.Float)
 
     # Excavation categories
-    Soft_Murum_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_0_to_1_5 = db.Column(db.Float)
-    Soft_Murum_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_1_5_to_3_0 = db.Column(db.Float)
-    Soft_Murum_3_0_to_4_5 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_3_0_to_4_5 = db.Column(db.Float)
 
-    Hard_Murum_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_0_to_1_5 = db.Column(db.Float)
-    Hard_Murum_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_1_5_to_3_0 = db.Column(db.Float)
 
-    Soft_Rock_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_0_to_1_5 = db.Column(db.Float)
-    Soft_Rock_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_1_5_to_3_0 = db.Column(db.Float)
 
-    Hard_Rock_0_to_1_5 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_0_to_1_5 = db.Column(db.Float)
-    Hard_Rock_1_5_to_3_0 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_1_5_to_3_0 = db.Column(db.Float)
-    Hard_Rock_3_0_to_4_5 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_3_0_to_4_5 = db.Column(db.Float)
-    Hard_Rock_4_5_to_6_0 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_4_5_to_6_0 = db.Column(db.Float)
-    Hard_Rock_6_0_to_7_5 = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_6_0_to_7_5 = db.Column(db.Float)
 
     # Totals
-    Soft_Murum_0_to_1_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_0_to_1_5_total = db.Column(db.Float)
-    Soft_Murum_1_5_to_3_0_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_1_5_to_3_0_total = db.Column(db.Float)
-    Soft_Murum_3_0_to_4_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Murum_3_0_to_4_5_total = db.Column(db.Float)
 
-    Hard_Murum_0_to_1_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_0_to_1_5_total = db.Column(db.Float)
-    Hard_Murum_1_5_and_above_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Murum_1_5_and_above_total = db.Column(db.Float)
 
-    Soft_Rock_0_to_1_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_0_to_1_5_total = db.Column(db.Float)
-    Soft_Rock_1_5_and_above_total = db.Column(db.Numeric(10, 4), default=0)
+    Soft_Rock_1_5_and_above_total = db.Column(db.Float)
 
-    Hard_Rock_0_to_1_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_0_to_1_5_total = db.Column(db.Float)
-    Hard_Rock_1_5_to_3_0_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_1_5_to_3_0_total = db.Column(db.Float)
-    Hard_Rock_3_0_to_4_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_3_0_to_4_5_total = db.Column(db.Float)
-    Hard_Rock_4_5_to_6_0_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_4_5_to_6_0_total = db.Column(db.Float)
-    Hard_Rock_6_0_to_7_5_total = db.Column(db.Numeric(10, 4), default=0)
+    Hard_Rock_6_0_to_7_5_total = db.Column(db.Float)
 
-    Total = db.Column(db.Numeric(12, 4), default=0)
+    Total = db.Column(db.Float)
     Remarks = db.Column(db.String(500))
     RA_Bill_No=db.Column(db.String(500))
     
@@ -80,12 +79,44 @@ 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 safe(val):
+            return val or 0
+
+        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)
+            ),
+        }
+
+# ==========================================
+# AUTO CALCULATE GRAND TOTAL
+# ==========================================
 def calculate_trench_total(mapper, connection, target):
     total = 0
     for column in target.__table__.columns:
-        if RegularExpression.STR_TOTAL_PATTERN.match(column.name):
+        if column.name.endswith("_total"):
             total += getattr(target, column.name) or 0
     target.Total = total
 

app/models/user_model.py

@@ -5,7 +5,7 @@ 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=False)
 

app/routes/dashboard.py

@@ -1,7 +1,7 @@
 import matplotlib
 matplotlib.use("Agg")
 
-from flask import Blueprint, render_template, session, redirect, url_for, jsonify, request
+from flask import Blueprint, render_template, session, redirect, url_for, jsonify
 import matplotlib.pyplot as plt
 import io
 import base64
@@ -13,8 +13,6 @@ from app.models.trench_excavation_model import TrenchExcavation
 from app.models.manhole_excavation_model import ManholeExcavation
 from app.models.laying_model import Laying
 
-from app.models.subcontractor_model import Subcontractor
-
 dashboard_bp = Blueprint("dashboard", __name__, url_prefix="/dashboard")
 
 
@@ -25,6 +23,97 @@ def dashboard():
     return render_template("dashboard.html", title="Business Intelligence Dashboard")
 
 
+
+
+# import matplotlib
+# matplotlib.use("Agg")
+
+# from flask import Blueprint, render_template, session, redirect, url_for
+# import matplotlib.pyplot as plt
+# import io
+# import base64
+# from app.utils.plot_utils import plot_to_base64
+# from app.services.dashboard_service import DashboardService
+
+# dashboard_bp = Blueprint("dashboard", __name__, url_prefix="/dashboard")
+
+# # dashboard_bp = Blueprint("dashboard", __name__)
+
+# # charts 
+# # def plot_to_base64():
+# #     img = io.BytesIO()
+# #     plt.savefig(img, format="png", bbox_inches="tight")
+# #     plt.close()
+# #     img.seek(0)
+# #     return base64.b64encode(img.getvalue()).decode()
+
+# # bar chart
+# def bar_chart():
+#     categories = ["Trench", "Manhole", "Pipe Laying", "Restoration"]
+#     values = [120, 80, 150, 60]
+
+#     plt.figure()
+#     plt.bar(categories, values)
+#     plt.title("Work Category Report")
+#     plt.xlabel("test Category")
+#     plt.ylabel("test Quantity")
+
+
+#     return plot_to_base64(plt)
+
+# # Pie chart
+# def pie_chart():
+#     labels = ["Completed", "In Progress", "Pending"]
+#     sizes = [55, 20, 25]
+
+#     plt.figure()
+#     plt.pie(sizes, labels=labels, autopct="%1.1f%%", startangle=140)
+#     plt.title("Project Status")
+
+#     return plot_to_base64(plt)
+
+# # Histogram chart
+# def histogram_chart():
+#     daily_work = [5, 10, 15, 20, 20, 25, 30, 35, 40, 45, 50]
+
+#     plt.figure()
+#     plt.hist(daily_work, bins=5)
+#     plt.title("Daily Work Distribution")
+#     plt.xlabel("Work Units")
+#     plt.ylabel("Frequency")
+
+#     return plot_to_base64(plt)
+
+# # Dashboaed page
+# @dashboard_bp.route("/")
+# def dashboard():
+#     if not session.get("user_id"):
+#         return redirect(url_for("auth.login"))
+
+#     return render_template(
+#         "dashboard.html",
+#         title="Dashboard",
+#         bar_chart=bar_chart(),
+#         pie_chart=pie_chart(),
+#         histogram=histogram_chart()
+#     )
+
+# # subcontractor dashboard
+# @dashboard_bp.route("/subcontractor_dashboard", methods=["GET", "POST"])
+# def subcontractor_dashboard():
+#     if not session.get("user_id"):
+#         return redirect(url_for("auth.login"))
+
+#     tr_dash = DashboardService().bar_chart_of_tr_ex
+    
+    
+#     return render_template(
+#         "subcontractor_dashboard.html",
+#         title="Dashboard",
+#         bar_chart=tr_dash
+#     )
+
+
 @dashboard_bp.route("/api/live-stats")
 def live_stats():
     try:
@@ -63,182 +152,16 @@ def live_stats():
 
 
 # subcontractor dashboard
-@dashboard_bp.route("/subcontractor_dashboard")
+@dashboard_bp.route("/subcontractor_dashboard", methods=["GET", "POST"])
 def subcontractor_dashboard():
-
     if not session.get("user_id"):
         return redirect(url_for("auth.login"))
 
-    subcontractors = Subcontractor.query.all()
+    tr_dash = DashboardService().bar_chart_of_tr_ex
-
+    
+    
     return render_template(
         "subcontractor_dashboard.html",
-        subcontractors=subcontractors
+        title="Dashboard",
-    )
+        bar_chart=tr_dash
-
+    )
-# ✅ API: Get Unique RA Bills
-@dashboard_bp.route("/api/get-ra-bills")
-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 _:
-            results = []
-
-    ra_bills = [r[0] for r in results if r[0]]
-
-    return {"ra_bills": ra_bills}
-
-
-# API FOR CHART DATA
-# @dashboard_bp.route("/api/subcontractor-chart")
-# def subcontractor_chart():
-
-#     subcontractor_id = request.args.get("subcontractor")
-#     category = request.args.get("category")
-#     ra_bill = request.args.get("ra_bill")
-
-#     labels = []
-#     values = []
-
-#     match category:
-
-#         # ✅ Trench
-#         case "trench_excavation":
-#             query = db.session.query(
-#                 TrenchExcavation.excavation_category,
-#                 func.sum(TrenchExcavation.Total)
-#             )
-
-#             if subcontractor_id:
-#                 query = query.filter(TrenchExcavation.subcontractor_id == subcontractor_id)
-
-#             if ra_bill:
-#                 query = query.filter(TrenchExcavation.RA_Bill_No == ra_bill)
-
-#             results = query.group_by(TrenchExcavation.excavation_category).all()
-
-#         # ✅ Manhole
-#         case "manhole_excavation":
-#             query = db.session.query(
-#                 ManholeExcavation.excavation_category,
-#                 func.sum(ManholeExcavation.Total)
-#             )
-
-#             if subcontractor_id:
-#                 query = query.filter(ManholeExcavation.subcontractor_id == subcontractor_id)
-
-#             if ra_bill:
-#                 query = query.filter(ManholeExcavation.RA_Bill_No == ra_bill)
-
-#             results = query.group_by(ManholeExcavation.excavation_category).all()
-
-#         case _:
-#             results = []
-
-#     for r in results:
-#         labels.append(r[0])
-#         values.append(float(r[1] or 0))
-
-#     return jsonify({
-#         "labels": labels,
-#         "values": values
-#     })
-
-
-@dashboard_bp.route("/api/trench-analysis")
-def trench_analysis():
-
-    subcontractor_id = request.args.get("subcontractor")
-    ra_bill = request.args.get("ra_bill")
-
-    query = TrenchExcavation.query
-
-    if subcontractor_id:
-        query = query.filter(TrenchExcavation.subcontractor_id == subcontractor_id)
-
-    if ra_bill:
-        query = query.filter(TrenchExcavation.RA_Bill_No == ra_bill)
-
-    data = query.all()
-
-    result = {
-        "Soft Murum": {"depth": 0, "qty": 0},
-        "Hard Murum": {"depth": 0, "qty": 0},
-        "Soft Rock": {"depth": 0, "qty": 0},
-        "Hard Rock": {"depth": 0, "qty": 0},
-    }
-
-    for r in data:
-
-        # Soft Murum
-        result["Soft Murum"]["depth"] += (
-            (r.Soft_Murum_0_to_1_5 or 0) +
-            (r.Soft_Murum_1_5_to_3_0 or 0) +
-            (r.Soft_Murum_3_0_to_4_5 or 0)
-        )
-        result["Soft Murum"]["qty"] += (
-            (r.Soft_Murum_0_to_1_5_total or 0) +
-            (r.Soft_Murum_1_5_to_3_0_total or 0) +
-            (r.Soft_Murum_3_0_to_4_5_total or 0)
-        )
-
-        # Hard Murum
-        result["Hard Murum"]["depth"] += (
-            (r.Hard_Murum_0_to_1_5 or 0) +
-            (r.Hard_Murum_1_5_to_3_0 or 0)
-        )
-        result["Hard Murum"]["qty"] += (
-            (r.Hard_Murum_0_to_1_5_total or 0) +
-            (r.Hard_Murum_1_5_and_above_total or 0)
-        )
-
-        # Soft Rock
-        result["Soft Rock"]["depth"] += (
-            (r.Soft_Rock_0_to_1_5 or 0) +
-            (r.Soft_Rock_1_5_to_3_0 or 0)
-        )
-        result["Soft Rock"]["qty"] += (
-            (r.Soft_Rock_0_to_1_5_total or 0) +
-            (r.Soft_Rock_1_5_and_above_total or 0)
-        )
-
-        # Hard Rock
-        result["Hard Rock"]["depth"] += (
-            (r.Hard_Rock_0_to_1_5 or 0) +
-            (r.Hard_Rock_1_5_to_3_0 or 0) +
-            (r.Hard_Rock_3_0_to_4_5 or 0) +
-            (r.Hard_Rock_4_5_to_6_0 or 0) +
-            (r.Hard_Rock_6_0_to_7_5 or 0)
-        )
-        result["Hard Rock"]["qty"] += (
-            (r.Hard_Rock_0_to_1_5_total or 0) +
-            (r.Hard_Rock_1_5_to_3_0_total or 0) +
-            (r.Hard_Rock_3_0_to_4_5_total or 0) +
-            (r.Hard_Rock_4_5_to_6_0_total or 0) +
-            (r.Hard_Rock_6_0_to_7_5_total or 0)
-        )
-
-    labels = list(result.keys())
-    depth = [result[k]["depth"] for k in labels]
-    qty = [result[k]["qty"] for k in labels]
-
-    return jsonify({
-        "labels": labels,
-        "depth": depth,
-        "qty": qty
-    })

app/routes/file_format.py

@@ -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):

app/routes/file_report.py

@@ -145,61 +145,73 @@ def report_file():
 # --- CLIENT REPORT (PREVIEW + DOWNLOAD) ---
 @file_report_bp.route("/client_report", methods=["GET", "POST"])
 @login_required
-def client_report():
+def client_vs_all_subcontractor():
-
+    tables = {"tr": None, "mh": None, "dc": None}
-    tables = {"tr": None, "mh": None, "dc": None, "laying": 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)
+            return render_template("generate_comparison_client_vs_subcont.html", tables=tables, ra_val=ra_val)
-
+ 
-        # -------- FETCH CLIENT DATA --------
+        clientBill = ClientBill()
-        bill_gen = ClientBill()
+        clientBill.Fetch(RA_Bill_No=RA_Bill_No)
-        bill_gen.Fetch(RA_Bill_No)
+        contractorBill = SubcontractorBill()
-
+        contractorBill.Fetch(RA_Bill_No=RA_Bill_No)
-        # If no data
+ 
-        if (
+        # --- SAFETY CHECK: Verify data exists before merging ---
-            bill_gen.df_tr.empty and
+        if clientBill.df_tr.empty and clientBill.df_mh.empty:
-            bill_gen.df_mh.empty and
-            bill_gen.df_dc.empty and
-            bill_gen.df_laying.empty
-        ):
             flash(f"No Client records found for RA Bill {RA_Bill_No}", "warning")
+            return render_template("generate_comparison_client_vs_subcont.html", tables=tables, ra_val=ra_val)
+ 
+        qty_cols = [...] # (Keep your existing list)
+        mh_dc_qty_cols = [...] # (Keep your existing list)
+        mh_lay_qty_cols =[...]
+
+        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()
+ 
+        # 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)
+ 
+        # --- 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)
-
+ 
-        # -------- DOWNLOAD --------
+       
-        if action == "download":
+        # Convert to HTML for preview
-
+        tables["tr"] = df_tr_cmp.to_html(classes='table table-striped table-hover table-sm', index=False)
-            output = io.BytesIO()
+        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)
-            with pd.ExcelWriter(output, engine="xlsxwriter") as writer:
+        tables["laying"] = df_lay_cmp.to_html(classes='table table-striped table-hover table-sm', index=False)
-                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")
+    return render_template("client_report.html", tables=tables, ra_val=ra_val)   
-                bill_gen.df_laying.to_excel(writer, index=False, sheet_name="Laying")
+ 
-
-            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)
-
-    return render_template("client_report.html", tables=tables, ra_val=ra_val)

app/routes/generate_comparison_report.py

@@ -2,7 +2,7 @@ from flask import Blueprint, render_template, request, send_file, flash
 from collections import defaultdict
 import pandas as pd
 import io
-
+ 
 from app.models.subcontractor_model import Subcontractor
 from app.models.trench_excavation_model import TrenchExcavation
 from app.models.manhole_excavation_model import ManholeExcavation
@@ -15,13 +15,17 @@ from app.models.mh_dc_client_model import ManholeDomesticChamberClient
 from app.models.laying_client_model import LayingClient
  
 from app.utils.helpers import login_required
-from app.utils.regex_utils import RegularExpression
+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):
@@ -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 D_RANGE_PATTERN.match(k)
-            or RegularExpression.PIPE_MM_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 D_RANGE_PATTERN.match(k)
-            or RegularExpression.PIPE_MM_PATTERN.match(k)
+            or PIPE_MM_PATTERN.match(k)
         )
  
         row = {
@@ -135,9 +138,7 @@ 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
  
  
@@ -224,12 +225,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()
@@ -250,4 +254,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

app/routes/subcontractor_routes.py

@@ -40,8 +40,7 @@ def save_subcontractor():
             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"),
+            gst_no=request.form.get("gst_no")
-            pan_no=request.form.get("pan_no")
         )
 
         db.session.add(subcontractor)
@@ -121,8 +120,6 @@ def update_subcontractor(id):
         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()
 

app/services/file_service.py

@@ -1,10 +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
-from app.utils.file_utils import get_uploads_folder
+
-from app.utils.file_utils import ALLOWED_EXTENSIONS
+from app.config import Config
+from app import db
 
 # Subcontractor models import
 from app.models.trench_excavation_model import TrenchExcavation
@@ -24,7 +24,7 @@ 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)
 
     def normalize(self, val):
         if val is None or pd.isna(val):
@@ -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)
@@ -311,6 +310,7 @@ class FileService:
         db.session.commit()
 
 
+
     # ---------------- 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)

app/services/logger_service.py

@@ -1,25 +1,20 @@
 import os
 import logging
 from logging.handlers import RotatingFileHandler
-from flask import request, session, has_request_context
+from flask import request, session
 
 
-class RequestContextFilter(logging.Filter):
+class RequestFormatter(logging.Formatter):
+    """
+    Custom formatter to safely inject request data
+    """
 
-    def filter(self, record):
+    def format(self, record):
-
+        record.user = getattr(record, "user", "Anonymous")
-        if has_request_context():
+        record.ip = getattr(record, "ip", "N/A")
-            record.user = session.get("user_email", "Anonymous")
+        record.method = getattr(record, "method", "N/A")
-            record.ip = request.remote_addr
+        record.url = getattr(record, "url", "N/A")
-            record.method = request.method
+        return super().format(record)
-            record.url = request.url
-        else:
-            record.user = "System"
-            record.ip = "N/A"
-            record.method = "N/A"
-            record.url = "N/A"
-
-        return True
 
 
 class LoggerService:
@@ -27,17 +22,18 @@ class LoggerService:
     @staticmethod
     def init_app(app):
 
+        # Create logs folder if not exists
         if not os.path.exists("logs"):
             os.makedirs("logs")
 
-        formatter = logging.Formatter(
+        formatter = RequestFormatter(
             "%(asctime)s | %(levelname)s | "
             "User:%(user)s | IP:%(ip)s | "
             "Method:%(method)s | URL:%(url)s | "
             "%(message)s"
         )
 
-        # INFO LOG
+        # 🔹 INFO LOG
         info_handler = RotatingFileHandler(
             "logs/app.log",
             maxBytes=5 * 1024 * 1024,
@@ -46,7 +42,7 @@ class LoggerService:
         info_handler.setLevel(logging.INFO)
         info_handler.setFormatter(formatter)
 
-        # ERROR LOG
+        # 🔹 ERROR LOG
         error_handler = RotatingFileHandler(
             "logs/error.log",
             maxBytes=5 * 1024 * 1024,
@@ -55,25 +51,32 @@ class LoggerService:
         error_handler.setLevel(logging.ERROR)
         error_handler.setFormatter(formatter)
 
-        # CONSOLE
+        # 🔹 CONSOLE LOG
         console_handler = logging.StreamHandler()
         console_handler.setLevel(logging.DEBUG)
         console_handler.setFormatter(formatter)
 
-        # 🔹 ADD FILTER (important)
-        context_filter = RequestContextFilter()
-
-        info_handler.addFilter(context_filter)
-        error_handler.addFilter(context_filter)
-        console_handler.addFilter(context_filter)
-
         app.logger.setLevel(logging.DEBUG)
-
         app.logger.addHandler(info_handler)
         app.logger.addHandler(error_handler)
         app.logger.addHandler(console_handler)
 
-        # Log every request automatically
+        # Auto request logging
         @app.before_request
         def log_request():
-            app.logger.info("Request Started")
+            app.logger.info(
+                "Request Started",
+                extra=LoggerService.get_request_data()
+            )
+
+    @staticmethod
+    def get_request_data():
+        try:
+            return {
+                "user": session.get("user_email", "Anonymous"),
+                "ip": request.remote_addr,
+                "method": request.method,
+                "url": request.url
+            }
+        except:
+            return {}

app/templates/client_report.html

@@ -29,20 +29,25 @@
         <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 Comparison</button>
+                    type="button">Tr.Ex </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
-                    Comparison</button>
+                    </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
-                    Comparison</button>
+                    </button>
             </li>
             <li class="nav-item">
+<<<<<<< HEAD
                 <button class="nav-link" id="laying-tab" data-bs-toggle="tab" data-bs-target="#laying"
                     type="button">Laying
                     & Bedding Comparison</button>
+=======
+                <button class="nav-link" id="laying-tab" data-bs-toggle="tab" data-bs-target="#laying" type="button">Laying
+                    & Bedding </button>
+>>>>>>> 1dceb640bd930c37888799f10f02fe90b219be67
         </ul>
 
         <div class="tab-content mt-3" id="reportTabsContent">

app/templates/subcontractor/add.html

@@ -36,11 +36,6 @@
             <input type="text" class="form-control" name="gst_no">
         </div>
 
-        <div class="mb-3">
-            <label class="form-label">PAN No:</label>
-            <input type="text" class="form-control" name="pan_no">
-        </div>
-
         <button class="btn btn-success">Save</button>
         <a href="{{ url_for('subcontractor.subcontractor_list') }}" class="btn btn-secondary">Back</a>
 

app/templates/subcontractor/edit.html

@@ -37,23 +37,6 @@
             <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>
 

app/templates/subcontractor/list.html

@@ -19,9 +19,9 @@
                 <table class="table table-bordered table-hover align-middle">
                     <thead class="table-dark">
                         <tr>
-                            <th>Sr. No</th>
+                            <th>ID</th>
-                            <th>Subcontractor Name</th>
+                            <th>Name</th>
-                            <th>GST No</th>
+                            <th>Contact</th>
                             <th>Mobile</th>
                             <th>Email</th>
                             <th>Status</th>
@@ -33,7 +33,7 @@
                         <tr>
                             <td>{{ s.id }}</td>
                             <td>{{ s.subcontractor_name }}</td>
-                            <td>{{ s.gst_no }}</td>
+                            <td>{{ s.contact_person }}</td>
                             <td>{{ s.mobile_no }}</td>
                             <td>{{ s.email_id }}</td>
                             <td>
@@ -65,9 +65,9 @@
                 {% 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>
+                        <h6 class="fw-bold mb-2">{{ s.subcontractor_name }}</h6>
 
-                        <p class="mb-1"><strong>GST No:</strong> {{ s.gst_no }}</p>
+                        <p class="mb-1"><strong>Contact Person Name:</strong> {{ s.contact_person }}</p>
                         <p class="mb-1"><strong>Mobile:</strong> {{ s.mobile_no }}</p>
                         <p class="mb-1"><strong>Email:</strong> {{ s.email_id }}</p>
 

app/templates/subcontractor_dashboard.html

@@ -1,118 +1,122 @@
 {% extends "base.html" %}
+
 {% block content %}
 
-<div class="container mt-3">
+<div class="container-fluid px-2 px-md-4">
 
-    <h4>RA Bill Dashboard</h4>
+    <h4 class="mb-3 text-center text-md-start">Subcontractor Dashboard </h4>
 
-    <div class="row mb-3">
+    <div class="row g-3 mb-4">
-
+        <div class="col-12 col-md-4">
-        <!-- Contractor -->
+            <div class="card text-white bg-primary shadow h-100">
-        <div class="col-md-4">
+                <div class="card-body text-center text-md-start">
-            <select id="subcontractor" class="form-control">
+                    <h6>Trenching Units</h6>
-                <option value="">Select Contractor</option>
+                    <h3 class="fw-bold" id="card-trench">0</h3>
-                {% for s in subcontractors %}
+                </div>
-                <option value="{{s.id}}">{{s.subcontractor_name}}</option>
+            </div>
-                {% endfor %}
-            </select>
         </div>
-
+        <div class="col-12 col-md-4">
-        <!-- Category -->
+            <div class="card text-white bg-success shadow h-100">
-        <div class="col-md-4">
+                <div class="card-body text-center text-md-start">
-            <select id="category" class="form-control">
+                    <h6>Manhole Units</h6>
-                <option value="">Select Category</option>
+                    <h3 class="fw-bold" id="card-manhole">0</h3>
-                <option value="trench_excavation">Trench Excavation</option>
+                </div>
-            </select>
+            </div>
         </div>
-
+        <div class="col-12 col-md-4">
-        <!-- RA Bill -->
+            <div class="card text-dark bg-warning shadow h-100">
-        <div class="col-md-4">
+                <div class="card-body text-center text-md-start">
-            <select id="ra_bill" class="form-control">
+                    <h6>Laying Units</h6>
-                <option value="">RA Bill</option>
+                    <h3 class="fw-bold" id="card-laying">0</h3>
-            </select>
+                </div>
+            </div>
         </div>
-
     </div>
 
-    <div class="card">
+    <div class="row g-3">
-        <div class="card-body">
+        <div class="col-12 col-md-6">
-            <canvas id="comparisonChart"></canvas>
+            <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>
+            </div>
+        </div>
+
+        <div class="col-12 col-md-6">
+            <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>
+            </div>
         </div>
     </div>
 
 </div>
 
+
 <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',
+        data: {
+            labels: ['Trenching', 'Manholes', 'Laying'],
+            datasets: [{
+                label: 'Units Completed',
+                data: [0, 0, 0],
+                backgroundColor: ['#0d6efd', '#198754', '#ffc107']
+            }]
+        },
+        options: { responsive: true, maintainAspectRatio: false }
+    });
 
-    let chart;
+    // 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']
+            }]
+        },
+        options: { responsive: true, maintainAspectRatio: false }
+    });
 
-    // ✅ Load RA Bills
+    // 4. Function to Fetch Live Data from your Python API
-    function loadRABills() {
+    function fetchLiveData() {
-
+        fetch('/dashboard/api/live-stats') // This matches the route we created in the "Kitchen"
-        let subcontractor = document.getElementById("subcontractor").value
+            .then(response => response.json())
-        let category = document.getElementById("category").value
-
-        if (!subcontractor || !category) return
-
-        fetch(`/dashboard/api/get-ra-bills?subcontractor=${subcontractor}&category=${category}`)
-            .then(res => res.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;
 
-                let ra = document.getElementById("ra_bill")
+                // Update Bar Chart
-                ra.innerHTML = '<option value="">RA Bill</option>'
+                liveBarChart.data.datasets[0].data = [
+                    data.summary.trench,
+                    data.summary.manhole,
+                    data.summary.laying
+                ];
+                liveBarChart.update();
 
-                data.ra_bills.forEach(bill => {
+                // Update Pie Chart (Location stats)
-                    ra.innerHTML += `<option value="${bill}">${bill}</option>`
+                livePieChart.data.labels = Object.keys(data.locations);
-                })
+                livePieChart.data.datasets[0].data = Object.values(data.locations);
+                livePieChart.update();
             })
+            .catch(err => console.error("Error fetching live data:", err));
     }
 
-    // ✅ Load Chart
+    // 5. Check for updates every 10 seconds (Real-time effect)
-    function loadChart() {
+    setInterval(fetchLiveData, 10000);
-
+    fetchLiveData(); // Load immediately on page open
-        let subcontractor = document.getElementById("subcontractor").value
-        let ra_bill = document.getElementById("ra_bill").value
-
-        fetch(`/dashboard/api/trench-analysis?subcontractor=${subcontractor}&ra_bill=${ra_bill}`)
-            .then(res => res.json())
-            .then(data => {
-
-                if (chart) chart.destroy()
-
-                chart = new Chart(document.getElementById("comparisonChart"), {
-                    type: "bar",
-                    data: {
-                        labels: data.labels,
-                        datasets: [
-                            {
-                                label: "Depth",
-                                data: data.depth,
-                                backgroundColor: "green"
-                            },
-                            {
-                                label: "Excavation Qty (cum)",
-                                data: data.qty,
-                                backgroundColor: "blue"
-                            }
-                        ]
-                    }
-                })
-            })
-    }
-
-    // Events
-    document.getElementById("subcontractor").addEventListener("change", () => {
-        loadRABills()
-    })
-
-    document.getElementById("category").addEventListener("change", () => {
-        loadRABills()
-    })
-
-    document.getElementById("ra_bill").addEventListener("change", loadChart)
-
 </script>
 
 {% endblock %}

app/utils/file_utils.py

@@ -1,26 +1,6 @@
 import os
-from flask import current_app
+from app.config import Config
-
-
-# file extension
-ALLOWED_EXTENSIONS = {"xlsx", "xls", "csv"}
-
-
-def get_download_format_folder():
-    return os.path.join(
-        current_app.root_path,
-        "static",
-        "downloads",
-        "format"
-    )
-
-def get_uploads_folder():
-    return os.path.join(
-        current_app.root_path,
-        "static",
-        "uploads"
-    )
 
 def ensure_upload_folder():
-    if not os.path.exists(get_uploads_folder()):
+    if not os.path.exists(Config.UPLOAD_FOLDER):
-        os.makedirs(get_uploads_folder())
+        os.makedirs(Config.UPLOAD_FOLDER)

app/utils/regex_utils.py

@@ -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+)?$")