Add payroll functionalities

app.py

@@ -5,13 +5,15 @@ from functools import wraps
 from datetime import datetime, date, time, timedelta
 from sqlalchemy import text
 from user_agents import parse
-import io, os, base64, re, uuid, requests, json, qrcode, math
+import io, os, base64, re, uuid, requests, json, qrcode, math, traceback
 from PIL import Image, ImageDraw
 from math import radians, sin, cos, asin, sqrt
 from dotenv import load_dotenv
 # Import the logging handler
 from logger_handler import AppLogger, log_user_activity, log_database_operations
 
+from single_checkin_calculator import SingleCheckInCalculator
+from payroll_excel_exporter import PayrollExcelExporter
 
 # Load environment variables in .env
 load_dotenv()
@@ -465,7 +467,6 @@ def calculate_location_accuracy_enhanced(qr_address, checkin_address, checkin_la
             
     except Exception as e:
         print(f"❌ Error calculating distance: {e}")
-        import traceback
         print(f"❌ Distance calculation traceback: {traceback.format_exc()}")
         return None
 
@@ -2815,7 +2816,6 @@ def delete_qr_code(qr_id):
         logger_handler.log_database_error('qr_code_deletion', e)
         print(f"❌ ERROR in delete route: {e}")
         print(f"❌ Exception type: {type(e)}")
-        import traceback
         print(f"❌ Traceback: {traceback.format_exc()}")
         flash('Error deleting QR code. Please try again.', 'error')
         return redirect(url_for('dashboard'))
@@ -3006,7 +3006,6 @@ def qr_checkin(qr_url):
                     
         except Exception as e:
             print(f"❌ Error in location accuracy calculation: {e}")
-            import traceback
             print(f"❌ Full traceback: {traceback.format_exc()}")
         
         # ENHANCED DEBUG: Save to database with verification
@@ -3050,7 +3049,6 @@ def qr_checkin(qr_url):
             
         except Exception as e:
             print(f"❌ Database error: {e}")
-            import traceback
             print(f"❌ Full traceback: {traceback.format_exc()}")
             db.session.rollback()
             logger_handler.log_database_error('checkin_save', e)
@@ -3094,7 +3092,6 @@ def qr_checkin(qr_url):
         
     except Exception as e:
         print(f"❌ Unexpected error in check-in process: {e}")
-        import traceback
         print(f"❌ Traceback: {traceback.format_exc()}")
         
         return jsonify({
@@ -3505,7 +3502,6 @@ def attendance_report():
     except Exception as e:
         print(f"❌ Error loading attendance report: {e}")
         print(f"❌ Exception type: {type(e)}")
-        import traceback
         print(f"❌ Traceback: {traceback.format_exc()}")
         
         # Log the error
@@ -3784,7 +3780,6 @@ def export_configuration():
         
     except Exception as e:
         print(f"❌ Error in export_configuration route: {e}")
-        import traceback
         print(f"❌ Traceback: {traceback.format_exc()}")
         
         # Use your existing logger error method with correct parameters
@@ -3902,7 +3897,6 @@ def generate_excel_export():
             
     except Exception as e:
         print(f"❌ Error in generate_excel_export route: {e}")
-        import traceback
         print(f"❌ Traceback: {traceback.format_exc()}")
         
         # Use your existing logger error method with correct parameters
@@ -4077,7 +4071,6 @@ def create_excel_export(selected_columns, column_names, filters):
         
     except Exception as e:
         print(f"❌ Error creating Excel export: {e}")
-        import traceback
         print(f"❌ Traceback: {traceback.format_exc()}")
         return None
 
@@ -4276,10 +4269,384 @@ def create_excel_export_ordered(selected_columns, column_names, filters):
         
     except Exception as e:
         print(f"❌ Error creating Excel export: {e}")
-        import traceback
         print(f"❌ Traceback: {traceback.format_exc()}")
         return None
 
+@app.route('/payroll')
+@login_required
+def payroll_dashboard():
+    """Payroll dashboard for calculating and exporting working hours"""
+    try:
+        # Check if user has payroll access
+        user_role = session.get('role')
+        if user_role not in ['admin', 'payroll']:
+            logger_handler.logger.warning(f"User {session.get('username', 'unknown')} (role: {user_role}) attempted to access payroll dashboard without permissions")
+            flash('Access denied. Only administrators and payroll staff can access payroll features.', 'error')
+            return redirect(url_for('dashboard'))
+        
+        print("📊 Loading payroll dashboard")
+        
+        # Log payroll dashboard access
+        logger_handler.logger.info(f"User {session.get('username', 'unknown')} accessed payroll dashboard")
+        
+        # Get filter parameters with defaults
+        date_from = request.args.get('date_from', '')
+        date_to = request.args.get('date_to', '')
+        project_filter = request.args.get('project_filter', '')
+        include_travel_time = request.args.get('include_travel_time', 'true').lower() == 'true'
+        
+        # Set default date range if not provided (last 2 weeks)
+        if not date_from or not date_to:
+            end_date = datetime.now().date()
+            start_date = end_date - timedelta(days=13)  # 2 weeks (14 days)
+            date_from = start_date.strftime('%Y-%m-%d')
+            date_to = end_date.strftime('%Y-%m-%d')
+        
+        # Get list of projects for dropdown
+        projects = []
+        try:
+            projects = Project.query.filter_by(active_status=True).order_by(Project.name).all()
+            print(f"📊 Found {len(projects)} active projects for filter")
+        except Exception as e:
+            print(f"⚠️ Error loading projects: {e}")
+        
+        # Get attendance records for the period
+        attendance_records = []
+        working_hours_data = None
+        
+        if date_from and date_to:
+            try:
+                start_date = datetime.strptime(date_from, '%Y-%m-%d')
+                end_date = datetime.strptime(date_to, '%Y-%m-%d')
+                
+                # Query attendance records with optional project filter
+                query = db.session.query(AttendanceData).join(QRCode, AttendanceData.qr_code_id == QRCode.id)
+                
+                # Apply date filter
+                query = query.filter(
+                    AttendanceData.check_in_date >= start_date.date(),
+                    AttendanceData.check_in_date <= end_date.date()
+                )
+                
+                # Apply project filter if selected
+                if project_filter and project_filter != '':
+                    query = query.filter(QRCode.project_id == int(project_filter))
+                    print(f"📊 Applied project filter: {project_filter}")
+                
+                query = query.order_by(AttendanceData.employee_id, AttendanceData.check_in_date, AttendanceData.check_in_time)
+                
+                attendance_records = query.all()
+                print(f"📊 Found {len(attendance_records)} attendance records for payroll calculation")
+                
+                # Calculate working hours if we have records
+                if attendance_records:
+                    calculator = SingleCheckInCalculator()
+                    working_hours_data = calculator.calculate_all_employees_hours(
+                        start_date, end_date, attendance_records
+                    )
+                    print(f"📊 Calculated hours for {working_hours_data['employee_count']} employees")
+                
+            except ValueError as e:
+                print(f"⚠️ Invalid date format: {e}")
+                flash('Invalid date format. Please use YYYY-MM-DD format.', 'error')
+            except Exception as e:
+                print(f"❌ Error calculating working hours: {e}")
+                logger_handler.log_database_error('payroll_calculation', e)
+                flash('Error calculating working hours. Please check the server logs.', 'error')
+        
+        # Get employee names for display
+        employee_names = {}
+        if working_hours_data:
+            try:
+                # Try to get employee names from your employee table if it exists
+                employee_ids = list(working_hours_data['employees'].keys())
+                # This assumes you have an employee table - modify as needed
+                employee_query = db.session.execute(text("""
+                    SELECT id, CONCAT(firstName, ' ', lastName) as full_name 
+                    FROM employee 
+                    WHERE id IN :employee_ids
+                """), {'employee_ids': tuple(employee_ids)})
+                
+                for row in employee_query:
+                    employee_names[str(row[0])] = row[1]
+                    
+            except Exception as e:
+                print(f"⚠️ Could not load employee names: {e}")
+                # Continue without names - will use employee IDs
+        
+        # Get selected project name for display
+        selected_project_name = ''
+        if project_filter:
+            try:
+                selected_project = Project.query.get(int(project_filter))
+                if selected_project:
+                    selected_project_name = selected_project.name
+            except Exception as e:
+                print(f"⚠️ Error getting selected project name: {e}")
+        
+        return render_template('payroll_dashboard.html',
+                             working_hours_data=working_hours_data,
+                             employee_names=employee_names,
+                             projects=projects,
+                             date_from=date_from,
+                             date_to=date_to,
+                             project_filter=project_filter,
+                             selected_project_name=selected_project_name,
+                             include_travel_time=include_travel_time,
+                             user_role=user_role)
+        
+    except Exception as e:
+        print(f"❌ Error loading payroll dashboard: {e}")
+        import traceback
+        print(f"❌ Traceback: {traceback.format_exc()}")
+        
+        logger_handler.log_flask_error(
+            error_type="payroll_dashboard_error",
+            error_message=str(e),
+            stack_trace=traceback.format_exc()
+        )
+        
+        flash('Error loading payroll dashboard. Please check the server logs.', 'error')
+        return redirect(url_for('dashboard'))
+
+
+@app.route('/payroll/export-excel', methods=['POST'])
+@login_required
+@log_database_operations('payroll_excel_export')
+def export_payroll_excel():
+    """Export payroll report to Excel with working hours calculations"""
+    try:
+        # Check permissions
+        user_role = session.get('role')
+        if user_role not in ['admin', 'payroll']:
+            logger_handler.logger.warning(f"User {session.get('username', 'unknown')} (role: {user_role}) attempted unauthorized payroll Excel export")
+            flash('Access denied. Only administrators and payroll staff can export payroll data.', 'error')
+            return redirect(url_for('payroll_dashboard'))
+        
+        print("📊 Payroll Excel export started")
+        
+        # Get parameters from form
+        date_from = request.form.get('date_from')
+        date_to = request.form.get('date_to')
+        project_filter = request.form.get('project_filter', '')
+        include_travel_time = request.form.get('include_travel_time', 'false').lower() == 'true'
+        report_type = request.form.get('report_type', 'payroll')  # 'payroll' or 'detailed'
+        
+        if not date_from or not date_to:
+            flash('Please provide both start and end dates for the export.', 'error')
+            return redirect(url_for('payroll_dashboard'))
+        
+        try:
+            start_date = datetime.strptime(date_from, '%Y-%m-%d')
+            end_date = datetime.strptime(date_to, '%Y-%m-%d')
+        except ValueError:
+            flash('Invalid date format. Please use YYYY-MM-DD format.', 'error')
+            return redirect(url_for('payroll_dashboard'))
+        
+        # Get attendance records with project filter
+        query = db.session.query(AttendanceData).join(QRCode, AttendanceData.qr_code_id == QRCode.id)
+        
+        # Apply date filter
+        query = query.filter(
+            AttendanceData.check_in_date >= start_date.date(),
+            AttendanceData.check_in_date <= end_date.date()
+        )
+        
+        # Apply project filter if selected
+        if project_filter and project_filter != '':
+            query = query.filter(QRCode.project_id == int(project_filter))
+            print(f"📊 Applied project filter to export: {project_filter}")
+        
+        query = query.order_by(AttendanceData.employee_id, AttendanceData.check_in_date, AttendanceData.check_in_time)
+        
+        attendance_records = query.all()
+        
+        if not attendance_records:
+            flash('No attendance records found for the selected date range and project.', 'warning')
+            return redirect(url_for('payroll_dashboard'))
+        
+        print(f"📊 Exporting {len(attendance_records)} attendance records to Excel")
+        
+        # Get employee names
+        employee_names = {}
+        try:
+            employee_ids = list(set(str(record.employee_id) for record in attendance_records))
+            employee_query = db.session.execute(text("""
+                SELECT id, CONCAT(firstName, ' ', lastName) as full_name 
+                FROM employee 
+                WHERE id IN :employee_ids
+            """), {'employee_ids': tuple(employee_ids)})
+            
+            for row in employee_query:
+                employee_names[str(row[0])] = row[1]
+                
+        except Exception as e:
+            print(f"⚠️ Could not load employee names for export: {e}")
+        
+        # Get project name for filename
+        project_name = ''
+        if project_filter:
+            try:
+                project = Project.query.get(int(project_filter))
+                if project:
+                    project_name = f"_{project.name.replace(' ', '_')}"
+            except Exception as e:
+                print(f"⚠️ Error getting project name for filename: {e}")
+        
+        # Create Excel exporter
+        exporter = PayrollExcelExporter(
+            company_name=os.environ.get('COMPANY_NAME', 'Your Company'),
+            contract_name=os.environ.get('CONTRACT_NAME', 'Default Contract')
+        )
+        
+        # Generate Excel file
+        if report_type == 'detailed':
+            excel_file = exporter.create_detailed_hours_report(
+                start_date, end_date, attendance_records, employee_names, include_travel_time
+            )
+            filename_prefix = 'detailed_hours_report'
+        else:
+            excel_file = exporter.create_payroll_report(
+                start_date, end_date, attendance_records, employee_names, include_travel_time
+            )
+            filename_prefix = 'payroll_report'
+        
+        if excel_file:
+            # Generate filename with timestamp and project name
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            travel_suffix = '_with_travel' if include_travel_time else '_no_travel'
+            filename = f'{filename_prefix}_{date_from}_to_{date_to}{project_name}{travel_suffix}_{timestamp}.xlsx'
+            
+            print(f"📊 Payroll Excel file generated successfully: {filename}")
+            
+            # Log successful export
+            logger_handler.logger.info(f"Payroll Excel export generated by user {session.get('username', 'unknown')}: {filename}")
+            
+            return send_file(
+                excel_file,
+                as_attachment=True,
+                download_name=filename,
+                mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+            )
+        else:
+            flash('Error generating payroll Excel file.', 'error')
+            return redirect(url_for('payroll_dashboard'))
+            
+    except Exception as e:
+        print(f"❌ Error in export_payroll_excel route: {e}")
+        import traceback
+        print(f"❌ Traceback: {traceback.format_exc()}")
+        
+        logger_handler.log_flask_error(
+            error_type="payroll_excel_export_error",
+            error_message=str(e),
+            stack_trace=traceback.format_exc()
+        )
+        
+        flash('Error generating payroll Excel export. Please check the server logs.', 'error')
+        return redirect(url_for('payroll_dashboard'))
+
+@app.route('/api/working-hours/calculate', methods=['POST'])
+@login_required
+@log_database_operations('working_hours_api_calculation')
+def calculate_working_hours_api():
+    """API endpoint for calculating working hours"""
+    try:
+        # Check permissions
+        user_role = session.get('role')
+        if user_role not in ['admin', 'payroll']:
+            return jsonify({
+                'success': False,
+                'message': 'Access denied. Insufficient permissions.'
+            }), 403
+        
+        # Get parameters from JSON request
+        data = request.get_json()
+        if not data:
+            return jsonify({
+                'success': False,
+                'message': 'No data provided'
+            }), 400
+        
+        employee_id = data.get('employee_id')
+        date_from = data.get('date_from')
+        date_to = data.get('date_to')
+        include_travel_time = data.get('include_travel_time', True)
+        
+        if not all([employee_id, date_from, date_to]):
+            return jsonify({
+                'success': False,
+                'message': 'Missing required parameters: employee_id, date_from, date_to'
+            }), 400
+        
+        try:
+            start_date = datetime.strptime(date_from, '%Y-%m-%d')
+            end_date = datetime.strptime(date_to, '%Y-%m-%d')
+        except ValueError:
+            return jsonify({
+                'success': False,
+                'message': 'Invalid date format. Use YYYY-MM-DD.'
+            }), 400
+        
+        # Get attendance records for the employee
+        query = db.session.query(AttendanceData).filter(
+            AttendanceData.employee_id == str(employee_id),
+            AttendanceData.check_in_date >= start_date.date(),
+            AttendanceData.check_in_date <= end_date.date()
+        ).order_by(AttendanceData.check_in_date, AttendanceData.check_in_time)
+        
+        attendance_records = query.all()
+        
+        # Calculate working hours
+        calculator = SingleCheckInCalculator()
+        hours_data = calculator.calculate_employee_hours(
+            str(employee_id), start_date, end_date, attendance_records
+        )
+        
+        # Log API usage
+        logger_handler.logger.info(f"Working hours API used by {session.get('username', 'unknown')} for employee {employee_id}")
+        
+        return jsonify({
+            'success': True,
+            'data': hours_data
+        })
+        
+    except Exception as e:
+        print(f"❌ Error in calculate_working_hours_api: {e}")
+        logger_handler.log_flask_error(
+            error_type="working_hours_api_error",
+            error_message=str(e),
+            stack_trace=traceback.format_exc()
+        )
+        
+        return jsonify({
+            'success': False,
+            'message': 'Internal server error. Please check the server logs.'
+        }), 500
+
+def get_employee_name(employee_id):
+    """Helper function to get employee full name by ID"""
+    try:
+        result = db.session.execute(text("""
+            SELECT CONCAT(firstName, ' ', lastName) as full_name 
+            FROM employee 
+            WHERE id = :employee_id
+        """), {'employee_id': employee_id})
+        
+        row = result.fetchone()
+        return row[0] if row else f"Employee {employee_id}"
+        
+    except Exception as e:
+        print(f"⚠️ Error getting employee name for ID {employee_id}: {e}")
+        return f"Employee {employee_id}"
+    
+@app.context_processor
+def inject_payroll_utils():
+    """Inject payroll utility functions into templates"""
+    return {
+        'get_employee_name': get_employee_name,
+        'format_hours': lambda hours: f"{hours:.2f}" if hours else "0.00"
+    }
            
 # Jinja2 filters for better template functionality
 @app.template_filter('days_since')

payroll_excel_exporter.py

@@ -0,0 +1,463 @@
+#!/usr/bin/env python3
+"""
+Payroll Excel Exporter
+=====================
+
+Enhanced Excel exporter for payroll reports with working hours calculations.
+Based on the Java PayrollReport.java implementation.
+
+Features:
+- Employee working hours with daily/weekly breakdown
+- Regular and overtime hour calculations
+- Travel time inclusion options
+- Professional Excel formatting
+- Multiple report formats
+"""
+
+import io
+from datetime import datetime, timedelta
+from typing import List, Dict, Any, Optional
+from openpyxl import Workbook
+from openpyxl.styles import Font, Alignment, PatternFill, Border, Side
+from openpyxl.utils import get_column_letter
+from single_checkin_calculator import SingleCheckInCalculator
+from logger_handler import log_database_operations
+
+
+class PayrollExcelExporter:
+    """Excel exporter for payroll reports with working hours"""
+    
+    def __init__(self, company_name: str = "Company Name", contract_name: str = "Default Contract"):
+        self.company_name = company_name
+        self.contract_name = contract_name
+        
+        # Excel styling
+        self.header1_style = None
+        self.header2_style = None
+        self.header3_style = None
+        self.table_header_style = None
+        self.data_style = None
+        self.total_style = None
+        
+    def _setup_styles(self, workbook: Workbook):
+        """Setup Excel cell styles"""
+        
+        # Header 1 style (Company name)
+        self.header1_style = {
+            'font': Font(name="Arial", size=16, bold=True, color="FFFFFF"),
+            'fill': PatternFill(start_color="2F4F4F", end_color="2F4F4F", fill_type="solid"),
+            'alignment': Alignment(horizontal="center", vertical="center")
+        }
+        
+        # Header 2 style (Report title)
+        self.header2_style = {
+            'font': Font(name="Arial", size=14, bold=True, color="FFFFFF"),
+            'fill': PatternFill(start_color="4682B4", end_color="4682B4", fill_type="solid"),
+            'alignment': Alignment(horizontal="center", vertical="center")
+        }
+        
+        # Header 3 style (Contract and date range)
+        self.header3_style = {
+            'font': Font(name="Arial", size=12, bold=True),
+            'alignment': Alignment(horizontal="center", vertical="center")
+        }
+        
+        # Table header style
+        self.table_header_style = {
+            'font': Font(name="Arial", size=11, bold=True, color="FFFFFF"),
+            'fill': PatternFill(start_color="366092", end_color="366092", fill_type="solid"),
+            'alignment': Alignment(horizontal="center", vertical="center"),
+            'border': Border(
+                left=Side(style="thin"),
+                right=Side(style="thin"),
+                top=Side(style="thin"),
+                bottom=Side(style="thin")
+            )
+        }
+        
+        # Data style
+        self.data_style = {
+            'font': Font(name="Arial", size=10),
+            'alignment': Alignment(horizontal="center", vertical="center"),
+            'border': Border(
+                left=Side(style="thin"),
+                right=Side(style="thin"),
+                top=Side(style="thin"),
+                bottom=Side(style="thin")
+            )
+        }
+        
+        # Total style
+        self.total_style = {
+            'font': Font(name="Arial", size=11, bold=True),
+            'fill': PatternFill(start_color="E6E6FA", end_color="E6E6FA", fill_type="solid"),
+            'alignment': Alignment(horizontal="center", vertical="center"),
+            'border': Border(
+                left=Side(style="thick"),
+                right=Side(style="thick"),
+                top=Side(style="thick"),
+                bottom=Side(style="thick")
+            )
+        }
+    
+    def _apply_style(self, cell, style_dict):
+        """Apply a style dictionary to a cell"""
+        for attr, value in style_dict.items():
+            setattr(cell, attr, value)
+    
+    @log_database_operations('payroll_excel_export')
+    def create_payroll_report(self, start_date: datetime, end_date: datetime, 
+                             attendance_records: List[Dict], employee_names: Dict[str, str] = None,
+                             include_travel_time: bool = True) -> io.BytesIO:
+        """
+        Create a comprehensive payroll report with working hours
+        
+        Args:
+            start_date: Report start date
+            end_date: Report end date  
+            attendance_records: List of attendance records
+            employee_names: Dictionary mapping employee_id to full name
+            include_travel_time: Whether to include travel time in calculations
+            
+        Returns:
+            BytesIO buffer containing the Excel file
+        """
+        try:
+            print(f"📊 Creating payroll report from {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}")
+            
+            # Calculate working hours
+            calculator = SingleCheckInCalculator()
+            hours_data = calculator.calculate_all_employees_hours(start_date, end_date, attendance_records)
+            
+            # Create workbook
+            workbook = Workbook()
+            worksheet = workbook.active
+            worksheet.title = "Payroll Report"
+            
+            # Setup styles
+            self._setup_styles(workbook)
+            
+            # Write report headers
+            current_row = self._write_report_headers(worksheet, start_date, end_date)
+            
+            # Write employee data
+            current_row = self._write_employee_payroll_data(worksheet, hours_data, employee_names, current_row)
+            
+            # Write summary totals
+            self._write_summary_totals(worksheet, hours_data, current_row)
+            
+            # Auto-adjust column widths
+            self._auto_adjust_columns(worksheet)
+            
+            # Save to BytesIO
+            excel_buffer = io.BytesIO()
+            workbook.save(excel_buffer)
+            excel_buffer.seek(0)
+            
+            print("✅ Payroll report Excel file created successfully")
+            return excel_buffer
+            
+        except Exception as e:
+            print(f"❌ Error creating payroll report: {e}")
+            raise e
+    
+    def _write_report_headers(self, worksheet, start_date: datetime, end_date: datetime) -> int:
+        """Write report headers and return next row number"""
+        current_row = 1
+        
+        # Company name
+        cell = worksheet.cell(row=current_row, column=1, value=self.company_name)
+        self._apply_style(cell, self.header1_style)
+        worksheet.merge_cells(f'A{current_row}:M{current_row}')
+        current_row += 1
+        
+        # Report title
+        cell = worksheet.cell(row=current_row, column=1, value="Payroll Report - Working Hours Summary")
+        self._apply_style(cell, self.header2_style)
+        worksheet.merge_cells(f'A{current_row}:M{current_row}')
+        current_row += 1
+        
+        # Contract name
+        cell = worksheet.cell(row=current_row, column=1, value=self.contract_name)
+        self._apply_style(cell, self.header3_style)
+        worksheet.merge_cells(f'A{current_row}:M{current_row}')
+        current_row += 1
+        
+        # Date range
+        date_range = f"Date range: {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}"
+        cell = worksheet.cell(row=current_row, column=1, value=date_range)
+        self._apply_style(cell, self.header3_style)
+        worksheet.merge_cells(f'A{current_row}:M{current_row}')
+        current_row += 2  # Add extra space
+        
+        return current_row
+    
+    def _write_employee_payroll_data(self, worksheet, hours_data: Dict, employee_names: Dict[str, str], start_row: int) -> int:
+        """Write employee payroll data and return next row number"""
+        current_row = start_row
+        
+        # Table headers
+        headers = [
+            "#", "Employee ID", "Employee Name", 
+            "Week 1 Mon", "Week 1 Tue", "Week 1 Wed", "Week 1 Thu", "Week 1 Fri", "Week 1 Sat", "Week 1 Sun",
+            "Week 1 Regular", "Week 1 OT",
+            "Week 2 Mon", "Week 2 Tue", "Week 2 Wed", "Week 2 Thu", "Week 2 Fri", "Week 2 Sat", "Week 2 Sun", 
+            "Week 2 Regular", "Week 2 OT",
+            "Total Regular", "Total OT", "Grand Total"
+        ]
+        
+        for col, header in enumerate(headers, 1):
+            cell = worksheet.cell(row=current_row, column=col, value=header)
+            self._apply_style(cell, self.table_header_style)
+        current_row += 1
+        
+        # Employee data
+        counter = 1
+        for employee_id, emp_data in hours_data['employees'].items():
+            # Employee basic info
+            employee_name = employee_names.get(employee_id, f"Employee {employee_id}") if employee_names else f"Employee {employee_id}"
+            
+            row_data = [
+                counter,
+                employee_id,
+                employee_name
+            ]
+            
+            # Calculate daily hours for two weeks (14 days)
+            daily_hours = self._calculate_daily_hours_for_payroll(emp_data, hours_data['period_start'])
+            
+            # Week 1 daily hours (7 days)
+            week1_total = 0
+            for day_idx in range(7):
+                hours = daily_hours.get(day_idx, 0)
+                row_data.append(round(hours, 2))
+                week1_total += hours
+            
+            # Week 1 regular and OT
+            week1_regular = min(week1_total, 40.0)
+            week1_ot = max(0, week1_total - 40.0)
+            row_data.extend([round(week1_regular, 2), round(week1_ot, 2)])
+            
+            # Week 2 daily hours (7 days)
+            week2_total = 0
+            for day_idx in range(7, 14):
+                hours = daily_hours.get(day_idx, 0)
+                row_data.append(round(hours, 2))
+                week2_total += hours
+            
+            # Week 2 regular and OT
+            week2_regular = min(week2_total, 40.0)
+            week2_ot = max(0, week2_total - 40.0)
+            row_data.extend([round(week2_regular, 2), round(week2_ot, 2)])
+            
+            # Totals
+            total_regular = week1_regular + week2_regular
+            total_ot = week1_ot + week2_ot
+            grand_total = total_regular + total_ot
+            row_data.extend([round(total_regular, 2), round(total_ot, 2), round(grand_total, 2)])
+            
+            # Write row data
+            for col, value in enumerate(row_data, 1):
+                cell = worksheet.cell(row=current_row, column=col, value=value)
+                self._apply_style(cell, self.data_style)
+            
+            current_row += 1
+            counter += 1
+        
+        return current_row + 1  # Add space before summary
+    
+    def _calculate_daily_hours_for_payroll(self, emp_data: Dict, start_date_str: str) -> Dict[int, float]:
+        """Calculate daily hours for payroll format (14 days)"""
+        daily_hours = {}
+        start_date = datetime.strptime(start_date_str, '%Y-%m-%d')
+        
+        for day_idx in range(14):
+            current_date = start_date + timedelta(days=day_idx)
+            date_key = current_date.strftime('%Y-%m-%d')
+            
+            if date_key in emp_data['daily_hours']:
+                day_data = emp_data['daily_hours'][date_key]
+                if not day_data['is_miss_punch']:
+                    daily_hours[day_idx] = day_data['total_hours']
+                else:
+                    daily_hours[day_idx] = 0  # Miss punch = 0 hours
+            else:
+                daily_hours[day_idx] = 0  # No records = 0 hours
+        
+        return daily_hours
+    
+    def _write_summary_totals(self, worksheet, hours_data: Dict, start_row: int):
+        """Write summary totals section"""
+        current_row = start_row + 1
+        
+        # Summary header
+        cell = worksheet.cell(row=current_row, column=1, value="PAYROLL SUMMARY")
+        self._apply_style(cell, self.header2_style)
+        worksheet.merge_cells(f'A{current_row}:F{current_row}')
+        current_row += 2
+        
+        # Calculate totals across all employees
+        total_employees = len(hours_data['employees'])
+        total_regular_hours = 0
+        total_overtime_hours = 0
+        total_hours = 0
+        
+        for emp_data in hours_data['employees'].values():
+            total_regular_hours += emp_data['grand_totals']['regular_hours']
+            total_overtime_hours += emp_data['grand_totals']['overtime_hours']
+            total_hours += emp_data['grand_totals']['total_hours']
+        
+        # Summary data
+        summary_data = [
+            ("Total Employees:", total_employees),
+            ("Total Regular Hours:", round(total_regular_hours, 2)),
+            ("Total Overtime Hours:", round(total_overtime_hours, 2)),
+            ("Grand Total Hours:", round(total_hours, 2)),
+            ("Travel Time Included:", "Yes" if hours_data['include_travel_time'] else "No"),
+            ("Report Generated:", datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
+        ]
+        
+        for label, value in summary_data:
+            cell1 = worksheet.cell(row=current_row, column=1, value=label)
+            self._apply_style(cell1, self.total_style)
+            cell2 = worksheet.cell(row=current_row, column=2, value=value)
+            self._apply_style(cell2, self.total_style)
+            current_row += 1
+    
+    def _auto_adjust_columns(self, worksheet):
+        """Auto-adjust column widths"""
+        for column in worksheet.columns:
+            max_length = 0
+            column_letter = get_column_letter(column[0].column)
+            
+            for cell in column:
+                try:
+                    if len(str(cell.value)) > max_length:
+                        max_length = len(str(cell.value))
+                except:
+                    pass
+            
+            adjusted_width = min(max_length + 2, 20)
+            worksheet.column_dimensions[column_letter].width = adjusted_width
+    
+    @log_database_operations('detailed_hours_export')
+    def create_detailed_hours_report(self, start_date: datetime, end_date: datetime,
+                                    attendance_records: List[Dict], employee_names: Dict[str, str] = None,
+                                    include_travel_time: bool = True) -> io.BytesIO:
+        """
+        Create a detailed daily hours report for all employees
+        
+        Args:
+            start_date: Report start date
+            end_date: Report end date
+            attendance_records: List of attendance records
+            employee_names: Dictionary mapping employee_id to full name
+            include_travel_time: Whether to include travel time in calculations
+            
+        Returns:
+            BytesIO buffer containing the Excel file
+        """
+        try:
+            print(f"📊 Creating detailed hours report from {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}")
+            
+            # Calculate working hours
+            calculator = SingleCheckInCalculator()
+            hours_data = calculator.calculate_all_employees_hours(start_date, end_date, attendance_records)
+            
+            # Create workbook
+            workbook = Workbook()
+            worksheet = workbook.active
+            worksheet.title = "Detailed Hours Report"
+            
+            # Setup styles
+            self._setup_styles(workbook)
+            
+            # Write headers
+            current_row = 1
+            cell = worksheet.cell(row=current_row, column=1, value=self.company_name)
+            self._apply_style(cell, self.header1_style)
+            worksheet.merge_cells(f'A{current_row}:J{current_row}')
+            current_row += 1
+            
+            cell = worksheet.cell(row=current_row, column=1, value="Detailed Daily Hours Report")
+            self._apply_style(cell, self.header2_style)
+            worksheet.merge_cells(f'A{current_row}:J{current_row}')
+            current_row += 2
+            
+            # Table headers
+            headers = ["Employee ID", "Employee Name", "Date", "Day of Week", "Total Hours", 
+                      "Status", "Records Count", "Regular Hours", "Overtime Hours", "Notes"]
+            
+            for col, header in enumerate(headers, 1):
+                cell = worksheet.cell(row=current_row, column=col, value=header)
+                self._apply_style(cell, self.table_header_style)
+            current_row += 1
+            
+            # Write detailed data
+            for employee_id, emp_data in hours_data['employees'].items():
+                employee_name = employee_names.get(employee_id, f"Employee {employee_id}") if employee_names else f"Employee {employee_id}"
+                
+                # Sort daily hours by date
+                daily_items = sorted(emp_data['daily_hours'].items())
+                
+                for date_str, day_data in daily_items:
+                    date_obj = datetime.strptime(date_str, '%Y-%m-%d')
+                    day_name = date_obj.strftime('%A')
+                    
+                    # Determine status and notes
+                    if day_data['is_miss_punch']:
+                        status = "Miss Punch"
+                        notes = "Missing check-in or check-out"
+                        hours = 0
+                    elif day_data['records_count'] == 0:
+                        status = "No Records"
+                        notes = "No attendance records"
+                        hours = 0
+                    else:
+                        status = "Complete"
+                        notes = f"{day_data['records_count']} record(s)"
+                        hours = day_data['total_hours']
+                    
+                    # Calculate regular/overtime for this day
+                    regular_hours = min(hours, 8.0)  # Daily limit
+                    overtime_hours = max(0, hours - 8.0)
+                    
+                    row_data = [
+                        employee_id,
+                        employee_name,
+                        date_str,
+                        day_name,
+                        round(hours, 2),
+                        status,
+                        day_data['records_count'],
+                        round(regular_hours, 2),
+                        round(overtime_hours, 2),
+                        notes
+                    ]
+                    
+                    for col, value in enumerate(row_data, 1):
+                        cell = worksheet.cell(row=current_row, column=col, value=value)
+                        self._apply_style(cell, self.data_style)
+                        
+                        # Color code miss punches
+                        if status == "Miss Punch":
+                            cell.fill = PatternFill(start_color="FFE6E6", end_color="FFE6E6", fill_type="solid")
+                        elif status == "No Records":
+                            cell.fill = PatternFill(start_color="F0F0F0", end_color="F0F0F0", fill_type="solid")
+                    
+                    current_row += 1
+            
+            # Auto-adjust columns
+            self._auto_adjust_columns(worksheet)
+            
+            # Save to BytesIO
+            excel_buffer = io.BytesIO()
+            workbook.save(excel_buffer)
+            excel_buffer.seek(0)
+            
+            print("✅ Detailed hours report Excel file created successfully")
+            return excel_buffer
+            
+        except Exception as e:
+            print(f"❌ Error creating detailed hours report: {e}")
+            raise e

single_checkin_calculator.py

@@ -0,0 +1,320 @@
+#!/usr/bin/env python3
+"""
+Single Check-in Working Hours Calculator
+=======================================
+
+Calculator specifically designed for single check-in systems where each
+attendance record represents a check-in only (not check-in/check-out pairs).
+
+This calculator interprets consecutive check-ins as work periods:
+- 1st check-in = start work
+- 2nd check-in = end work (or start of next period)
+- 3rd check-in = end previous period, start new period
+- etc.
+
+Based on your attendance system structure.
+"""
+
+from datetime import datetime, timedelta, time
+from typing import List, Dict, Optional, Tuple, Any
+from dataclasses import dataclass
+import math
+from logger_handler import log_database_operations
+
+
+@dataclass
+class CheckInRecord:
+    """Represents a single check-in record"""
+    id: int
+    employee_id: str
+    check_in_date: datetime
+    check_in_time: time
+    location_name: str
+    timestamp: datetime = None
+    
+    def __post_init__(self):
+        if self.timestamp is None:
+            # Combine date and time for timestamp
+            self.timestamp = datetime.combine(self.check_in_date, self.check_in_time)
+
+
+@dataclass 
+class WorkPeriod:
+    """Represents a calculated work period from consecutive check-ins"""
+    start_record: CheckInRecord
+    end_record: Optional[CheckInRecord]
+    duration_minutes: int = 0
+    is_complete: bool = False
+    
+    def __post_init__(self):
+        if self.end_record and self.start_record:
+            duration = self.end_record.timestamp - self.start_record.timestamp
+            self.duration_minutes = int(duration.total_seconds() / 60)
+            self.is_complete = True
+        else:
+            self.duration_minutes = 0
+            self.is_complete = False
+
+
+class SingleCheckInCalculator:
+    """Calculator for single check-in attendance systems"""
+    
+    def __init__(self, max_work_period_hours: float = 12.0, min_break_minutes: int = 30):
+        self.max_work_period_hours = max_work_period_hours  # Maximum reasonable work period
+        self.min_break_minutes = min_break_minutes  # Minimum break between work periods
+    
+    @log_database_operations('single_checkin_hours_calculation')
+    def calculate_employee_hours(self, employee_id: str, start_date: datetime, end_date: datetime, 
+                                 attendance_records: List[Dict]) -> Dict[str, Any]:
+        """
+        Calculate working hours for an employee using single check-in records
+        
+        Logic:
+        - Convert consecutive check-ins into work periods
+        - 1st check-in = start work, 2nd check-in = end work
+        - Handle multiple periods per day
+        - Round to nearest quarter hour
+        """
+        try:
+            print(f"🔍 Calculating hours for employee {employee_id}")
+            
+            # Convert database records to CheckInRecord objects
+            records = []
+            for record in attendance_records:
+                if hasattr(record, '__dict__'):
+                    emp_id = str(record.employee_id)
+                    date_val = record.check_in_date
+                    time_val = record.check_in_time
+                    location = record.location_name
+                    record_id = record.id
+                else:
+                    emp_id = str(record['employee_id'])
+                    date_val = record['check_in_date']
+                    time_val = record['check_in_time']
+                    location = record['location_name']
+                    record_id = record['id']
+                
+                if emp_id == employee_id:
+                    checkin_record = CheckInRecord(
+                        id=record_id,
+                        employee_id=emp_id,
+                        check_in_date=date_val,
+                        check_in_time=time_val,
+                        location_name=location
+                    )
+                    records.append(checkin_record)
+            
+            if not records:
+                print(f"⚠️ No records found for employee {employee_id}")
+                return self._empty_result(employee_id, start_date, end_date)
+            
+            print(f"📊 Found {len(records)} check-in records for employee {employee_id}")
+            
+            # Group records by date and calculate daily hours
+            daily_records = {}
+            for record in records:
+                date_key = record.check_in_date.strftime('%Y-%m-%d')
+                if date_key not in daily_records:
+                    daily_records[date_key] = []
+                daily_records[date_key].append(record)
+            
+            # Calculate daily hours
+            daily_hours = {}
+            weekly_totals = []
+            
+            current_date = start_date
+            current_week_hours = []
+            
+            while current_date <= end_date:
+                date_key = current_date.strftime('%Y-%m-%d')
+                day_records = daily_records.get(date_key, [])
+                
+                # Calculate hours for this day
+                day_hours, is_miss_punch = self._calculate_daily_hours_from_checkins(day_records)
+                
+                daily_hours[date_key] = {
+                    'total_minutes': int(day_hours * 60) if day_hours > 0 else 0,
+                    'total_hours': day_hours if day_hours > 0 else 0,
+                    'is_miss_punch': is_miss_punch,
+                    'records_count': len(day_records)
+                }
+                
+                print(f"📅 {date_key}: {len(day_records)} records, {day_hours:.2f} hours, miss_punch: {is_miss_punch}")
+                
+                # Add to weekly calculation (only positive hours)
+                current_week_hours.append(max(0, day_hours))
+                
+                # Check if end of week (Sunday) or end of period
+                if current_date.weekday() == 6 or current_date == end_date:  # Sunday or last day
+                    week_total = sum(current_week_hours)
+                    week_regular = min(week_total, 40.0)
+                    week_overtime = max(0, week_total - 40.0)
+                    
+                    weekly_totals.append({
+                        'total_hours': week_total,
+                        'regular_hours': week_regular,
+                        'overtime_hours': week_overtime,
+                        'total_minutes': int(week_total * 60),
+                        'regular_minutes': int(week_regular * 60),
+                        'overtime_minutes': int(week_overtime * 60)
+                    })
+                    
+                    current_week_hours = []
+                
+                current_date += timedelta(days=1)
+            
+            # Calculate grand totals
+            grand_total_hours = sum(week['total_hours'] for week in weekly_totals)
+            grand_regular_hours = sum(week['regular_hours'] for week in weekly_totals)
+            grand_overtime_hours = sum(week['overtime_hours'] for week in weekly_totals)
+            
+            print(f"✅ Employee {employee_id}: {grand_total_hours:.2f} total hours, {grand_regular_hours:.2f} regular, {grand_overtime_hours:.2f} OT")
+            
+            return {
+                'employee_id': employee_id,
+                'start_date': start_date.strftime('%Y-%m-%d'),
+                'end_date': end_date.strftime('%Y-%m-%d'),
+                'include_travel_time': True,  # Not applicable for single check-in system
+                'daily_hours': daily_hours,
+                'weekly_hours': weekly_totals,
+                'grand_totals': {
+                    'total_hours': grand_total_hours,
+                    'regular_hours': grand_regular_hours,
+                    'overtime_hours': grand_overtime_hours,
+                    'total_minutes': int(grand_total_hours * 60),
+                    'regular_minutes': int(grand_regular_hours * 60),
+                    'overtime_minutes': int(grand_overtime_hours * 60)
+                }
+            }
+            
+        except Exception as e:
+            print(f"❌ Error calculating working hours for employee {employee_id}: {e}")
+            import traceback
+            print(f"❌ Traceback: {traceback.format_exc()}")
+            return self._empty_result(employee_id, start_date, end_date)
+    
+    def _calculate_daily_hours_from_checkins(self, day_records: List[CheckInRecord]) -> Tuple[float, bool]:
+        """
+        Calculate hours for a single day from check-in records
+        
+        Logic: 
+        - Pair consecutive check-ins as work periods
+        - 1st = start, 2nd = end, 3rd = start new period, 4th = end, etc.
+        - Single record = miss punch
+        - Validate reasonable work periods
+        
+        Returns: (hours, is_miss_punch)
+        """
+        if not day_records:
+            return 0.0, False
+        
+        if len(day_records) == 1:
+            print(f"⚠️ Single check-in found - miss punch")
+            return 0.0, True  # Single check-in = miss punch
+        
+        # Sort records by time
+        sorted_records = sorted(day_records, key=lambda r: r.timestamp)
+        print(f"📝 Processing {len(sorted_records)} records for the day")
+        
+        # Create work periods from consecutive check-ins
+        work_periods = []
+        for i in range(0, len(sorted_records) - 1, 2):
+            start_record = sorted_records[i]
+            end_record = sorted_records[i + 1] if i + 1 < len(sorted_records) else None
+            
+            if end_record:
+                period = WorkPeriod(start_record, end_record)
+                
+                # Validate work period duration
+                if self._is_valid_work_period(period):
+                    work_periods.append(period)
+                    print(f"✅ Valid work period: {start_record.check_in_time} - {end_record.check_in_time} = {period.duration_minutes/60:.2f} hours")
+                else:
+                    print(f"⚠️ Invalid work period: {period.duration_minutes/60:.2f} hours (too long or negative)")
+                    return 0.0, True  # Invalid period = miss punch
+            else:
+                print(f"⚠️ Unpaired check-in at {start_record.check_in_time}")
+                return 0.0, True  # Unpaired record = miss punch
+        
+        # Calculate total hours
+        total_minutes = sum(period.duration_minutes for period in work_periods)
+        total_hours = total_minutes / 60.0
+        
+        # Round to nearest quarter hour
+        rounded_hours = round(total_hours * 4) / 4
+        
+        print(f"📊 Daily total: {rounded_hours:.2f} hours from {len(work_periods)} work periods")
+        
+        return rounded_hours, False
+    
+    def _is_valid_work_period(self, period: WorkPeriod) -> bool:
+        """Check if a work period is valid (reasonable duration)"""
+        if not period.is_complete:
+            return False
+        
+        hours = period.duration_minutes / 60.0
+        
+        # Must be positive and less than max work period
+        if hours <= 0 or hours > self.max_work_period_hours:
+            return False
+        
+        # Must be at least 15 minutes
+        if period.duration_minutes < 15:
+            return False
+        
+        return True
+    
+    def _empty_result(self, employee_id: str, start_date: datetime, end_date: datetime) -> Dict[str, Any]:
+        """Return empty result structure"""
+        return {
+            'employee_id': employee_id,
+            'start_date': start_date.strftime('%Y-%m-%d'),
+            'end_date': end_date.strftime('%Y-%m-%d'),
+            'include_travel_time': True,
+            'daily_hours': {},
+            'weekly_hours': [],
+            'grand_totals': {
+                'total_hours': 0.0,
+                'regular_hours': 0.0,
+                'overtime_hours': 0.0,
+                'total_minutes': 0,
+                'regular_minutes': 0,
+                'overtime_minutes': 0
+            }
+        }
+    
+    def calculate_all_employees_hours(self, start_date: datetime, end_date: datetime, 
+                                      attendance_records: List[Dict]) -> Dict[str, Any]:
+        """Calculate working hours for all employees in the given period"""
+        try:
+            print(f"🚀 Starting calculation for all employees")
+            
+            # Get unique employee IDs
+            employee_ids = set()
+            for record in attendance_records:
+                if hasattr(record, '__dict__'):
+                    employee_ids.add(str(record.employee_id))
+                else:
+                    employee_ids.add(str(record['employee_id']))
+            
+            print(f"👥 Found {len(employee_ids)} unique employees")
+            
+            results = {}
+            for emp_id in sorted(employee_ids):
+                print(f"\n🔄 Processing employee {emp_id}")
+                results[emp_id] = self.calculate_employee_hours(emp_id, start_date, end_date, attendance_records)
+            
+            return {
+                'calculation_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                'period_start': start_date.strftime('%Y-%m-%d'),
+                'period_end': end_date.strftime('%Y-%m-%d'),
+                'include_travel_time': True,  # Not applicable for single check-in
+                'employee_count': len(employee_ids),
+                'employees': results
+            }
+            
+        except Exception as e:
+            print(f"❌ Error calculating hours for all employees: {e}")
+            import traceback
+            print(f"❌ Traceback: {traceback.format_exc()}")
+            raise e

templates/base_authenticated.html

@@ -68,18 +68,30 @@
                 <i class="fas fa-chart-line"></i>
                 <span class="menu-text">Reports</span>
               </a>
+              <a href="{{ url_for('payroll_dashboard') }}" class="menu-item">
+                <i class="fas fa-calculator"></i>
+                <span class="menu-text">Payroll</span>
+              </a>
               <a href="{{ url_for('admin_logs') }}" 
                  class="menu-item {% if request.endpoint == 'admin_logs' %}active{% endif %}">
                 <i class="fas fa-clipboard-list"></i>
                 <span class="menu-text">System Logs</span>
               </a>
-              {% elif session.role in ['payroll', 'project_manager'] %}
+              {% elif session.role in ['payroll'] %}
+              <a href="{{ url_for('attendance_report') }}" class="menu-item">
+                <i class="fas fa-chart-line"></i>
+                <span class="menu-text">Reports</span>
+              </a>
+              <a href="{{ url_for('payroll_dashboard') }}" class="menu-item">
+                <i class="fas fa-calculator"></i>
+                <span class="menu-text">Payroll</span>
+              </a>
+              {% elif session.role in ['project_manager'] %}
               <a href="{{ url_for('attendance_report') }}" class="menu-item">
                 <i class="fas fa-chart-line"></i>
                 <span class="menu-text">Reports</span>
               </a>
               {% endif %}
-
               <a href="{{ url_for('profile') }}" class="menu-item">
                 <i class="fas fa-user"></i>
                 <span class="menu-text">Profile</span>

templates/payroll_dashboard.html

@@ -0,0 +1,530 @@
+{% extends "base_authenticated.html" %}
+{% block title %}Payroll Dashboard - Working Hours{% endblock %}
+
+{% block extra_head %}
+<style>
+    .payroll-page {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        min-height: 100vh;
+        padding: 2rem 0;
+    }
+
+    .payroll-container {
+        max-width: 1400px;
+        margin: 0 auto;
+        padding: 0 1rem;
+    }
+
+    .payroll-header {
+        background: rgba(255, 255, 255, 0.95);
+        backdrop-filter: blur(10px);
+        border-radius: 15px;
+        padding: 2rem;
+        margin-bottom: 2rem;
+        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+        text-align: center;
+    }
+
+    .payroll-header h1 {
+        color: #2d3748;
+        font-size: 2.5rem;
+        font-weight: 700;
+        margin: 0 0 1rem 0;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        gap: 1rem;
+    }
+
+    .payroll-header h1 i {
+        color: #48bb78;
+    }
+
+    .filters-section {
+        background: rgba(255, 255, 255, 0.95);
+        backdrop-filter: blur(10px);
+        border-radius: 15px;
+        padding: 2rem;
+        margin-bottom: 2rem;
+        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+    }
+
+    .filters-form {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+        gap: 1.5rem;
+        align-items: end;
+    }
+
+    .form-group label {
+        display: block;
+        font-weight: 600;
+        color: #4a5568;
+        margin-bottom: 0.5rem;
+    }
+
+    .form-group input,
+    .form-group select {
+        width: 100%;
+        padding: 0.75rem;
+        border: 2px solid #e2e8f0;
+        border-radius: 8px;
+        font-size: 1rem;
+        transition: all 0.3s ease;
+    }
+
+    .form-group input:focus,
+    .form-group select:focus {
+        outline: none;
+        border-color: #4299e1;
+        box-shadow: 0 0 0 3px rgba(66, 153, 225, 0.1);
+    }
+
+    .checkbox-group {
+        display: flex;
+        align-items: center;
+        gap: 0.75rem;
+        margin-top: 1.5rem;
+    }
+
+    .checkbox-group input[type="checkbox"] {
+        width: auto;
+        transform: scale(1.2);
+    }
+
+    .btn {
+        display: inline-flex;
+        align-items: center;
+        gap: 0.5rem;
+        padding: 0.75rem 1.5rem;
+        border: none;
+        border-radius: 8px;
+        font-weight: 600;
+        text-decoration: none;
+        cursor: pointer;
+        transition: all 0.3s ease;
+        font-size: 1rem;
+    }
+
+    .btn:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 16px rgba(0, 0, 0, 0.2);
+    }
+
+    .btn-primary {
+        background: linear-gradient(135deg, #4299e1, #3182ce);
+        color: white;
+    }
+
+    .btn-success {
+        background: linear-gradient(135deg, #48bb78, #38a169);
+        color: white;
+    }
+
+    .btn-secondary {
+        background: linear-gradient(135deg, #a0aec0, #718096);
+        color: white;
+    }
+
+    .results-section {
+        background: rgba(255, 255, 255, 0.95);
+        backdrop-filter: blur(10px);
+        border-radius: 15px;
+        padding: 2rem;
+        margin-bottom: 2rem;
+        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+    }
+
+    .summary-cards {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+        gap: 1.5rem;
+        margin-bottom: 2rem;
+    }
+
+    .summary-card {
+        background: linear-gradient(135deg, #f7fafc, #edf2f7);
+        border: 2px solid #e2e8f0;
+        border-radius: 12px;
+        padding: 1.5rem;
+        text-align: center;
+        transition: all 0.3s ease;
+    }
+
+    .summary-card:hover {
+        border-color: #4299e1;
+        transform: translateY(-2px);
+        box-shadow: 0 4px 16px rgba(66, 153, 225, 0.15);
+    }
+
+    .summary-card h3 {
+        font-size: 2rem;
+        font-weight: 700;
+        color: #2d3748;
+        margin: 0 0 0.5rem 0;
+    }
+
+    .summary-card p {
+        color: #718096;
+        font-weight: 600;
+        margin: 0;
+    }
+
+    .employees-table {
+        overflow-x: auto;
+        border-radius: 10px;
+        box-shadow: 0 4px 16px rgba(0, 0, 0, 0.1);
+    }
+
+    .table {
+        width: 100%;
+        border-collapse: collapse;
+        background: white;
+        font-size: 0.9rem;
+    }
+
+    .table th {
+        background: linear-gradient(135deg, #4299e1, #3182ce);
+        color: white;
+        padding: 1rem;
+        text-align: left;
+        font-weight: 600;
+        border-bottom: 2px solid #2b6cb0;
+        white-space: nowrap;
+    }
+
+    .table td {
+        padding: 0.75rem 1rem;
+        border-bottom: 1px solid #e2e8f0;
+        color: #4a5568;
+    }
+
+    .table tbody tr:hover {
+        background-color: #f7fafc;
+    }
+
+    .hours-badge {
+        display: inline-block;
+        padding: 0.25rem 0.75rem;
+        border-radius: 20px;
+        font-size: 0.875rem;
+        font-weight: 600;
+    }
+
+    .hours-regular {
+        background: #e6fffa;
+        color: #38a169;
+    }
+
+    .hours-overtime {
+        background: #fff5f5;
+        color: #e53e3e;
+    }
+
+    .hours-total {
+        background: #ebf8ff;
+        color: #3182ce;
+    }
+
+    .miss-punch {
+        background: #feb2b2;
+        color: #c53030;
+    }
+
+    .no-data {
+        text-align: center;
+        padding: 3rem;
+        color: #a0aec0;
+        font-style: italic;
+        font-size: 1.1rem;
+    }
+
+    .export-actions {
+        display: flex;
+        gap: 1rem;
+        margin-top: 2rem;
+        flex-wrap: wrap;
+    }
+
+    .back-nav {
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+        color: white;
+        text-decoration: none;
+        font-weight: 600;
+        margin-bottom: 1rem;
+        opacity: 0.9;
+        transition: opacity 0.3s ease;
+    }
+
+    .back-nav:hover {
+        opacity: 1;
+        color: white;
+        text-decoration: none;
+    }
+
+    @media (max-width: 768px) {
+        .payroll-header h1 {
+            font-size: 2rem;
+            flex-direction: column;
+            gap: 0.5rem;
+        }
+
+        .filters-form {
+            grid-template-columns: 1fr;
+        }
+
+        .summary-cards {
+            grid-template-columns: repeat(2, 1fr);
+        }
+
+        .export-actions {
+            flex-direction: column;
+        }
+    }
+</style>
+{% endblock %}
+
+{% block content %}
+<div class="payroll-page">
+    <div class="payroll-container">
+        <!-- Back Navigation -->
+        <a href="{{ url_for('dashboard') }}" class="back-nav">
+            <i class="fas fa-arrow-left"></i>
+            <span>Back to Dashboard</span>
+        </a>
+
+        <!-- Page Header -->
+        <div class="payroll-header">
+            <h1>
+                <i class="fas fa-calculator"></i>
+                Payroll Dashboard
+            </h1>
+            <p>Calculate employee working hours and generate payroll reports</p>
+        </div>
+
+        <!-- Filters Section -->
+        <div class="filters-section">
+            <h3 style="margin-bottom: 1.5rem; color: #2d3748;">
+                <i class="fas fa-filter" style="color: #4299e1; margin-right: 0.5rem;"></i>
+                Calculation Parameters
+            </h3>
+            
+            <form method="GET" action="{{ url_for('payroll_dashboard') }}" class="filters-form">
+                <div class="form-group">
+                    <label for="date_from">Start Date</label>
+                    <input type="date" id="date_from" name="date_from" value="{{ date_from }}" required>
+                </div>
+
+                <div class="form-group">
+                    <label for="date_to">End Date</label>
+                    <input type="date" id="date_to" name="date_to" value="{{ date_to }}" required>
+                </div>
+
+                <div class="form-group">
+                    <label for="project_filter">Filter by Project</label>
+                    <select id="project_filter" name="project_filter">
+                        <option value="">All Projects</option>
+                        {% for project in projects %}
+                        <option value="{{ project.id }}" {% if project_filter == project.id|string %}selected{% endif %}>
+                            {{ project.name }}
+                        </option>
+                        {% endfor %}
+                    </select>
+                </div>
+
+                <div class="form-group">
+                    <button type="submit" class="btn btn-primary">
+                        <i class="fas fa-calculator"></i>
+                        Calculate Hours
+                    </button>
+                </div>
+
+                <div class="checkbox-group">
+                    <input type="checkbox" id="include_travel_time" name="include_travel_time" 
+                           value="true" {% if include_travel_time %}checked{% endif %}>
+                    <label for="include_travel_time">Include travel time between locations</label>
+                </div>
+            </form>
+        </div>
+
+        <!-- Results Section -->
+        {% if working_hours_data %}
+        <div class="results-section">
+            <h3 style="margin-bottom: 1.5rem; color: #2d3748;">
+                <i class="fas fa-chart-bar" style="color: #48bb78; margin-right: 0.5rem;"></i>
+                Working Hours Summary
+            </h3>
+
+            <!-- Summary Cards -->
+            <div class="summary-cards">
+                <div class="summary-card">
+                    <h3>{{ working_hours_data.employee_count }}</h3>
+                    <p>Total Employees</p>
+                </div>
+                <div class="summary-card">
+                    <h3>{{ "%.1f"|format(working_hours_data.employees.values() | map(attribute='grand_totals.total_hours') | sum) }}</h3>
+                    <p>Total Hours</p>
+                </div>
+                <div class="summary-card">
+                    <h3>{{ "%.1f"|format(working_hours_data.employees.values() | map(attribute='grand_totals.regular_hours') | sum) }}</h3>
+                    <p>Regular Hours</p>
+                </div>
+                <div class="summary-card">
+                    <h3>{{ "%.1f"|format(working_hours_data.employees.values() | map(attribute='grand_totals.overtime_hours') | sum) }}</h3>
+                    <p>Overtime Hours</p>
+                </div>
+            </div>
+
+            <!-- Employee Details Table -->
+            <div class="employees-table">
+                <table class="table">
+                    <thead>
+                        <tr>
+                            <th>Employee ID</th>
+                            <th>Employee Name</th>
+                            <th>Total Hours</th>
+                            <th>Regular Hours</th>
+                            <th>Overtime Hours</th>
+                            <th>Working Days</th>
+                            <th>Status</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {% for employee_id, emp_data in working_hours_data.employees.items() %}
+                        <tr>
+                            <td>{{ employee_id }}</td>
+                            <td>{{ employee_names.get(employee_id, 'Employee ' + employee_id) }}</td>
+                            <td>
+                                <span class="hours-badge hours-total">
+                                    {{ "%.2f"|format(emp_data.grand_totals.total_hours) }} hrs
+                                </span>
+                            </td>
+                            <td>
+                                <span class="hours-badge hours-regular">
+                                    {{ "%.2f"|format(emp_data.grand_totals.regular_hours) }} hrs
+                                </span>
+                            </td>
+                            <td>
+                                {% if emp_data.grand_totals.overtime_hours > 0 %}
+                                <span class="hours-badge hours-overtime">
+                                    {{ "%.2f"|format(emp_data.grand_totals.overtime_hours) }} hrs
+                                </span>
+                                {% else %}
+                                <span class="hours-badge" style="background: #f0f0f0; color: #666;">
+                                    0.00 hrs
+                                </span>
+                                {% endif %}
+                            </td>
+                            <td>
+                                {% set working_days = emp_data.daily_hours.values() | selectattr('total_hours', '>', 0) | list | length %}
+                                {{ working_days }} days
+                            </td>
+                            <td>
+                                {% set miss_punches = emp_data.daily_hours.values() | selectattr('is_miss_punch', 'equalto', true) | list | length %}
+                                {% if miss_punches > 0 %}
+                                <span class="hours-badge miss-punch">
+                                    {{ miss_punches }} miss punch(es)
+                                </span>
+                                {% else %}
+                                <span class="hours-badge" style="background: #e6fffa; color: #38a169;">
+                                    Complete
+                                </span>
+                                {% endif %}
+                            </td>
+                        </tr>
+                        {% endfor %}
+                    </tbody>
+                </table>
+            </div>
+
+            <!-- Export Actions -->
+            <div class="export-actions">
+                <form method="POST" action="{{ url_for('export_payroll_excel') }}" style="display: inline;">
+                    <input type="hidden" name="date_from" value="{{ date_from }}">
+                    <input type="hidden" name="date_to" value="{{ date_to }}">
+                    <input type="hidden" name="include_travel_time" value="{{ include_travel_time|lower }}">
+                    <input type="hidden" name="report_type" value="payroll">
+                    <button type="submit" class="btn btn-success">
+                        <i class="fas fa-file-excel"></i>
+                        Export Payroll Report
+                    </button>
+                </form>
+
+                <form method="POST" action="{{ url_for('export_payroll_excel') }}" style="display: inline;">
+                    <input type="hidden" name="date_from" value="{{ date_from }}">
+                    <input type="hidden" name="date_to" value="{{ date_to }}">
+                    <input type="hidden" name="include_travel_time" value="{{ include_travel_time|lower }}">
+                    <input type="hidden" name="report_type" value="detailed">
+                    <button type="submit" class="btn btn-secondary">
+                        <i class="fas fa-list-alt"></i>
+                        Export Detailed Hours
+                    </button>
+                </form>
+            </div>
+
+            <div style="margin-top: 1rem; padding: 1rem; background: #f7fafc; border-radius: 8px; color: #4a5568; font-size: 0.9rem;">
+                <strong>Report Details:</strong><br>
+                Period: {{ working_hours_data.period_start }} to {{ working_hours_data.period_end }}<br>
+                Travel Time: {{ "Included" if working_hours_data.include_travel_time else "Excluded" }}<br>
+                Generated: {{ working_hours_data.calculation_date }}
+            </div>
+        </div>
+        {% else %}
+        <div class="results-section">
+            <div class="no-data">
+                <i class="fas fa-clock" style="font-size: 3rem; margin-bottom: 1rem; opacity: 0.5;"></i><br>
+                {% if date_from and date_to %}
+                No attendance records found for the selected date range.<br>
+                Please try a different date range or check if attendance data has been recorded.
+                {% else %}
+                Please select a date range to calculate working hours.
+                {% endif %}
+            </div>
+        </div>
+        {% endif %}
+    </div>
+</div>
+
+<script>
+document.addEventListener('DOMContentLoaded', function() {
+    // Auto-submit form when travel time checkbox changes
+    const travelTimeCheckbox = document.getElementById('include_travel_time');
+    if (travelTimeCheckbox) {
+        travelTimeCheckbox.addEventListener('change', function() {
+            // Only auto-submit if we have dates
+            const dateFrom = document.getElementById('date_from').value;
+            const dateTo = document.getElementById('date_to').value;
+            
+            if (dateFrom && dateTo) {
+                this.form.submit();
+            }
+        });
+    }
+
+    // Set max date to today for date inputs
+    const today = new Date().toISOString().split('T')[0];
+    document.getElementById('date_from').setAttribute('max', today);
+    document.getElementById('date_to').setAttribute('max', today);
+
+    // Validate date range
+    const dateFromInput = document.getElementById('date_from');
+    const dateToInput = document.getElementById('date_to');
+
+    function validateDateRange() {
+        const dateFrom = new Date(dateFromInput.value);
+        const dateTo = new Date(dateToInput.value);
+
+        if (dateFrom && dateTo && dateFrom > dateTo) {
+            dateToInput.setCustomValidity('End date must be after start date');
+        } else {
+            dateToInput.setCustomValidity('');
+        }
+    }
+
+    dateFromInput.addEventListener('change', validateDateRange);
+    dateToInput.addEventListener('change', validateDateRange);
+});
+</script>
+{% endblock %}

working_hours_calculator.py

@@ -0,0 +1,445 @@
+#!/usr/bin/env python3
+"""
+Working Hours Calculator for Employee Payroll
+============================================
+
+This module implements the working hours calculation logic
+based on the Java files provided. It handles:
+- Daily time calculations with travel time options
+- Weekly regular and overtime hours
+- Record pairing (check-in/check-out)
+- Missing punch detection
+- Quarter-hour rounding
+
+Based on the Java classes:
+- DailyTimeCalculator.java
+- WeeklyTimeCalculator.java 
+- PayrollReport.java
+"""
+
+from datetime import datetime, timedelta, time
+from typing import List, Dict, Optional, Tuple, Any
+from dataclasses import dataclass
+import math
+from logger_handler import log_database_operations
+
+# Constants from Java implementation
+TRAVEL_TIME_MAX_MINUTES = 60
+RECORD_GROUPING_MAX_MINUTES = 60 * 6  # 6 hours
+MAX_REGULAR_TIME_MINUTES = 60 * 40    # 40 hours per week
+
+
+@dataclass
+class AttendanceRecord:
+    """Represents a single attendance record"""
+    id: int
+    employee_id: str
+    check_in_date: datetime
+    check_in_time: time
+    location_name: str
+    record_type: str = 'check_in'  # 'check_in' or 'check_out'
+    timestamp: datetime = None
+    
+    def __post_init__(self):
+        if self.timestamp is None:
+            # Combine date and time for timestamp
+            self.timestamp = datetime.combine(self.check_in_date, self.check_in_time)
+
+
+@dataclass 
+class RecordPair:
+    """Represents a paired check-in/check-out record"""
+    check_in: Optional[AttendanceRecord]
+    check_out: Optional[AttendanceRecord]
+    is_miss_punch: bool = False
+    date: datetime = None
+    location: str = ""
+    
+    def __post_init__(self):
+        if self.check_in:
+            self.date = self.check_in.check_in_date
+            self.location = self.check_in.location_name
+        elif self.check_out:
+            self.date = self.check_out.check_in_date
+            self.location = self.check_out.location_name
+    
+    @property
+    def duration_minutes(self) -> int:
+        """Calculate duration in minutes between check-in and check-out"""
+        if self.is_miss_punch or not self.check_in or not self.check_out:
+            return -1
+        
+        duration = self.check_out.timestamp - self.check_in.timestamp
+        return int(duration.total_seconds() / 60)
+
+
+class TimeCalculator:
+    """Base time calculator with rounding functionality"""
+    
+    @staticmethod
+    def round_time_to_nearest_quarter_hour(minutes: int) -> int:
+        """Round time to nearest quarter hour (15 minutes)"""
+        if minutes < 0:
+            return minutes  # Keep negative values for miss punches
+        
+        # Round to nearest 15-minute interval
+        return round(minutes / 15) * 15
+
+
+class DailyTimeCalculator(TimeCalculator):
+    """Calculate daily working hours with travel time options"""
+    
+    def __init__(self):
+        self.record_pairs: List[RecordPair] = []
+    
+    def add_record_pair(self, pair: RecordPair):
+        """Add a record pair to the daily calculation"""
+        self.record_pairs.append(pair)
+    
+    def get_minutes_total_include_travel_time(self) -> int:
+        """Calculate total minutes including travel time between locations"""
+        minute_total = 0
+        grouped_pairs = self._group_record_pairs(self.record_pairs)
+        
+        for group in grouped_pairs:
+            group_minutes = self._get_minutes_per_record_pair_group(group)
+            if group_minutes < 0:
+                return -1  # Miss punch detected
+            minute_total += group_minutes
+        
+        return self.round_time_to_nearest_quarter_hour(minute_total)
+    
+    def get_minutes_total_exclude_travel_time(self) -> int:
+        """Calculate total minutes excluding travel time"""
+        minute_total = 0
+        
+        for pair in self.record_pairs:
+            if not pair.is_miss_punch:
+                minute_total += pair.duration_minutes
+            else:
+                return -1  # Miss punch detected
+        
+        return self.round_time_to_nearest_quarter_hour(minute_total)
+    
+    def _group_record_pairs(self, record_pairs: List[RecordPair]) -> List[List[RecordPair]]:
+        """Group record pairs based on time gaps (similar to Java implementation)"""
+        if not record_pairs:
+            return []
+        
+        # Sort pairs by time
+        sorted_pairs = sorted(record_pairs, key=lambda p: p.check_in.timestamp if p.check_in else p.check_out.timestamp)
+        
+        all_groups = []
+        current_group = [sorted_pairs[0]]
+        
+        for i in range(1, len(sorted_pairs)):
+            prev_pair = sorted_pairs[i-1]
+            current_pair = sorted_pairs[i]
+            
+            # Calculate time gap
+            if prev_pair.check_out and current_pair.check_in:
+                gap_minutes = (current_pair.check_in.timestamp - prev_pair.check_out.timestamp).total_seconds() / 60
+                
+                if gap_minutes > TRAVEL_TIME_MAX_MINUTES:
+                    # Start new group
+                    all_groups.append(current_group)
+                    current_group = [current_pair]
+                else:
+                    current_group.append(current_pair)
+            else:
+                current_group.append(current_pair)
+        
+        all_groups.append(current_group)
+        return all_groups
+    
+    def _get_minutes_per_record_pair_group(self, group: List[RecordPair]) -> int:
+        """Calculate minutes for a group of record pairs with travel time"""
+        if not group:
+            return 0
+        
+        # Check for miss punches
+        for pair in group:
+            if pair.is_miss_punch:
+                return -1
+        
+        # Find overall start and end times for the group
+        start_time = min(pair.check_in.timestamp for pair in group if pair.check_in)
+        end_time = max(pair.check_out.timestamp for pair in group if pair.check_out)
+        
+        duration = end_time - start_time
+        return int(duration.total_seconds() / 60)
+
+
+class WeeklyTimeCalculator(TimeCalculator):
+    """Calculate weekly regular and overtime hours"""
+    
+    def __init__(self):
+        self.daily_calculators: List[DailyTimeCalculator] = []
+        self.total_minutes = 0
+        self.regular_minutes = 0
+        self.overtime_minutes = 0
+        self.include_travel_time = True  # Default setting
+    
+    def add_daily_calculator(self, daily_calc: DailyTimeCalculator):
+        """Add a daily time calculator to the weekly calculation"""
+        self.daily_calculators.append(daily_calc)
+    
+    def set_include_travel_time(self, include: bool):
+        """Set whether to include travel time in calculations"""
+        self.include_travel_time = include
+    
+    def calculate_time(self):
+        """Calculate weekly totals with regular and overtime split"""
+        self.total_minutes = 0
+        
+        for daily_calc in self.daily_calculators:
+            if self.include_travel_time:
+                daily_minutes = daily_calc.get_minutes_total_include_travel_time()
+            else:
+                daily_minutes = daily_calc.get_minutes_total_exclude_travel_time()
+            
+            if daily_minutes > 0:
+                self.total_minutes += daily_minutes
+        
+        # Calculate regular and overtime
+        if self.total_minutes > MAX_REGULAR_TIME_MINUTES:
+            self.regular_minutes = MAX_REGULAR_TIME_MINUTES
+        else:
+            self.regular_minutes = self.total_minutes
+        
+        self.overtime_minutes = self.total_minutes - self.regular_minutes
+    
+    @property
+    def total_hours(self) -> float:
+        """Get total hours as decimal"""
+        return self.total_minutes / 60.0
+    
+    @property
+    def regular_hours(self) -> float:
+        """Get regular hours as decimal"""
+        return self.regular_minutes / 60.0
+    
+    @property
+    def overtime_hours(self) -> float:
+        """Get overtime hours as decimal"""
+        return self.overtime_minutes / 60.0
+
+
+class RecordPairBuilder:
+    """Build record pairs from attendance records"""
+    
+    @staticmethod
+    def build_pairs_from_records(records: List[AttendanceRecord]) -> List[RecordPair]:
+        """Build check-in/check-out pairs from attendance records"""
+        if not records:
+            return []
+        
+        # Sort records by timestamp
+        sorted_records = sorted(records, key=lambda r: r.timestamp)
+        pairs = []
+        
+        i = 0
+        while i < len(sorted_records):
+            current_record = sorted_records[i]
+            
+            # Look for matching check-out record
+            check_out_record = None
+            if i + 1 < len(sorted_records):
+                next_record = sorted_records[i + 1]
+                # Simple pairing: assume alternating check-in/check-out
+                if current_record.record_type == 'check_in' and next_record.record_type == 'check_out':
+                    check_out_record = next_record
+                    i += 2  # Skip both records
+                else:
+                    i += 1
+            else:
+                i += 1
+            
+            # Create pair
+            if current_record.record_type == 'check_in':
+                pair = RecordPair(
+                    check_in=current_record,
+                    check_out=check_out_record,
+                    is_miss_punch=(check_out_record is None)
+                )
+            else:
+                # Orphaned check-out
+                pair = RecordPair(
+                    check_in=None,
+                    check_out=current_record,
+                    is_miss_punch=True
+                )
+            
+            pairs.append(pair)
+        
+        return pairs
+
+
+class WorkingHoursCalculator:
+    """Main calculator for employee working hours"""
+    
+    def __init__(self, include_travel_time: bool = True):
+        self.include_travel_time = include_travel_time
+    
+    @log_database_operations('working_hours_calculation')
+    def calculate_employee_hours(self, employee_id: str, start_date: datetime, end_date: datetime, 
+                                 attendance_records: List[Dict]) -> Dict[str, Any]:
+        """
+        Calculate working hours for an employee over a date range
+        
+        Args:
+            employee_id: Employee ID
+            start_date: Start date for calculation
+            end_date: End date for calculation
+            attendance_records: List of attendance records from database
+            
+        Returns:
+            Dictionary containing daily and weekly hour calculations
+        """
+        try:
+            # Convert database records to AttendanceRecord objects
+            records = []
+            for record in attendance_records:
+                # Handle both dictionary and SQLAlchemy object formats
+                if hasattr(record, '__dict__'):
+                    # SQLAlchemy object
+                    emp_id = str(record.employee_id)
+                    date_val = record.check_in_date
+                    time_val = record.check_in_time
+                    location = record.location_name
+                    record_id = record.id
+                else:
+                    # Dictionary
+                    emp_id = str(record['employee_id'])
+                    date_val = record['check_in_date']
+                    time_val = record['check_in_time']
+                    location = record['location_name']
+                    record_id = record['id']
+                
+                if emp_id == employee_id:
+                    att_record = AttendanceRecord(
+                        id=record_id,
+                        employee_id=emp_id,
+                        check_in_date=date_val,
+                        check_in_time=time_val,
+                        location_name=location,
+                        record_type='check_in'  # Default, could be enhanced
+                    )
+                    records.append(att_record)
+            
+            # Group records by date
+            daily_records = {}
+            for record in records:
+                date_key = record.check_in_date.strftime('%Y-%m-%d')
+                if date_key not in daily_records:
+                    daily_records[date_key] = []
+                daily_records[date_key].append(record)
+            
+            # Calculate daily hours
+            daily_hours = {}
+            weekly_calculators = []
+            
+            current_date = start_date
+            while current_date <= end_date:
+                date_key = current_date.strftime('%Y-%m-%d')
+                day_records = daily_records.get(date_key, [])
+                
+                daily_calc = DailyTimeCalculator()
+                
+                if day_records:
+                    # Build record pairs
+                    pairs = RecordPairBuilder.build_pairs_from_records(day_records)
+                    for pair in pairs:
+                        daily_calc.add_record_pair(pair)
+                
+                # Calculate daily totals
+                if self.include_travel_time:
+                    total_minutes = daily_calc.get_minutes_total_include_travel_time()
+                else:
+                    total_minutes = daily_calc.get_minutes_total_exclude_travel_time()
+                
+                daily_hours[date_key] = {
+                    'total_minutes': total_minutes,
+                    'total_hours': total_minutes / 60.0 if total_minutes > 0 else 0,
+                    'is_miss_punch': total_minutes < 0,
+                    'records_count': len(day_records)
+                }
+                
+                # Add to weekly calculator (group by week)
+                if current_date.weekday() == 0:  # Monday - start new week
+                    weekly_calc = WeeklyTimeCalculator()
+                    weekly_calc.set_include_travel_time(self.include_travel_time)
+                    weekly_calculators.append(weekly_calc)
+                
+                if weekly_calculators:
+                    weekly_calculators[-1].add_daily_calculator(daily_calc)
+                
+                current_date += timedelta(days=1)
+            
+            # Calculate weekly totals
+            weekly_hours = []
+            for week_calc in weekly_calculators:
+                week_calc.calculate_time()
+                weekly_hours.append({
+                    'total_hours': week_calc.total_hours,
+                    'regular_hours': week_calc.regular_hours,
+                    'overtime_hours': week_calc.overtime_hours,
+                    'total_minutes': week_calc.total_minutes,
+                    'regular_minutes': week_calc.regular_minutes,
+                    'overtime_minutes': week_calc.overtime_minutes
+                })
+            
+            # Calculate grand totals
+            grand_total_hours = sum(week['total_hours'] for week in weekly_hours)
+            grand_regular_hours = sum(week['regular_hours'] for week in weekly_hours)
+            grand_overtime_hours = sum(week['overtime_hours'] for week in weekly_hours)
+            
+            return {
+                'employee_id': employee_id,
+                'start_date': start_date.strftime('%Y-%m-%d'),
+                'end_date': end_date.strftime('%Y-%m-%d'),
+                'include_travel_time': self.include_travel_time,
+                'daily_hours': daily_hours,
+                'weekly_hours': weekly_hours,
+                'grand_totals': {
+                    'total_hours': grand_total_hours,
+                    'regular_hours': grand_regular_hours,
+                    'overtime_hours': grand_overtime_hours,
+                    'total_minutes': int(grand_total_hours * 60),
+                    'regular_minutes': int(grand_regular_hours * 60),
+                    'overtime_minutes': int(grand_overtime_hours * 60)
+                }
+            }
+            
+        except Exception as e:
+            print(f"❌ Error calculating working hours for employee {employee_id}: {e}")
+            raise e
+    
+    def calculate_all_employees_hours(self, start_date: datetime, end_date: datetime, 
+                                      attendance_records: List[Dict]) -> Dict[str, Any]:
+        """Calculate working hours for all employees in the given period"""
+        try:
+            # Get unique employee IDs
+            employee_ids = set()
+            for record in attendance_records:
+                if hasattr(record, '__dict__'):
+                    employee_ids.add(str(record.employee_id))
+                else:
+                    employee_ids.add(str(record['employee_id']))
+            
+            results = {}
+            for emp_id in employee_ids:
+                results[emp_id] = self.calculate_employee_hours(emp_id, start_date, end_date, attendance_records)
+            
+            return {
+                'calculation_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                'period_start': start_date.strftime('%Y-%m-%d'),
+                'period_end': end_date.strftime('%Y-%m-%d'),
+                'include_travel_time': self.include_travel_time,
+                'employee_count': len(employee_ids),
+                'employees': results
+            }
+            
+        except Exception as e:
+            print(f"❌ Error calculating hours for all employees: {e}")
+            raise e