#!/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 working_hours_calculator import WorkingHoursCalculator 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) def _get_employee_names(self, attendance_records: List[Dict]) -> Dict[str, str]: """Get employee names - fallback method if names not provided""" print("⚠️ Excel exporter falling back to internal name lookup - this should not normally happen") return {} # Return empty dict - names should be provided by the route def _get_employee_names(self, attendance_records: List[Dict]) -> Dict[str, str]: """Get employee names using the same CAST method as attendance report""" employee_names = {} try: from flask import current_app from sqlalchemy import text # Get unique employee IDs from attendance records employee_ids = [] for record in attendance_records: if hasattr(record, '__dict__'): emp_id = str(record.employee_id) else: emp_id = str(record['employee_id']) if emp_id not in employee_ids: employee_ids.append(emp_id) if employee_ids: # Use the same SQL approach as attendance report - JOIN with CAST placeholders = ','.join([f"'{emp_id}'" for emp_id in employee_ids]) # Import db from current app context from app import db employee_query = db.session.execute(text(f""" SELECT ad.employee_id, CONCAT(e.firstName, ' ', e.lastName) as full_name FROM attendance_data ad LEFT JOIN employee e ON CAST(ad.employee_id AS UNSIGNED) = e.id WHERE ad.employee_id IN ({placeholders}) GROUP BY ad.employee_id, e.firstName, e.lastName """)) for row in employee_query: if row[1]: # Only add if we got a name employee_names[str(row[0])] = row[1] print(f"📊 Excel exporter retrieved names for {len(employee_names)} employees using CAST method") except Exception as e: print(f"⚠️ Excel exporter could not load employee names: {e}") import traceback print(f"⚠️ Traceback: {traceback.format_exc()}") return employee_names @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) -> 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 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')}") # Get employee names using the same method as payroll routes if employee_names is None: employee_names = self._get_employee_names(attendance_records) # Calculate working hours calculator = WorkingHoursCalculator() 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}:Q{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}:Q{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}:Q{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}:Q{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)), ("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) -> 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 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')}") # Get employee names using the same method as payroll routes if employee_names is None: employee_names = self._get_employee_names(attendance_records) # Calculate working hours calculator = WorkingHoursCalculator() 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 @log_database_operations('template_hours_export') def create_template_format_report(self, start_date: datetime, end_date: datetime, attendance_records: List[Dict], employee_names: Dict[str, str] = None, project_name: str = None) -> io.BytesIO: """ Create a template-format report matching the provided Excel template. This creates a single sheet with all employees' detailed reports. 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 project_name: Project name for the report header Returns: BytesIO buffer containing the Excel file """ try: print(f"📊 Creating single-sheet template format report from {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}") # Get employee names using the same method as payroll routes if employee_names is None: employee_names = self._get_employee_names(attendance_records) # Calculate working hours calculator = WorkingHoursCalculator() hours_data = calculator.calculate_all_employees_hours(start_date, end_date, attendance_records) # Create workbook with single sheet workbook = Workbook() worksheet = workbook.active worksheet.title = "Hours Report" # Setup styles self._setup_template_styles(workbook) # Write main report headers once at the top current_row = self._write_main_report_headers(worksheet, start_date, end_date, project_name) # Write all employees data in one sheet 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}" # Write employee section current_row = self._write_employee_section(worksheet, employee_id, employee_name, emp_data, start_date, end_date, attendance_records, current_row) # Add spacing between employees current_row += 2 # Auto-adjust column widths to match template self._adjust_template_columns(worksheet) # Save to BytesIO excel_buffer = io.BytesIO() workbook.save(excel_buffer) excel_buffer.seek(0) print("✅ Single-sheet template format report Excel file created successfully") return excel_buffer except Exception as e: print(f"❌ Error creating template format report: {e}") import traceback print(f"❌ Traceback: {traceback.format_exc()}") raise e def _setup_template_styles(self, workbook: Workbook): """Setup Excel cell styles for template format""" # Company name style (matches template) self.template_company_style = { 'font': Font(name="Arial", size=14, bold=True), 'alignment': Alignment(horizontal="left", vertical="center") } # Report title style self.template_title_style = { 'font': Font(name="Arial", size=12, bold=True), 'alignment': Alignment(horizontal="left", vertical="center") } # Project name style self.template_project_style = { 'font': Font(name="Arial", size=11, bold=True), 'alignment': Alignment(horizontal="left", vertical="center") } # Date range style self.template_date_style = { 'font': Font(name="Arial", size=11), 'alignment': Alignment(horizontal="left", vertical="center") } # Employee info style self.template_employee_style = { 'font': Font(name="Arial", size=11, bold=True), 'alignment': Alignment(horizontal="left", vertical="center") } # Column header style self.template_header_style = { 'font': Font(name="Arial", size=10, bold=True), 'fill': PatternFill(start_color="D9E1F2", end_color="D9E1F2", 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 cell style self.template_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") ) } def _adjust_template_columns(self, worksheet): """Adjust column widths to match template format""" # Column widths based on template analysis column_widths = { 'A': 12, # Day 'B': 10.6, # Date 'C': 12.6, # In 'D': 12.6, # Out 'E': 34, # Location 'F': 5.6, # Zone 'G': 15.4, # Hours/Building 'H': 10.9, # Daily Total 'I': 14.0, # Regular Hours 'J': 9.6, # OT Hours 'K': 35, # Building Address 'L': 35, # Recorded Location 'M': 10.0, # Distance 'N': 15.0, # Possible Violation } for col_letter, width in column_widths.items(): worksheet.column_dimensions[col_letter].width = width def _write_main_report_headers(self, worksheet, start_date: datetime, end_date: datetime, project_name: str) -> int: """Write main report headers at the top of the sheet""" current_row = 1 # 1. Company Name (merged across columns A-N) cell = worksheet.cell(row=current_row, column=1, value=self.company_name) self._apply_style(cell, self.template_company_style) worksheet.merge_cells(f'A{current_row}:N{current_row}') current_row += 1 # 2. Report title (merged across columns A-N) cell = worksheet.cell(row=current_row, column=1, value="Summary report of Hours worked") self._apply_style(cell, self.template_title_style) worksheet.merge_cells(f'A{current_row}:N{current_row}') current_row += 1 # 3. Project name (merged across columns A-N) project_display = project_name if project_name else "[Project Name]" cell = worksheet.cell(row=current_row, column=1, value=project_display) self._apply_style(cell, self.template_project_style) worksheet.merge_cells(f'A{current_row}:N{current_row}') current_row += 1 # 4. Date range (merged across columns A-N) date_range = f"Date range: {start_date.strftime('%m/%d/%Y')} to {end_date.strftime('%m/%d/%Y')}" cell = worksheet.cell(row=current_row, column=1, value=date_range) self._apply_style(cell, self.template_date_style) worksheet.merge_cells(f'A{current_row}:N{current_row}') current_row += 2 # Add extra space return current_row def _write_employee_section(self, worksheet, employee_id: str, employee_name: str, emp_data: Dict, start_date: datetime, end_date: datetime, attendance_records: List[Dict], start_row: int) -> int: """Write individual employee section with FIXED WEEKLY OVERTIME CALCULATION""" current_row = start_row # Employee info header (merged across columns A-O) employee_info = f"Employee ID {employee_id}: {employee_name}" cell = worksheet.cell(row=current_row, column=1, value=employee_info) self._apply_style(cell, self.template_employee_style) worksheet.merge_cells(f'A{current_row}:N{current_row}') current_row += 1 # Column headers for this employee headers = ["Day", "Date", "In", "Out", "Location", "Zone", "Hours/Building", "Daily Total", "Regular Hours", "OT Hours", "Building Address", "Recorded Location", "Distance", "Possible Violation"] for col, header in enumerate(headers, 1): cell = worksheet.cell(row=current_row, column=col, value=header) self._apply_style(cell, self.template_header_style) current_row += 1 # Get attendance records for this employee for location info employee_records = [record for record in attendance_records if str(record.employee_id) == employee_id] # Group attendance records by date for location info daily_location_data = {} for record in employee_records: date_key = record.check_in_date.strftime('%Y-%m-%d') if date_key not in daily_location_data: daily_location_data[date_key] = { 'records': [], 'location': '', 'building_address': '' } daily_location_data[date_key]['records'].append(record) # Get location info for each day for date_str, day_info in daily_location_data.items(): sorted_records = sorted(day_info['records'], key=lambda x: x.check_in_time) if sorted_records: # Get location info from QR code if hasattr(sorted_records[0], 'qr_code') and sorted_records[0].qr_code: day_info['location'] = sorted_records[0].qr_code.location or '' day_info['building_address'] = sorted_records[0].qr_code.location_address or '' # FIXED: Initialize ALL weekly totals tracking variables weekly_total_hours = 0 # Track overall totals for grand total grand_regular_hours = 0 grand_ot_hours = 0 grand_total_hours = 0 total_pairs_written = 0 # Track total pairs across all days # Track week boundaries (assuming payroll period starts on Monday) current_week_start = None # Log the overtime calculation change print(f"🔧 FIXED: Using weekly overtime calculation (40 hrs/week) for employee {employee_id}") # Write data rows using the calculated daily hours from emp_data for date_str in sorted(emp_data['daily_hours'].keys()): date_obj = datetime.strptime(date_str, '%Y-%m-%d') day_hours_data = emp_data['daily_hours'][date_str] # Skip days with miss punch, but INCLUDE days with valid hours even if single period if day_hours_data.get('is_miss_punch', False): print(f"⚠️ Skipping {date_str} - Miss punch detected") continue # Include days with valid working hours (single periods should show Daily Total) if day_hours_data.get('total_hours', 0) <= 0: print(f"⚠️ Skipping {date_str} - No working hours") continue print(f"✅ Including {date_str} - Working hours: {day_hours_data.get('total_hours', 0):.2f}") # Calculate week boundaries week_start = date_obj - timedelta(days=date_obj.weekday()) # Monday of the week # FIXED: Check if we've moved to a new week and need to write weekly total if current_week_start is not None and week_start != current_week_start: # Calculate weekly overtime using 40-hour threshold week_regular = min(weekly_total_hours, 40.0) week_overtime = max(0, weekly_total_hours - 40.0) # Write weekly total row for previous week current_row = self._write_weekly_total_row(worksheet, current_row, week_regular, week_overtime, weekly_total_hours) # Add to grand totals grand_regular_hours += week_regular grand_ot_hours += week_overtime # Reset weekly counters weekly_total_hours = 0 current_week_start = week_start total_hours = day_hours_data.get('total_hours', 0) # FIXED: Remove daily overtime calculation - now calculated weekly only # OLD CODE: regular_hours = min(total_hours, 8.0) # Max 8 regular hours per day # OLD CODE: ot_hours = max(0, total_hours - 8.0) # Add to weekly totals (no daily overtime calculation) weekly_total_hours += total_hours grand_total_hours += total_hours # Get location info for this date location_info = daily_location_data.get(date_str, {}) location = location_info.get('location', '') building_address = location_info.get('building_address', '') # Get all records for this day, sorted by time day_records = [] if date_str in daily_location_data: day_records = sorted(daily_location_data[date_str]['records'], key=lambda x: x.check_in_time) # Write multiple pairs for the day (like template shows FRIDAY appearing twice) pairs_written = 0 if len(day_records) >= 2: # Calculate total number of pairs for this day total_pairs_for_day = len(day_records) // 2 print(f"📊 Day {date_str}: {len(day_records)} records = {total_pairs_for_day} pairs") # Create pairs from consecutive records for i in range(0, len(day_records) - 1, 2): if i + 1 < len(day_records): start_record = day_records[i] end_record = day_records[i + 1] # FIXED: Pass total_hours without daily overtime split current_row = self._write_record_pair_row( worksheet, current_row, date_obj, start_record, end_record, location, building_address, total_hours, 0, 0, # No daily regular/ot split pairs_written, total_hours, total_pairs_for_day ) pairs_written += 1 total_pairs_written += 1 # Track total pairs else: # Single record or no records - write one row start_record = day_records[0] if day_records else None current_row = self._write_single_record_row( worksheet, current_row, date_obj, start_record, location, building_address, total_hours, 0, 0 # No daily regular/ot split ) # FIXED: Write final weekly total with proper weekly overtime calculation if weekly_total_hours > 0: week_regular = min(weekly_total_hours, 40.0) week_overtime = max(0, weekly_total_hours - 40.0) current_row = self._write_weekly_total_row(worksheet, current_row, week_regular, week_overtime, weekly_total_hours) # Add final week to grand totals grand_regular_hours += week_regular grand_ot_hours += week_overtime # Write grand total row current_row = self._write_grand_total_row(worksheet, current_row, grand_regular_hours, grand_ot_hours) # Add space between employees current_row += 2 # Log the export action with fixed overtime calculation print(f"✅ FIXED Template format export: Employee {employee_id} ({employee_name}) data written with weekly overtime calculation (40 hrs/week)") print(f"📊 Total: {grand_total_hours:.2f} hrs, Regular: {grand_regular_hours:.2f} hrs, Overtime: {grand_ot_hours:.2f} hrs") return current_row def _write_record_pair_row(self, worksheet, current_row: int, date_obj: datetime, start_record, end_record, location: str, building_address: str, day_total_hours: float, regular_hours: float, ot_hours: float, pair_index: int, daily_total_hours: float, total_pairs_for_day: int = 1) -> int: """Write a single record pair row (in/out times)""" day_name = date_obj.strftime('%A').upper() date_str = date_obj.strftime('%m/%d/%Y') # Calculate hours for this specific pair if start_record and end_record: start_time = start_record.check_in_time end_time = end_record.check_in_time start_datetime = datetime.combine(start_record.check_in_date, start_time) end_datetime = datetime.combine(end_record.check_in_date, end_time) pair_duration = (end_datetime - start_datetime).total_seconds() / 3600 pair_hours = round(pair_duration, 2) else: start_time = start_record.check_in_time if start_record else None end_time = end_record.check_in_time if end_record else None pair_hours = 0 # Format times check_in_time = start_time.strftime('%I:%M:%S %p') if start_time else '' check_out_time = end_time.strftime('%I:%M:%S %p') if end_time else '' # Get location accuracy info location_accuracy = None recorded_location = '' distance_value = '' possible_violation = 'No' if start_record and hasattr(start_record, 'location_accuracy'): location_accuracy = getattr(start_record, 'location_accuracy', None) if location_accuracy is not None: try: accuracy_value = float(location_accuracy) distance_value = f"{accuracy_value:.3f}" if accuracy_value < 0.3: recorded_location = building_address possible_violation = "No" else: recorded_location = f"GPS Location (Accuracy: {distance_value} miles)" possible_violation = "Yes" if accuracy_value > 0.5 else "Possible" except (ValueError, TypeError): distance_value = "Unknown" recorded_location = "GPS Location (Unknown Accuracy)" possible_violation = "Possible" # Create building address hyperlink if available building_address_display = building_address if building_address and "," in building_address: # Create Google Maps hyperlink maps_url = f"https://www.google.com/maps/place/{building_address.replace(' ', '+')}" building_address_display = f'=HYPERLINK("{maps_url}","{building_address}")' # Create recorded location hyperlink if it's a GPS location recorded_location_display = recorded_location if recorded_location and "GPS Location" not in recorded_location and "," in recorded_location: maps_url = f"https://www.google.com/maps/place/{recorded_location.replace(' ', '+')}" recorded_location_display = f'=HYPERLINK("{maps_url}","{recorded_location}")' # Determine if this is the last pair of the day (for daily total) is_last_pair = (pair_index == total_pairs_for_day - 1) # Show daily total on second+ pairs daily_total_display = daily_total_hours if is_last_pair else "" row_data = [ day_name, # A - Day date_str, # B - Date check_in_time, # C - In check_out_time, # D - Out location, # E - Location "", # F - Zone (empty) pair_hours, # G - Hours/Building daily_total_display, # H - Daily Total (only on last pair) "", # I - Regular Hours (only on last pair) "", # J - OT Hours (only on last pair) building_address_display, # K - Building Address recorded_location_display, # L - Recorded Location distance_value, # M - Distance possible_violation # N - Possible Violation ] # Write the row for col, value in enumerate(row_data, 1): cell = worksheet.cell(row=current_row, column=col, value=value) self._apply_style(cell, self.template_data_style) return current_row + 1 def _write_single_record_row(self, worksheet, current_row: int, date_obj: datetime, record, location: str, building_address: str, total_hours: float, regular_hours: float, ot_hours: float) -> int: """Write a single record row when there's only one check-in""" day_name = date_obj.strftime('%A').upper() date_str = date_obj.strftime('%m/%d/%Y') # Single record - estimate check-out time if record: check_in_time = record.check_in_time.strftime('%I:%M:%S %p') # Estimate check-out based on total hours check_in_datetime = datetime.combine(record.check_in_date, record.check_in_time) estimated_checkout = check_in_datetime + timedelta(hours=total_hours) check_out_time = estimated_checkout.strftime('%I:%M:%S %p') else: check_in_time = '' check_out_time = '' # Get location accuracy info (same logic as pair row) location_accuracy = None recorded_location = '' distance_value = '' possible_violation = 'No' if record and hasattr(record, 'location_accuracy'): location_accuracy = getattr(record, 'location_accuracy', None) if location_accuracy is not None: try: accuracy_value = float(location_accuracy) distance_value = f"{accuracy_value:.3f}" if accuracy_value < 0.3: recorded_location = building_address possible_violation = "No" else: recorded_location = f"GPS Location (Accuracy: {distance_value} miles)" possible_violation = "Yes" if accuracy_value > 0.5 else "Possible" except (ValueError, TypeError): distance_value = "Unknown" recorded_location = "GPS Location (Unknown Accuracy)" possible_violation = "Possible" row_data = [ day_name, # A - Day date_str, # B - Date check_in_time, # C - In check_out_time, # D - Out location, # E - Location "", # F - Zone total_hours, # G - Hours/Building total_hours, # H - Daily Total "", # I - Regular Hours "", # J - OT Hours building_address, # K - Building Address recorded_location, # L - Recorded Location distance_value, # M - Distance possible_violation # N - Possible Violation ] # Write the row for col, value in enumerate(row_data, 1): cell = worksheet.cell(row=current_row, column=col, value=value) self._apply_style(cell, self.template_data_style) return current_row + 1 def _write_weekly_total_row(self, worksheet, current_row: int, weekly_regular: float, weekly_ot: float, weekly_total: float) -> int: """Write weekly total row matching template format""" # Weekly Total row (columns G-J) cell = worksheet.cell(row=current_row, column=7, value="Weekly Total: ") # G self._apply_style(cell, self.template_data_style) cell.font = Font(name="Arial", size=10, bold=True) cell = worksheet.cell(row=current_row, column=8, value=round(weekly_total, 2)) # H - Daily Total self._apply_style(cell, self.template_data_style) cell.font = Font(name="Arial", size=10, bold=True) cell = worksheet.cell(row=current_row, column=9, value=round(weekly_regular, 2)) # I - Regular Hours self._apply_style(cell, self.template_data_style) cell.font = Font(name="Arial", size=10, bold=True) cell = worksheet.cell(row=current_row, column=10, value=round(weekly_ot, 2)) # J - OT Hours self._apply_style(cell, self.template_data_style) cell.font = Font(name="Arial", size=10, bold=True) # Log weekly total print(f"✅ Template export: Weekly total written - Regular: {weekly_regular:.2f}, OT: {weekly_ot:.2f}, Total: {weekly_total:.2f}") return current_row + 1 def _write_grand_total_row(self, worksheet, current_row: int, grand_regular: float, grand_ot: float) -> int: """Write grand total row matching template format""" # Grand Total row (columns G, I, J) cell = worksheet.cell(row=current_row, column=7, value="GRAND TOTAL: ") # G self._apply_style(cell, self.template_data_style) cell.font = Font(name="Arial", size=10, bold=True) cell = worksheet.cell(row=current_row, column=9, value=round(grand_regular, 2)) # I - Regular Hours self._apply_style(cell, self.template_data_style) cell.font = Font(name="Arial", size=10, bold=True) cell = worksheet.cell(row=current_row, column=10, value=round(grand_ot, 2)) # J - OT Hours self._apply_style(cell, self.template_data_style) cell.font = Font(name="Arial", size=10, bold=True) # Log grand total print(f"✅ Template export: Grand total written - Regular: {grand_regular:.2f}, OT: {grand_ot:.2f}") return current_row + 1