Add new reference models and update repositories for enhanced data handling

- Introduced new models: StatusInfo, EstShipDate, FOB, and EstFreight to expand reference data capabilities.
- Updated existing models (Country, CompanyType, PaymentTerm, etc.) to align with new schema requirements and removed CustomerStatus.
- Modified BidderRepository to streamline project number handling.
- Enhanced ReferenceDataRepository to include new reference models and improved stored procedure handling.
- Updated schemas to reflect changes in models, including new output classes for FOB, EstShipDate, EstFreight, and StatusInfo.
- Refactored ReferenceDataService to incorporate new methods for fetching FOBs, estimated ship dates, estimated freights, and status info.
- Added tools for scanning dynamic SQL in stored procedures, including a SQL script and a Python CLI wrapper.

app/controllers/reference.py

@@ -5,7 +5,7 @@ from app.services.reference_service import ReferenceDataService
 from app.schemas.reference import (
     StateOut, CountryOut, CompanyTypeOut, LeadSourceOut, PaymentTermOut,
     PurchasePriceOut, RentalPriceOut, BarrierSizeOut, ProductApplicationOut,
-    CustomerStatusOut, ProjectStatusOut, ReferenceDataResponse
+    ReferenceDataResponse, FOBOut, EstShipDateOut, EstFreightOut, StatusInfoOut
 )
 from app.core.dependencies import get_current_user_optional
 from app.schemas.auth import CurrentUser
@@ -36,7 +36,6 @@ def get_all_reference_data(
     - Rental Prices
     - Barrier Sizes
     - Product Applications
-    - Customer Statuses
     - Project Statuses
     
     **Note**: This endpoint is public but may have enhanced data for authenticated users.
@@ -161,31 +160,62 @@ def get_product_applications(
     service = ReferenceDataService(db)
     return service.get_product_applications(active_only=active_only)
 
-@router.get("/customer-statuses", response_model=List[CustomerStatusOut])
-def get_customer_statuses(
-    active_only: bool = Query(True, description="Return only active customer statuses"),
+
+
+@router.get("/fobs", response_model=List[FOBOut])
+def get_FOB(
+    active_only: bool = Query(True, description="Return only active FOBS"),
     db: Session = Depends(get_db)
 ):
     """
-    Get all customer statuses.
+    Get all FOBs (Free on Board terms).
     
-    Returns a list of all available customer status options.
+    Returns a list of all available FOB terms used in shipping.
     """
     service = ReferenceDataService(db)
-    return service.get_customer_statuses(active_only=active_only)
+    return service.get_fobs(active_only=active_only)
+
 
-@router.get("/project-statuses", response_model=List[ProjectStatusOut])
-def get_project_statuses(
-    active_only: bool = Query(True, description="Return only active project statuses"),
+@router.get("/est-ship-dates", response_model=List[EstShipDateOut])
+def get_est_ship_dates(
+    active_only: bool = Query(True, description="Return only active estimated ship dates"),
     db: Session = Depends(get_db)
 ):
     """
-    Get all project statuses.
-    
-    Returns a list of all available project status options with color codes.
+    Get all Estimated Ship Date options.
+    Returns a list of estimated shipping date options from the DB.
+    """
+    service = ReferenceDataService(db)
+    return service.get_est_ship_dates(active_only=active_only)
+
+
+@router.get("/est-freights", response_model=List[EstFreightOut])
+def get_est_freights(
+    active_only: bool = Query(True, description="Return only active estimated freights"),
+    db: Session = Depends(get_db)
+):
+    """
+    Get all Estimated Freight options.
+    Returns a list of estimated freight options from the DB.
     """
     service = ReferenceDataService(db)
-    return service.get_project_statuses(active_only=active_only)
+    return service.get_est_freights(active_only=active_only)
+
+
+@router.get("/status-info", response_model=List[StatusInfoOut])
+def get_status_info(
+    active_only: bool = Query(True, description="Return only active status info records"),
+    db: Session = Depends(get_db)
+):
+    """
+    Get all StatusInfo records.
+    Returns a list of project status metadata (ID, description, abbreviation).
+    """
+    service = ReferenceDataService(db)
+    return service.get_status_info(active_only=active_only)
+
+
+
 
 @router.post("/clear-cache", status_code=status.HTTP_200_OK)
 def clear_reference_cache(

app/db/models/reference.py

@@ -1,4 +1,4 @@
-from sqlalchemy import Column, Integer, String, Boolean, Text, DateTime
+from sqlalchemy import Column, Integer, String, Boolean, Text, DateTime, Numeric
 from app.db.base import Base
 
 class State(Base):
@@ -9,84 +9,93 @@ class State(Base):
     description = Column("Description", String(255), nullable=True)
     enabled = Column("Enabled", Boolean, nullable=True)
 
+
+class StatusInfo(Base):
+    __tablename__ = "StatusInfo"
+
+    # DB table uses ID, Desc, Abrv
+    status_info_id = Column("ID", Integer, primary_key=True, index=True)
+    description = Column("Desc", String(255), nullable=True)
+    abrv = Column("Abrv", String(50), nullable=True)
+    # optional enabled mapping if present
+ 
+
+class EstShipDate(Base):
+    __tablename__ = "EstShipDate"
+
+    # DB table uses Id and EstShipDateDescription
+    est_ship_date_id = Column("Id", Integer, primary_key=True, index=True)
+    est_ship_date_description = Column("EstShipDateDescription", String(255), nullable=True)
+ 
 class Country(Base):
     __tablename__ = "Countries"
     
     country_id = Column("CountryID", Integer, primary_key=True, index=True)
-    country_name = Column("CountryName", String(100), nullable=False)
-    country_code = Column("CountryCode", String(3), nullable=True)
-    # Make IsActive column optional in case it doesn't exist in the database
-    # Set nullable=True so SQLAlchemy doesn't fail if the column is missing
-    is_active = Column("IsActive", Boolean, nullable=True)
+    customer_type_id = Column("CustomerTypeID", Integer, nullable=True)
+    description = Column("Description", String(255), nullable=True)
+    enabled = Column("Enabled", Boolean, nullable=True)
+
+ 
 
 class CompanyType(Base):
     __tablename__ = "CompanyTypes"
     
     company_type_id = Column("CompanyTypeID", Integer, primary_key=True, index=True)
-    company_type_name = Column("CompanyTypeName", String(100), nullable=False)
+    customer_type_id = Column("CustomerTypeID", Integer, nullable=True)
     description = Column("Description", String(255), nullable=True)
-    is_active = Column("IsActive", Boolean, nullable=False, default=True)
+    enabled = Column("Inactive", Boolean, nullable=True)
 
 class LeadGeneratedFrom(Base):
     __tablename__ = "LeadGeneratedFroms"
     
     lead_generated_from_id = Column("LeadGeneratedFromID", Integer, primary_key=True, index=True)
-    source_name = Column("SourceName", String(100), nullable=False)
+    source_name = Column("CustomerTypeID", String(100), nullable=False)
     description = Column("Description", String(255), nullable=True)
-    is_active = Column("IsActive", Boolean, nullable=False, default=True)
+    enabled = Column("Enabled", Boolean, nullable=False, default=True)
+
+ 
 
 class PaymentTerm(Base):
-    __tablename__ = "PaymentTerms"
-    
-    payment_term_id = Column("PaymentTermID", Integer, primary_key=True, index=True)
-    term_name = Column("TermName", String(50), nullable=False)
-    days = Column("Days", Integer, nullable=False)
-    description = Column("Description", String(255), nullable=True)
-    is_active = Column("IsActive", Boolean, nullable=False, default=True)
+    __tablename__ = "PaymentTerm"
+    payment_term_id = Column("ID", Integer, primary_key=True, index=True)
+    description = Column("PaymentDescription", String(50), nullable=False)
+    enabled = Column("Enabled", Boolean, nullable=False, default=True)
 
+ 
 class PurchasePrice(Base):
-    __tablename__ = "PurchasePrices"
+    __tablename__ = "PurchasePrice"
     
-    purchase_price_id = Column("PurchasePriceID", Integer, primary_key=True, index=True)
-    price_name = Column("PriceName", String(100), nullable=False)
-    price_value = Column("PriceValue", String(50), nullable=False)
-    effective_date = Column("EffectiveDate", DateTime, nullable=True)
-    is_active = Column("IsActive", Boolean, nullable=False, default=True)
+    purchase_price_id = Column("Id", Integer, primary_key=True, index=True)
+    description = Column("Price", String(100), nullable=False)
+    enabled = Column("enabled", Boolean, nullable=False, default=True)
 
 class RentalPrice(Base):
-    __tablename__ = "RentalPrices"
+    __tablename__ = "RentalPrice"
     
-    rental_price_id = Column("RentalPriceID", Integer, primary_key=True, index=True)
-    price_name = Column("PriceName", String(100), nullable=False)
-    price_value = Column("PriceValue", String(50), nullable=False)
-    effective_date = Column("EffectiveDate", DateTime, nullable=True)
-    is_active = Column("IsActive", Boolean, nullable=False, default=True)
-
+    rental_price_id = Column("Id", Integer, primary_key=True, index=True)
+    description = Column("Price", String(100), nullable=False)
+    enabled = Column("Enabled", Boolean, nullable=False, default=True)
+ 
 class BarrierSize(Base):
     __tablename__ = "BarrierSizes"
     
-    barrier_size_id = Column("BarrierSizeID", Integer, primary_key=True, index=True)
-    size_name = Column("SizeName", String(100), nullable=False)
-    length = Column("Length", String(20), nullable=True)
-    height = Column("Height", String(20), nullable=True)
-    description = Column("Description", String(255), nullable=True)
-    is_active = Column("IsActive", Boolean, nullable=False, default=True)
+    barrier_size_id = Column("Id", Integer, primary_key=True, index=True)
+    length = Column("Lenght", Numeric(precision=18, scale=2), nullable=True)
+    height = Column("Height", Numeric(precision=18, scale=2), nullable=True)
+    width = Column("Width", Numeric(precision=18, scale=2), nullable=True)
+    cableunits = Column("CableUnits", Numeric(precision=18, scale=2), nullable=True)
+    price = Column("Price", Numeric(precision=19, scale=4), nullable=False)
+    is_standard = Column("IsStandard", Boolean, nullable=False, default=True)
 
 class ProductApplication(Base):
     __tablename__ = "ProductApplications"
     
-    application_id = Column("ApplicationID", Integer, primary_key=True, index=True)
-    application_name = Column("ApplicationName", String(100), nullable=False)
+    application_id = Column("ProductApplicationID", Integer, primary_key=True, index=True)
+    customer_type_id = Column("CustomerTypeID", String(100), nullable=False)
     description = Column("Description", Text, nullable=True)
-    is_active = Column("IsActive", Boolean, nullable=False, default=True)
+    enabled = Column("Enabled", Boolean, nullable=False, default=True)
 
-class CustomerStatus(Base):
-    __tablename__ = "CustomerStatuses"
-    
-    status_id = Column("StatusID", Integer, primary_key=True, index=True)
-    status_name = Column("StatusName", String(50), nullable=False)
-    description = Column("Description", String(255), nullable=True)
-    is_active = Column("IsActive", Boolean, nullable=False, default=True)
+ 
 
 class ProjectStatus(Base):
     __tablename__ = "ProjectStatuses"
@@ -95,4 +104,23 @@ class ProjectStatus(Base):
     status_name = Column("StatusName", String(50), nullable=False)
     description = Column("Description", String(255), nullable=True)
     color_code = Column("ColorCode", String(7), nullable=True)  # For UI display
-    is_active = Column("IsActive", Boolean, nullable=False, default=True)
+    is_active = Column("IsActive", Boolean, nullable=False, default=True)
+
+
+class FOB(Base):
+    __tablename__ = "FOB"
+
+    # DB table uses Id and FobDescription (per DB schema)
+    fob_id = Column("Id", Integer, primary_key=True, index=True)
+    fob_description = Column("FobDescription", String(255), nullable=True)
+    # Some reference tables include Enabled/IsActive; include optional mapping
+    enabled = Column("Enabled", Boolean, nullable=True)
+
+
+class EstFreight(Base):
+    __tablename__ = "EstFreight"
+
+    # DB table uses Id and EstFreightDescription
+    est_freight_id = Column("Id", Integer, primary_key=True, index=True)
+    est_freight_description = Column("EstFreightDescription", String(255), nullable=True)
+  

app/db/repositories/bidder_repo.py

@@ -64,19 +64,15 @@ class BidderRepository:
         try:
             # Handle string or integer proj_no values
             # Try both the original value and converted value to handle both cases
-            original_proj_no = proj_no
-            
+             
             # Try to handle numeric project numbers stored in database as int or string
             try:
-                numeric_proj_no = int(proj_no)
-                query = self.db.query(Bidder).filter(
-                    (Bidder.ProjNo == original_proj_no) | 
-                    (Bidder.ProjNo == str(numeric_proj_no)) |
-                    (Bidder.ProjNo == numeric_proj_no)
+                 query = self.db.query(Bidder).filter(
+                    (Bidder.ProjNo ==  proj_no)  
                 )
             except (ValueError, TypeError):
                 # If conversion to int fails, just use the original string
-                query = self.db.query(Bidder).filter(Bidder.ProjNo == original_proj_no)
+                query = self.db.query(Bidder).filter(Bidder.ProjNo == str(proj_no))
             # Validate order_by field
             if not hasattr(Bidder, order_by):
                 order_by = "Id"

app/db/repositories/reference_repo.py

@@ -2,8 +2,7 @@ from sqlalchemy.orm import Session
 from sqlalchemy import text
 from app.db.models.reference import (
     State, Country, CompanyType, LeadGeneratedFrom, PaymentTerm,
-    PurchasePrice, RentalPrice, BarrierSize, ProductApplication,
-    CustomerStatus, ProjectStatus
+    PurchasePrice, RentalPrice, BarrierSize, ProductApplication, ProjectStatus
 )
 from typing import List, Dict, Any, Optional, Type, Union
 from app.core.exceptions import RepositoryException
@@ -32,7 +31,6 @@ class ReferenceDataRepository:
         'rental_prices': RentalPrice,
         'barrier_sizes': BarrierSize,
         'product_applications': ProductApplication,
-        'customer_statuses': CustomerStatus,
         'project_statuses': ProjectStatus
     }
 
@@ -43,9 +41,24 @@ class ReferenceDataRepository:
             return self._cache[cache_key]
             
         try:
-            # Try stored procedure first with required OrderBy parameter
-            sp_query = text("EXEC spStatesGetList @OrderBy = 'Description'")
-            result = self.db.execute(sp_query)
+            # Try stored procedure first with required OrderBy parameter using SQLAlchemy parameterized text
+            sp_query = text("""
+            DECLARE @TotalRecords INT;
+            EXEC dbo.spStatesGetList
+                @OrderBy = :order_by,
+                @OrderDirection = :order_dir,
+                @Page = :page,
+                @PageSize = :page_size,
+                @TotalRecords = @TotalRecords OUTPUT;
+            SELECT @TotalRecords AS TotalRecords;
+            """)
+            params = {
+                "order_by": "Description",
+                "order_dir": "ASC",
+                "page": 1,
+                "page_size": 1000,
+            }
+            result = self.db.execute(sp_query, params)
             
             if result.returns_rows:
                 # Map the stored procedure results to our expected schema
@@ -55,9 +68,8 @@ class ReferenceDataRepository:
                     # Map SP output to our API format
                     state_data = {
                         'state_id': row_dict.get('StateID', None),
-                        'state_name': row_dict.get('Description', None),  # Use Description as state_name
-                        'CustomerTypeID': None,  # No state code in DB
-                        'Enabled': None      # No country in DB
+                        'country_name': row_dict.get('Description', None),
+                        'is_active': row_dict.get('IsActive', True)
                     }
                     states_data.append(state_data)
                     
@@ -68,7 +80,7 @@ class ReferenceDataRepository:
         except Exception as e:
             logger.warning(f"Stored procedure failed, using fallback: {e}", exc_info=True)
             
-        
+        return []
 
     def get_countries(self, active_only: bool = True) -> List[Dict[str, Any]]:
         """Get all countries"""
@@ -77,43 +89,45 @@ class ReferenceDataRepository:
             return self._cache[cache_key]
             
         try:
-            # Try stored procedure first with required OrderBy parameter
-            sp_query = text("EXEC spCountriesGetList @OrderBy = 'CountryName'")
-            result = self.db.execute(sp_query)
+            sp_query = text("""
+            DECLARE @TotalRecords INT;
+            EXEC dbo.spCountriesGetList
+                @OrderBy = :order_by,
+                @OrderDirection = :order_dir,
+                @Page = :page,
+                @PageSize = :page_size,
+                @TotalRecords = @TotalRecords OUTPUT;
+            SELECT @TotalRecords AS TotalRecords;
+            """)
+            params = {
+                "order_by": "Description",
+                "order_dir": "ASC",
+                "page": 1,
+                "page_size": 1000,
+            }
+            result = self.db.execute(sp_query, params)
             
             if result.returns_rows:
-                countries_data = [dict(row._mapping) for row in result.fetchall()]
-                # Only filter by IsActive if the column exists in the results
-                if active_only and any('IsActive' in c for c in countries_data):
-                    countries_data = [c for c in countries_data if c.get('IsActive', True)]
+                countries_data = []
+                for row in result.fetchall():
+                    row_dict = dict(row._mapping)
+                    country_data = {
+                        'country_id': row_dict.get('CountryID', None),
+                        'country_name': row_dict.get('Description', None),
+                        'is_active': row_dict.get('IsActive', True)
+                    }
+                    countries_data.append(country_data)
+                if active_only:
+                    countries_data = [c for c in countries_data if c.get('is_active', True)]
                 self._cache[cache_key] = countries_data
                 logger.info(f"Retrieved {len(countries_data)} countries via stored procedure")
                 return countries_data
                 
         except Exception as e:
-            logger.warning(f"Stored procedure failed, using fallback: {e}")
-            
-        # Fallback to direct query
-        query = self.db.query(Country)
-        # Only apply active filter if we know the column exists
-        # Skip active_only filtering since it seems the column might not exist in the DB
-        
-        countries = query.all()
-        countries_data = [
-            {
-                'country_id': country.country_id,
-                'country_name': country.country_name,
-                'country_code': country.country_code,
-                # Skip is_active in the response if we can't reliably get it
-                # 'is_active': getattr(country, 'is_active', True)  # Default to True if attribute doesn't exist
-            }
-            for country in countries
-        ]
-        
-        self._cache[cache_key] = countries_data
-        logger.info(f"Retrieved {len(countries_data)} countries via direct query")
-        return countries_data
+            logger.warning(f"Stored procedure failed, using fallback: {e}", exc_info=True)
 
+        return []
+        
     def get_company_types(self, active_only: bool = True) -> List[Dict[str, Any]]:
         """Get all company types"""
         cache_key = f"company_types_{active_only}"
@@ -122,15 +136,18 @@ class ReferenceDataRepository:
             
         query = self.db.query(CompanyType)
         if active_only:
-            query = query.filter(CompanyType.is_active == True)
+            # The CompanyType model maps the DB "Enabled" column to attribute `enabled`
+            query = query.filter(CompanyType.enabled == True)
         
         company_types = query.all()
         company_types_data = [
             {
                 'company_type_id': ct.company_type_id,
-                'company_type_name': ct.company_type_name,
+                # The DB uses Description for the readable name; expose it as company_type_name
+                'company_type_name': ct.description,
                 'description': ct.description,
-                'is_active': ct.is_active
+                # Map enabled -> is_active for API consumers
+                'is_active': ct.enabled
             }
             for ct in company_types
         ]
@@ -147,15 +164,17 @@ class ReferenceDataRepository:
             
         query = self.db.query(LeadGeneratedFrom)
         if active_only:
-            query = query.filter(LeadGeneratedFrom.is_active == True)
+            query = query.filter(LeadGeneratedFrom.enabled == True)
         
         lead_sources = query.all()
         lead_sources_data = [
             {
                 'lead_generated_from_id': ls.lead_generated_from_id,
-                'source_name': ls.source_name,
+                # source_name may be stored in a DB column that can contain numeric codes;
+                # coerce to string so API consistently returns a string for frontend dropdowns
+                'source_name': str(ls.source_name) if ls.source_name is not None else None,
                 'description': ls.description,
-                'is_active': ls.is_active
+                'is_active': ls.enabled
             }
             for ls in lead_sources
         ]
@@ -172,16 +191,14 @@ class ReferenceDataRepository:
             
         query = self.db.query(PaymentTerm)
         if active_only:
-            query = query.filter(PaymentTerm.is_active == True)
+            query = query.filter(PaymentTerm.enabled == True)
         
         payment_terms = query.all()
         payment_terms_data = [
             {
                 'payment_term_id': pt.payment_term_id,
-                'term_name': pt.term_name,
-                'days': pt.days,
                 'description': pt.description,
-                'is_active': pt.is_active
+                'is_active': pt.enabled
             }
             for pt in payment_terms
         ]
@@ -198,16 +215,15 @@ class ReferenceDataRepository:
             
         query = self.db.query(PurchasePrice)
         if active_only:
-            query = query.filter(PurchasePrice.is_active == True)
+            query = query.filter(PurchasePrice.enabled == True)
         
         purchase_prices = query.all()
         purchase_prices_data = [
             {
                 'purchase_price_id': pp.purchase_price_id,
-                'price_name': pp.price_name,
-                'price_value': pp.price_value,
-                'effective_date': pp.effective_date,
-                'is_active': pp.is_active
+                # expose price under 'price' to match PurchasePriceOut schema
+                'price': pp.description,
+                'enabled': pp.enabled
             }
             for pp in purchase_prices
         ]
@@ -224,16 +240,15 @@ class ReferenceDataRepository:
             
         query = self.db.query(RentalPrice)
         if active_only:
-            query = query.filter(RentalPrice.is_active == True)
+            query = query.filter(RentalPrice.enabled == True)
         
         rental_prices = query.all()
         rental_prices_data = [
             {
                 'rental_price_id': rp.rental_price_id,
-                'price_name': rp.price_name,
-                'price_value': rp.price_value,
-                'effective_date': rp.effective_date,
-                'is_active': rp.is_active
+                # expose price under 'price' to match RentalPriceOut schema
+                'price': rp.description,
+                'enabled': rp.enabled
             }
             for rp in rental_prices
         ]
@@ -242,25 +257,27 @@ class ReferenceDataRepository:
         logger.info(f"Retrieved {len(rental_prices_data)} rental prices")
         return rental_prices_data
 
-    def get_barrier_sizes(self, active_only: bool = True) -> List[Dict[str, Any]]:
+    def get_barrier_sizes(self, standard_only: bool = True) -> List[Dict[str, Any]]:
         """Get all barrier sizes"""
-        cache_key = f"barrier_sizes_{active_only}"
+        cache_key = f"barrier_sizes_{standard_only}"
         if cache_key in self._cache:
             return self._cache[cache_key]
             
         query = self.db.query(BarrierSize)
-        if active_only:
-            query = query.filter(BarrierSize.is_active == True)
-        
+
+        if standard_only:
+            query = query.filter(BarrierSize.is_standard == True)
+         
         barrier_sizes = query.all()
         barrier_sizes_data = [
             {
                 'barrier_size_id': bs.barrier_size_id,
-                'size_name': bs.size_name,
                 'length': bs.length,
                 'height': bs.height,
-                'description': bs.description,
-                'is_active': bs.is_active
+                'width': bs.width,
+                'cableunits': bs.cableunits,
+                'price': bs.price,
+                'is_standard': bs.is_standard
             }
             for bs in barrier_sizes
         ]
@@ -277,47 +294,124 @@ class ReferenceDataRepository:
             
         query = self.db.query(ProductApplication)
         if active_only:
-            query = query.filter(ProductApplication.is_active == True)
+            query = query.filter(ProductApplication.enabled == True)
         
         product_applications = query.all()
         product_applications_data = [
             {
                 'application_id': pa.application_id,
-                'application_name': pa.application_name,
+                # customer_type_id may be stored as codes or numbers; expose as string for API
+                'customer_type_id': str(pa.customer_type_id) if pa.customer_type_id is not None else None,
                 'description': pa.description,
-                'is_active': pa.is_active
+                'enabled': pa.enabled
             }
             for pa in product_applications
         ]
-        
+
         self._cache[cache_key] = product_applications_data
         logger.info(f"Retrieved {len(product_applications_data)} product applications")
         return product_applications_data
 
-    def get_customer_statuses(self, active_only: bool = True) -> List[Dict[str, Any]]:
-        """Get all customer statuses"""
-        cache_key = f"customer_statuses_{active_only}"
+
+    def get_fobs(self, active_only: bool = True) -> List[Dict[str, Any]]:
+        """Get all FOB (Free On Board) terms"""
+        cache_key = f"fobs_{active_only}"
         if cache_key in self._cache:
             return self._cache[cache_key]
-            
-        query = self.db.query(CustomerStatus)
-        if active_only:
-            query = query.filter(CustomerStatus.is_active == True)
-        
-        customer_statuses = query.all()
-        customer_statuses_data = [
-            {
-                'status_id': cs.status_id,
-                'status_name': cs.status_name,
-                'description': cs.description,
-                'is_active': cs.is_active
-            }
-            for cs in customer_statuses
-        ]
-        
-        self._cache[cache_key] = customer_statuses_data
-        logger.info(f"Retrieved {len(customer_statuses_data)} customer statuses")
-        return customer_statuses_data
+
+        # FOB table is small; query directly
+        try:
+            from app.db.models.reference import FOB
+            query = self.db.query(FOB)
+            if active_only and hasattr(FOB, 'enabled'):
+                query = query.filter(FOB.enabled == True)
+
+            fobs = query.all()
+            fobs_data = [
+                {
+                    'fob_id': f.fob_id,
+                    'fob_description': f.fob_description,
+                    'enabled': getattr(f, 'enabled', None)
+                }
+                for f in fobs
+            ]
+
+            if active_only:
+                fobs_data = [f for f in fobs_data if f.get('enabled', True) is not False]
+
+            self._cache[cache_key] = fobs_data
+            logger.info(f"Retrieved {len(fobs_data)} fobs")
+            return fobs_data
+        except Exception as e:
+            logger.warning(f"Failed to query FOB table: {e}", exc_info=True)
+            return []
+
+
+    def get_est_ship_dates(self, active_only: bool = True) -> List[Dict[str, Any]]:
+        """Get all estimated ship-date options"""
+        cache_key = f"est_ship_dates_{active_only}"
+        if cache_key in self._cache:
+            return self._cache[cache_key]
+
+        try:
+            from app.db.models.reference import EstShipDate
+            query = self.db.query(EstShipDate)
+            if active_only and hasattr(EstShipDate, 'enabled'):
+                query = query.filter(EstShipDate.enabled == True)
+
+            rows = query.all()
+            data = [
+                {
+                    'est_ship_date_id': r.est_ship_date_id,
+                    'est_ship_date_description': r.est_ship_date_description,
+                    'enabled': getattr(r, 'enabled', None)
+                }
+                for r in rows
+            ]
+
+            if active_only:
+                data = [d for d in data if d.get('enabled', True) is not False]
+
+            self._cache[cache_key] = data
+            logger.info(f"Retrieved {len(data)} est ship dates")
+            return data
+        except Exception as e:
+            logger.warning(f"Failed to query EstShipDate table: {e}", exc_info=True)
+            return []
+
+
+    def get_est_freights(self, active_only: bool = True) -> List[Dict[str, Any]]:
+        """Get all estimated freight options"""
+        cache_key = f"est_freights_{active_only}"
+        if cache_key in self._cache:
+            return self._cache[cache_key]
+
+        try:
+            from app.db.models.reference import EstFreight
+            query = self.db.query(EstFreight)
+            if active_only and hasattr(EstFreight, 'enabled'):
+                query = query.filter(EstFreight.enabled == True)
+
+            rows = query.all()
+            data = [
+                {
+                    'est_freight_id': r.est_freight_id,
+                    'est_freight_description': r.est_freight_description,
+                    'enabled': getattr(r, 'enabled', None)
+                }
+                for r in rows
+            ]
+
+            if active_only:
+                data = [d for d in data if d.get('enabled', True) is not False]
+
+            self._cache[cache_key] = data
+            logger.info(f"Retrieved {len(data)} est freights")
+            return data
+        except Exception as e:
+            logger.warning(f"Failed to query EstFreight table: {e}", exc_info=True)
+            return []
+ 
 
     def get_project_statuses(self, active_only: bool = True) -> List[Dict[str, Any]]:
         """Get all project statuses"""
@@ -357,10 +451,44 @@ class ReferenceDataRepository:
             'rental_prices': self.get_rental_prices(active_only),
             'barrier_sizes': self.get_barrier_sizes(active_only),
             'product_applications': self.get_product_applications(active_only),
-            'customer_statuses': self.get_customer_statuses(active_only),
-            'project_statuses': self.get_project_statuses(active_only)
+            'fobs': self.get_fobs(active_only),
+            'est_ship_dates': self.get_est_ship_dates(active_only),
+            'est_freights': self.get_est_freights(active_only),
         }
 
+    def get_status_info(self, active_only: bool = True) -> List[Dict[str, Any]]:
+        """Get all StatusInfo records"""
+        cache_key = f"status_info_{active_only}"
+        if cache_key in self._cache:
+            return self._cache[cache_key]
+
+        try:
+            from app.db.models.reference import StatusInfo
+            query = self.db.query(StatusInfo)
+            if active_only and hasattr(StatusInfo, 'enabled'):
+                query = query.filter(StatusInfo.enabled == True)
+
+            rows = query.all()
+            data = [
+                {
+                    'status_info_id': r.status_info_id,
+                    'description': r.description,
+                    'abrv': r.abrv,
+                    'enabled': getattr(r, 'enabled', None)
+                }
+                for r in rows
+            ]
+
+            if active_only:
+                data = [d for d in data if d.get('enabled', True) is not False]
+
+            self._cache[cache_key] = data
+            logger.info(f"Retrieved {len(data)} status info records")
+            return data
+        except Exception as e:
+            logger.warning(f"Failed to query StatusInfo table: {e}", exc_info=True)
+            return []
+
     def clear_cache(self):
         """Clear the internal cache to force fresh data on next request"""
         self._cache.clear()

app/schemas/reference.py

@@ -1,78 +1,102 @@
 from pydantic import BaseModel, Field
-from typing import Optional, Dict, List, Any
+from typing import Optional, List
 from datetime import datetime
+from decimal import Decimal
+
 
 class StateOut(BaseModel):
     state_id: int = Field(..., description="State ID")
-    state_name: Optional[str] = Field(None, description="State name (from Description field)")
-    state_code: Optional[str] = Field(None, description="State code")
-    country: Optional[str] = Field(None, description="Country")
+    customer_type_id: Optional[int] = Field(None, description="Customer type ID")
+    description: Optional[str] = Field(None, description="Description / state name")
+    enabled: Optional[bool] = Field(None, description="Enabled flag")
+
 
 class CountryOut(BaseModel):
     country_id: int = Field(..., description="Country ID")
-    country_name: str = Field(..., description="Country name")
-    country_code: Optional[str] = Field(None, description="Country code")
-    is_active: bool = Field(..., description="Active status")
+    customer_type_id: Optional[int] = Field(None, description="Customer type ID")
+    description: Optional[str] = Field(None, description="Description / country name")
+    enabled: Optional[bool] = Field(None, description="Enabled flag")
+
 
 class CompanyTypeOut(BaseModel):
     company_type_id: int = Field(..., description="Company type ID")
-    company_type_name: str = Field(..., description="Company type name")
+    customer_type_id: Optional[int] = Field(None, description="Customer type ID")
     description: Optional[str] = Field(None, description="Description")
-    is_active: bool = Field(..., description="Active status")
+    inactive: Optional[bool] = Field(None, description="Inactive flag (model uses column 'Inactive')")
+
 
 class LeadSourceOut(BaseModel):
     lead_generated_from_id: int = Field(..., description="Lead source ID")
     source_name: str = Field(..., description="Source name")
     description: Optional[str] = Field(None, description="Description")
-    is_active: bool = Field(..., description="Active status")
+    enabled: Optional[bool] = Field(True, description="Enabled flag")
+
 
 class PaymentTermOut(BaseModel):
     payment_term_id: int = Field(..., description="Payment term ID")
-    term_name: str = Field(..., description="Term name")
-    days: int = Field(..., description="Number of days")
-    description: Optional[str] = Field(None, description="Description")
-    is_active: bool = Field(..., description="Active status")
+    description: str = Field(..., description="Payment description / term name")
+    enabled: Optional[bool] = Field(True, description="Enabled flag")
+
 
 class PurchasePriceOut(BaseModel):
     purchase_price_id: int = Field(..., description="Purchase price ID")
-    price_name: str = Field(..., description="Price name")
-    price_value: str = Field(..., description="Price value")
-    effective_date: Optional[datetime] = Field(None, description="Effective date")
-    is_active: bool = Field(..., description="Active status")
+    price: str = Field(..., description="Price value or description")
+    enabled: Optional[bool] = Field(True, description="Enabled flag")
+
 
 class RentalPriceOut(BaseModel):
     rental_price_id: int = Field(..., description="Rental price ID")
-    price_name: str = Field(..., description="Price name")
-    price_value: str = Field(..., description="Price value")
-    effective_date: Optional[datetime] = Field(None, description="Effective date")
-    is_active: bool = Field(..., description="Active status")
+    price: str = Field(..., description="Price value or description")
+    enabled: Optional[bool] = Field(True, description="Enabled flag")
+
 
 class BarrierSizeOut(BaseModel):
     barrier_size_id: int = Field(..., description="Barrier size ID")
-    size_name: str = Field(..., description="Size name")
-    length: Optional[str] = Field(None, description="Length")
-    height: Optional[str] = Field(None, description="Height")
-    description: Optional[str] = Field(None, description="Description")
-    is_active: bool = Field(..., description="Active status")
+    length: Optional[Decimal] = Field(None, description="Length (numeric)")
+    height: Optional[Decimal] = Field(None, description="Height (numeric)")
+    width: Optional[Decimal] = Field(None, description="Width (numeric)")
+    cableunits: Optional[Decimal] = Field(None, description="Cable units (numeric)")
+    price: Optional[Decimal] = Field(None, description="Price (numeric)")
+    is_standard: Optional[bool] = Field(True, description="Is standard flag")
+
 
 class ProductApplicationOut(BaseModel):
     application_id: int = Field(..., description="Application ID")
-    application_name: str = Field(..., description="Application name")
+    customer_type_id: str = Field(..., description="Customer type ID / code")
     description: Optional[str] = Field(None, description="Description")
-    is_active: bool = Field(..., description="Active status")
+    enabled: Optional[bool] = Field(True, description="Enabled flag")
 
-class CustomerStatusOut(BaseModel):
-    status_id: int = Field(..., description="Status ID")
-    status_name: str = Field(..., description="Status name")
-    description: Optional[str] = Field(None, description="Description")
-    is_active: bool = Field(..., description="Active status")
 
 class ProjectStatusOut(BaseModel):
     status_id: int = Field(..., description="Status ID")
     status_name: str = Field(..., description="Status name")
     description: Optional[str] = Field(None, description="Description")
-    color_code: Optional[str] = Field(None, description="Color code for UI")
-    is_active: bool = Field(..., description="Active status")
+    color_code: Optional[str] = Field(None, description="Hex color code, e.g. #RRGGBB")
+    is_active: Optional[bool] = Field(True, description="Is active flag")
+
+
+class FOBOut(BaseModel):
+    fob_id: int = Field(..., description="FOB ID")
+    fob_description: Optional[str] = Field(None, description="FOB description / name")
+    enabled: Optional[bool] = Field(True, description="Enabled flag")
+
+
+class EstShipDateOut(BaseModel):
+    est_ship_date_id: int = Field(..., description="Estimated ship date ID")
+    est_ship_date_description: Optional[str] = Field(None, description="Estimated ship date description")
+    enabled: Optional[bool] = Field(True, description="Enabled flag")
+
+
+class EstFreightOut(BaseModel):
+    est_freight_id: int = Field(..., description="Estimated freight ID")
+    est_freight_description: Optional[str] = Field(None, description="Estimated freight description")
+    enabled: Optional[bool] = Field(True, description="Enabled flag")
+
+
+class StatusInfoOut(BaseModel):
+    status_info_id: int = Field(..., description="StatusInfo ID")
+    description: Optional[str] = Field(None, description="Status description")
+    abrv: Optional[str] = Field(None, description="Abbreviation")
 
 class ReferenceDataResponse(BaseModel):
     """Complete reference data response containing all lookup tables"""
@@ -85,5 +109,7 @@ class ReferenceDataResponse(BaseModel):
     rental_prices: List[RentalPriceOut] = Field(..., description="List of rental prices")
     barrier_sizes: List[BarrierSizeOut] = Field(..., description="List of barrier sizes")
     product_applications: List[ProductApplicationOut] = Field(..., description="List of product applications")
-    customer_statuses: List[CustomerStatusOut] = Field(..., description="List of customer statuses")
-    project_statuses: List[ProjectStatusOut] = Field(..., description="List of project statuses")
+    project_statuses: Optional[List[ProjectStatusOut]] = Field([], description="List of project statuses")
+    fobs: Optional[List[FOBOut]] = Field([], description="List of FOB (Free On Board) terms")
+    est_ship_dates: Optional[List[EstShipDateOut]] = Field([], description="List of Estimated Ship Date options")
+    est_freights: Optional[List[EstFreightOut]] = Field([], description="List of Estimated Freight options")

app/services/reference_service.py

@@ -3,7 +3,7 @@ from app.db.repositories.reference_repo import ReferenceDataRepository
 from app.schemas.reference import (
     StateOut, CountryOut, CompanyTypeOut, LeadSourceOut, PaymentTermOut,
     PurchasePriceOut, RentalPriceOut, BarrierSizeOut, ProductApplicationOut,
-    CustomerStatusOut, ProjectStatusOut, ReferenceDataResponse
+    ReferenceDataResponse
 )
 from typing import List, Dict, Any, Optional
 import logging
@@ -64,16 +64,32 @@ class ReferenceDataService:
         product_applications_data = self.repo.get_product_applications(active_only)
         return [ProductApplicationOut(**pa) for pa in product_applications_data]
 
-    def get_customer_statuses(self, active_only: bool = True) -> List[CustomerStatusOut]:
-        """Get all customer statuses as Pydantic models"""
-        customer_statuses_data = self.repo.get_customer_statuses(active_only)
-        return [CustomerStatusOut(**cs) for cs in customer_statuses_data]
-
-    def get_project_statuses(self, active_only: bool = True) -> List[ProjectStatusOut]:
-        """Get all project statuses as Pydantic models"""
-        project_statuses_data = self.repo.get_project_statuses(active_only)
-        return [ProjectStatusOut(**ps) for ps in project_statuses_data]
-
+    def get_fobs(self, active_only: bool = True):
+        """Get all FOBs as Pydantic models"""
+        fobs_data = self.repo.get_fobs(active_only)
+        # Import here to avoid circular import at module load time
+        from app.schemas.reference import FOBOut
+        return [FOBOut(**f) for f in fobs_data]
+
+    def get_est_ship_dates(self, active_only: bool = True):
+        """Get all estimated ship-date options as Pydantic models"""
+        est_data = self.repo.get_est_ship_dates(active_only)
+        from app.schemas.reference import EstShipDateOut
+        return [EstShipDateOut(**e) for e in est_data]
+
+    def get_est_freights(self, active_only: bool = True):
+        """Get all estimated freight options as Pydantic models"""
+        est_data = self.repo.get_est_freights(active_only)
+        from app.schemas.reference import EstFreightOut
+        return [EstFreightOut(**e) for e in est_data]
+
+    def get_status_info(self, active_only: bool = True):
+        """Get all StatusInfo records as Pydantic models"""
+        data = self.repo.get_status_info(active_only)
+        from app.schemas.reference import StatusInfoOut
+        return [StatusInfoOut(**d) for d in data]
+
+ 
     def get_all_reference_data(self, active_only: bool = True) -> ReferenceDataResponse:
         """
         Get all reference data in a single response for efficiency.
@@ -84,20 +100,45 @@ class ReferenceDataService:
             # Get all data from repository
             all_data = self.repo.get_all_reference_data(active_only)
             
-            # Transform to Pydantic models
-            return ReferenceDataResponse(
-                states=[StateOut(**state) for state in all_data['states']],
-                countries=[CountryOut(**country) for country in all_data['countries']],
-                company_types=[CompanyTypeOut(**ct) for ct in all_data['company_types']],
-                lead_sources=[LeadSourceOut(**ls) for ls in all_data['lead_sources']],
-                payment_terms=[PaymentTermOut(**pt) for pt in all_data['payment_terms']],
-                purchase_prices=[PurchasePriceOut(**pp) for pp in all_data['purchase_prices']],
-                rental_prices=[RentalPriceOut(**rp) for rp in all_data['rental_prices']],
-                barrier_sizes=[BarrierSizeOut(**bs) for bs in all_data['barrier_sizes']],
-                product_applications=[ProductApplicationOut(**pa) for pa in all_data['product_applications']],
-                customer_statuses=[CustomerStatusOut(**cs) for cs in all_data['customer_statuses']],
-                project_statuses=[ProjectStatusOut(**ps) for ps in all_data['project_statuses']]
-            )
+            # Transform to Pydantic models using keys provided by the repository.
+            # The repository returns a dict with a subset of keys; map only those.
+            response_kwargs = {}
+            if 'states' in all_data:
+                response_kwargs['states'] = [StateOut(**state) for state in all_data['states']]
+            if 'countries' in all_data:
+                response_kwargs['countries'] = [CountryOut(**country) for country in all_data['countries']]
+            if 'company_types' in all_data:
+                response_kwargs['company_types'] = [CompanyTypeOut(**ct) for ct in all_data['company_types']]
+            if 'lead_sources' in all_data:
+                response_kwargs['lead_sources'] = [LeadSourceOut(**ls) for ls in all_data['lead_sources']]
+            if 'payment_terms' in all_data:
+                response_kwargs['payment_terms'] = [PaymentTermOut(**pt) for pt in all_data['payment_terms']]
+            if 'purchase_prices' in all_data:
+                response_kwargs['purchase_prices'] = [PurchasePriceOut(**pp) for pp in all_data['purchase_prices']]
+            if 'rental_prices' in all_data:
+                response_kwargs['rental_prices'] = [RentalPriceOut(**rp) for rp in all_data['rental_prices']]
+            if 'barrier_sizes' in all_data:
+                response_kwargs['barrier_sizes'] = [BarrierSizeOut(**bs) for bs in all_data['barrier_sizes']]
+            if 'product_applications' in all_data:
+                response_kwargs['product_applications'] = [ProductApplicationOut(**pa) for pa in all_data['product_applications']]
+            if 'fobs' in all_data:
+                from app.schemas.reference import FOBOut
+                response_kwargs['fobs'] = [FOBOut(**fb) for fb in all_data['fobs']]
+            if 'est_ship_dates' in all_data:
+                from app.schemas.reference import EstShipDateOut
+                response_kwargs['est_ship_dates'] = [EstShipDateOut(**ed) for ed in all_data['est_ship_dates']]
+            if 'est_freights' in all_data:
+                from app.schemas.reference import EstFreightOut
+                response_kwargs['est_freights'] = [EstFreightOut(**ef) for ef in all_data['est_freights']]
+            if 'status_info' in all_data:
+                from app.schemas.reference import StatusInfoOut
+                response_kwargs['status_info'] = [StatusInfoOut(**si) for si in all_data['status_info']]
+            # project_statuses and other optional tables may be added by the repo later
+            if 'project_statuses' in all_data:
+                from app.schemas.reference import ProjectStatusOut
+                response_kwargs['project_statuses'] = [ProjectStatusOut(**ps) for ps in all_data['project_statuses']]
+
+            return ReferenceDataResponse(**response_kwargs)
         except Exception as e:
             logger.error(f"Error retrieving all reference data: {e}")
             raise

tools/README_FIND_DYNAMIC_SQL.md

@@ -0,0 +1,34 @@
+Find dynamic SQL in stored procedures
+
+Files
+- find_dynamic_sql_procs.sql: parameterized T-SQL scanner. Use in SSMS, Azure Data Studio, or sqlcmd.
+- find_dynamic_sql_procs.py: small CLI wrapper that runs the SQL and emits CSV.
+
+Quick examples
+
+1) Run the SQL directly (Azure Data Studio/SSMS):
+
+   -- edit variables at top of file or use client substitution
+   :setvar TopN 200
+   :setvar ContextChars 120
+
+   -- open and run the file
+
+2) Run via python wrapper (recommended for automation):
+
+```bash
+python tools/find_dynamic_sql_procs.py --server demo.azonix.in --database hs-prod3 --uid myuser --pwd "mypassword" --top 200 > dynamic_procs.csv
+```
+
+Notes & limitations
+- The scanner uses simple LIKE patterns to detect likely dynamic SQL usage (sp_executesql, EXEC(@var), string concatenation).
+- It prioritizes precision via a small confidence score but will miss obfuscated dynamic SQL and may return false positives from comments or similar tokens.
+- Combine the output with manual inspection of `definition` for highest accuracy.
+- The Python wrapper requires `pyodbc` and an appropriate ODBC driver (e.g. ODBC Driver 17/18 for SQL Server).
+
+Security
+- Avoid putting credentials in shell history. Prefer using a secure credential store or trusted connections.
+
+Next steps (optional)
+- Add a mode to export full proc definitions to files.
+- Add a deeper parser using tSQLt or ANTLR for T-SQL to more accurately detect dynamic SQL boundaries.

tools/find_dynamic_sql_procs.py

@@ -0,0 +1,51 @@
+"""tools/find_dynamic_sql_procs.py
+Simple CLI wrapper that runs the T-SQL scanner against a SQL Server database using pyodbc.
+Usage:
+  python tools/find_dynamic_sql_procs.py --server demo.azonix.in --database hs-prod3 --uid user --pwd pass
+
+It prints a CSV to stdout with basic columns and confidence score.
+
+Notes:
+ - Requires pyodbc installed in your environment.
+ - Use Windows authentication by omitting uid/pwd and passing --trusted.
+"""
+import argparse
+import csv
+import sys
+import pyodbc
+
+import os
+
+SQL_PATH = os.path.join(os.path.dirname(__file__), 'find_dynamic_sql_procs.sql')
+SQL_TEMPLATE = open(SQL_PATH, 'r', encoding='utf-8').read()
+
+def run_scan(conn_str, top=1000):
+    sql = SQL_TEMPLATE.replace('TOP(@Top)', f'TOP({top})') if 'TOP(@Top)' in SQL_TEMPLATE else SQL_TEMPLATE
+    with pyodbc.connect(conn_str, autocommit=True) as cn:
+        cur = cn.cursor()
+        cur.execute(sql)
+        cols = [c[0] for c in cur.description]
+        writer = csv.writer(sys.stdout)
+        writer.writerow(cols)
+        for row in cur:
+            writer.writerow(row)
+
+
+if __name__ == '__main__':
+    ap = argparse.ArgumentParser(description='Find procs using dynamic SQL patterns')
+    ap.add_argument('--server', required=True)
+    ap.add_argument('--database', required=True)
+    ap.add_argument('--uid')
+    ap.add_argument('--pwd')
+    ap.add_argument('--trusted', action='store_true')
+    ap.add_argument('--top', type=int, default=1000)
+    args = ap.parse_args()
+
+    if args.trusted:
+        conn = f'DRIVER={{ODBC Driver 17 for SQL Server}};SERVER={args.server};DATABASE={args.database};Trusted_Connection=yes;'
+    else:
+        if not args.uid or not args.pwd:
+            ap.error('Either --trusted or both --uid and --pwd are required')
+        conn = f'DRIVER={{ODBC Driver 17 for SQL Server}};SERVER={args.server};DATABASE={args.database};UID={args.uid};PWD={args.pwd};'
+
+    run_scan(conn, top=args.top)

tools/find_dynamic_sql_procs.sql

@@ -0,0 +1,45 @@
+-- tools/find_dynamic_sql_procs.sql
+-- Parameterized T-SQL to scan all stored procedure sources for dynamic-SQL patterns.
+-- Usage:
+--   :setvar SearchPattern "sp_executesql|EXEC\s*\(|EXEC\s+@|\+\s*'"
+--   :setvar TopN 1000
+--   :setvar ContextChars 120
+-- Run in SSMS, Azure Data Studio or sqlcmd (sqlcmd: use -v to pass variables).
+
+SET NOCOUNT ON;
+
+-- variables via sqlcmd or client substitution
+DECLARE @SearchPattern NVARCHAR(400) = 'sp_executesql|EXEC\s*\(|EXEC\s+@|\+\s*\''; -- regex-like tokens (plain LIKE uses %)
+DECLARE @Top INT = 1000;
+DECLARE @Context INT = 120; -- characters of surrounding context
+
+-- We use simple LIKE checks plus more specific patterns to score confidence.
+
+SELECT TOP(@Top)
+    s.name AS schema_name,
+    p.name AS proc_name,
+    p.create_date,
+    p.modify_date,
+    m.definition,
+    -- basic token flags
+    CASE WHEN m.definition LIKE '%sp_executesql%' THEN 1 ELSE 0 END AS has_sp_executesql,
+    CASE WHEN m.definition LIKE '%EXEC %(%' ESCAPE '\' THEN 1 ELSE 0 END AS has_exec_parenthesis,
+    CASE WHEN m.definition LIKE '%EXEC @%' THEN 1 ELSE 0 END AS has_exec_variable,
+    CASE WHEN m.definition LIKE '%''+%''%' ESCAPE '\' OR m.definition LIKE '%'' + %' ESCAPE '\' THEN 1 ELSE 0 END AS has_string_concat,
+    -- rough confidence score
+    (CASE WHEN m.definition LIKE '%sp_executesql%' THEN 3 ELSE 0 END
+     + CASE WHEN m.definition LIKE '%EXEC %(%' ESCAPE '\' THEN 2 ELSE 0 END
+     + CASE WHEN m.definition LIKE '%EXEC @%' THEN 2 ELSE 0 END
+     + CASE WHEN m.definition LIKE '%''+%''%' ESCAPE '\' OR m.definition LIKE '%'' + %' ESCAPE '\' THEN 1 ELSE 0 END) AS confidence_score
+FROM sys.procedures p
+JOIN sys.schemas s ON p.schema_id = s.schema_id
+LEFT JOIN sys.sql_modules m ON p.object_id = m.object_id
+WHERE m.definition IS NOT NULL
+  AND (
+        m.definition LIKE '%sp_executesql%'
+     OR m.definition LIKE '%EXEC %(%' ESCAPE '\'
+     OR m.definition LIKE '%EXEC @%'
+     OR m.definition LIKE '%''+%''%' ESCAPE '\'
+     OR m.definition LIKE '%'' + %' ESCAPE '\'
+  )
+ORDER BY confidence_score DESC, s.name, p.name;