from django.shortcuts import render, redirect, get_object_or_404 from django.contrib.auth import authenticate, login, logout from django.contrib.auth.decorators import login_required from django.contrib import messages from django.utils import timezone from django.http import HttpResponse, JsonResponse from django.db.models import Q from django.core.mail import send_mail from django.template.loader import render_to_string from django.conf import settings from django.utils import timezone from django.http import HttpResponse, JsonResponse import sys import csv import io import xlsxwriter from datetime import timedelta, date from .models import ( Company, CostCenter, EmployeeProfile, VacationRequest, VacationLog, ClockRecord, ClockReportApproval ) from .forms import ( LoginForm, EmployeeForm, VacationRequestForm, ApprovalForm, ReportForm, ManualVacationForm ) from .decorators import role_required from .utils import calculate_vacation_balance def login_view(request): """View for user login""" if request.user.is_authenticated: return redirect('dashboard') error_message = None if request.method == 'POST': username = request.POST.get('username') password = request.POST.get('password') user = authenticate(request, username=username, password=password) if user is not None: login(request, user) # Redirect based on intended URL or default to dashboard next_url = request.GET.get('next', 'dashboard') return redirect(next_url) else: error_message = 'Nome de usuário ou senha inválidos.' return render(request, 'login_standalone.html', {'error_message': error_message}) def logout_view(request): """View for user logout""" logout(request) return redirect('login') def home(request): """Home page view that shows information about the system""" # If user is already logged in, redirect to dashboard if request.user.is_authenticated: return redirect('dashboard') return render(request, 'index.html') def dashboard(request): """Main dashboard view that redirects based on user role""" if not hasattr(request.user, 'profile'): messages.error(request, "Perfil não encontrado. Contate o administrador.") return redirect('logout') user_role = request.user.profile.role if user_role == EmployeeProfile.USER_ROLE_EMPLOYEE: return redirect('employee_dashboard') elif user_role == EmployeeProfile.USER_ROLE_MANAGER: return redirect('manager_dashboard') elif user_role == EmployeeProfile.USER_ROLE_ADMIN: return redirect('admin_dashboard') elif user_role == EmployeeProfile.USER_ROLE_INTERN: # 🔽 Adicione esta linha return redirect('intern_dashboard') else: messages.error(request, "Papel de usuário inválido.") return redirect('logout') @login_required @role_required(EmployeeProfile.USER_ROLE_EMPLOYEE) def employee_dashboard(request): """Dashboard for regular employees""" employee = request.user.profile # Get vacation balance vacation_balance = calculate_vacation_balance(employee) # Solicitações pendentes pending_requests = VacationRequest.objects.filter( employee=employee, status=VacationRequest.STATUS_PENDING ).order_by('start_date') # Solicitações aprovadas approved_requests = VacationRequest.objects.filter( employee=employee, status=VacationRequest.STATUS_APPROVED ).order_by('-start_date') # Histórico (exceto pendentes) vacation_history = VacationRequest.objects.filter( employee=employee ).exclude( status=VacationRequest.STATUS_PENDING ).order_by('-start_date') # Estagiários sob tutela (caso seja tutor) interns = [] if employee.is_tutor: interns = EmployeeProfile.objects.filter(role='intern', tutor=employee, is_active=True) context = { 'employee': employee, 'vacation_balance': vacation_balance, 'my_pending_requests': pending_requests, 'my_approved_requests': approved_requests, 'my_vacation_history': vacation_history, 'today_plus_15': timezone.now().date() + timedelta(days=15), 'interns': interns, # ✅ incluído aqui } return render(request, 'employee/dashboard.html', context) from .forms import VacationChoiceForm from .models import VacationRequest, VacationLog from .utils import calculate_vacation_balance from datetime import timedelta from django.utils import timezone FLEXIBLE_VACATION_RULES = { 'Gozo 5 dias': {'periods': [5], 'sold_days': 0}, 'Gozo 6 dias': {'periods': [6], 'sold_days': 0}, 'Gozo 7 dias': {'periods': [7], 'sold_days': 0}, 'Gozo 12 dias': {'periods': [12], 'sold_days': 0}, 'Gozo 14 dias': {'periods': [14], 'sold_days': 0}, 'Gozo 15 + venda 5': {'periods': [15], 'sold_days': 5}, 'Gozo 18 dias': {'periods': [18], 'sold_days': 0}, 'Gozo 20 + venda 10': {'periods': [20], 'sold_days': 10}, 'Gozo 30 dias': {'periods': [30], 'sold_days': 0}, 'Gozo 15 dias': {'periods': [15], 'sold_days': 0}, } from .forms import VacationChoiceForm, VACATION_RULES from django.utils.dateparse import parse_date from django.shortcuts import render, redirect from django.contrib.auth.decorators import login_required from django.contrib import messages from django.core.exceptions import ValidationError # <-- adicione esta linha from datetime import timedelta from django.utils.dateparse import parse_date @login_required @role_required(EmployeeProfile.USER_ROLE_EMPLOYEE, EmployeeProfile.USER_ROLE_MANAGER) def request_vacation(request): employee = request.user.profile if request.method == 'POST': # Fase de confirmação final if 'confirm' in request.POST: start_date = request.POST.get('start_date') option = request.POST.get('vacation_option') rule = VACATION_RULES.get(option) if not start_date or not rule: messages.error(request, "Erro ao confirmar solicitação: dados incompletos.") return redirect('request_vacation') try: start_date = parse_date(start_date) if not start_date: raise ValueError("Data inválida") except Exception: messages.error(request, "Data de início inválida.") return redirect('request_vacation') end_date = start_date + timedelta(days=sum(rule['periods']) - 1) total_solicitado = sum(rule['periods']) + rule.get('sold_days', 0) saldo = calculate_vacation_balance(employee) if total_solicitado > saldo: messages.error(request, f"Saldo insuficiente. Você possui {saldo} dias disponíveis.") return redirect('request_vacation') # Criação com tratamento de erro de validação try: vacation = VacationRequest( employee=employee, start_date=start_date, end_date=end_date, selling_days=rule.get('sold_days', 0), status=VacationRequest.STATUS_PENDING ) vacation.full_clean() # chama .clean() + validações de campos vacation.save() VacationLog.objects.create( vacation_request=vacation, action=VacationLog.ACTION_REQUEST, performed_by=request.user, details=f"Solicitação via opção: {option}" ) messages.success(request, "Solicitação de férias enviada com sucesso.") return redirect('employee_dashboard') except ValidationError as e: for field, errors in e.message_dict.items(): for error in errors: messages.error(request, error) return redirect('request_vacation') # Fase inicial: envio do formulário de escolha form = VacationChoiceForm(request.POST) if form.is_valid(): start_date = form.cleaned_data['start_date'] option = form.cleaned_data['vacation_option'] rule = VACATION_RULES.get(option) if not rule: form.add_error('vacation_option', "Opção de férias inválida.") else: periods = rule['periods'] sold_days = rule['sold_days'] current_date = start_date period_dates = [] for days in periods: end_date = current_date + timedelta(days=days - 1) period_dates.append({'start': current_date, 'end': end_date}) current_date = end_date + timedelta(days=1) return render(request, 'employee/confirm_vacation.html', { 'form': form, 'periods': period_dates, 'sold_days': sold_days, 'total_days': sum(periods) + sold_days, 'return_date': current_date, }) # Se inválido, renderiza o formulário com os erros balance = calculate_vacation_balance(employee) return render(request, 'employee/request_vacation.html', { 'form': form, 'vacation_balance': balance, }) # GET request else: form = VacationChoiceForm() balance = calculate_vacation_balance(employee) return render(request, 'employee/request_vacation.html', { 'form': form, 'vacation_balance': balance }) @login_required def view_history(request): vacations = VacationRequest.objects.filter(employee=request.user.profile).order_by('-start_date') context = { 'vacation_history': vacations, 'today_plus_15': timezone.now().date() + timedelta(days=15), } return render(request, 'employee/history.html', context) @login_required @role_required(EmployeeProfile.USER_ROLE_MANAGER) def manager_dashboard(request): manager = request.user.profile # Parte 1: Dados da equipe pending_requests = VacationRequest.objects.filter( employee__cost_centers__in=manager.cost_centers.all(), status=VacationRequest.STATUS_PENDING ).exclude(employee=manager) \ .exclude(employee__role=EmployeeProfile.USER_ROLE_MANAGER) \ .distinct() upcoming_vacations = VacationRequest.objects.filter( employee__cost_centers__in=manager.cost_centers.all(), status=VacationRequest.STATUS_APPROVED, start_date__gte=timezone.now().date() ).order_by('start_date') current_vacations = VacationRequest.objects.filter( employee__cost_centers__in=manager.cost_centers.all(), status=VacationRequest.STATUS_APPROVED, start_date__lte=timezone.now().date(), end_date__gte=timezone.now().date() ).order_by('end_date') # Parte 2: Dados pessoais do gestor my_vacation_balance = calculate_vacation_balance(manager) my_pending_requests = VacationRequest.objects.filter( employee=manager, status=VacationRequest.STATUS_PENDING ).order_by('start_date') my_approved_requests = VacationRequest.objects.filter( employee=manager, status=VacationRequest.STATUS_APPROVED ).order_by('-start_date') my_vacation_history = VacationRequest.objects.filter( employee=manager ).exclude( status=VacationRequest.STATUS_PENDING ).order_by('-start_date') # Parte 3: Estagiários sob tutela (se for tutor) intern_reports = [] if manager.is_tutor: intern_reports = EmployeeProfile.objects.filter(role='intern', tutor=manager, is_active=True) context = { # Equipe 'pending_requests': pending_requests, 'upcoming_vacations': upcoming_vacations, 'current_vacations': current_vacations, # Gestor 'vacation_balance': my_vacation_balance, 'my_pending_requests': my_pending_requests, 'my_approved_requests': my_approved_requests, 'my_vacation_history': my_vacation_history, 'today_plus_15': timezone.now().date() + timedelta(days=15), # Estagiários 'intern_reports': intern_reports, } return render(request, 'manager/dashboard.html', context) @login_required @role_required(EmployeeProfile.USER_ROLE_MANAGER) def pending_requests(request): manager = request.user.profile # Só colaboradores dos centros de custo do gestor pending_requests = ( VacationRequest.objects .filter( employee__cost_centers__in=manager.cost_centers.all(), status=VacationRequest.STATUS_PENDING ) .exclude(employee=manager) # NÃO pode aprovar as próprias férias .exclude(employee__role=EmployeeProfile.USER_ROLE_MANAGER) # NÃO pode aprovar outros gestores .select_related('employee', 'employee__user') .prefetch_related('employee__cost_centers') .distinct() .order_by('start_date') ) return render(request, 'manager/pending_requests.html', { 'pending_requests': pending_requests }) @login_required @role_required(EmployeeProfile.USER_ROLE_ADMIN) # somente RH pode aprovar/rejeitar def review_request(request, vacation_id): """View for HR (admin) to review and approve/reject vacation requests""" vacation_request = get_object_or_404( VacationRequest, id=vacation_id, status=VacationRequest.STATUS_PENDING ) if request.method == 'POST': form = ApprovalForm(request.POST) if form.is_valid(): action = form.cleaned_data['action'] if action == 'approve': vacation_request.status = VacationRequest.STATUS_APPROVED vacation_request.approved_by = request.user.profile vacation_request.approval_date = timezone.now() vacation_request.save() VacationLog.objects.create( vacation_request=vacation_request, action=VacationLog.ACTION_APPROVE, performed_by=request.user, details="Solicitação de férias aprovada" ) # Notifica colaborador try: if vacation_request.employee.user.email: send_mail( 'Solicitação de Férias Aprovada', f"Sua solicitação de férias de {vacation_request.start_date.strftime('%d/%m/%Y')} a {vacation_request.end_date.strftime('%d/%m/%Y')} foi aprovada.", settings.DEFAULT_FROM_EMAIL, [vacation_request.employee.user.email], fail_silently=True, ) except Exception as e: print(f"Erro ao enviar e-mail: {e}") messages.success(request, "Solicitação aprovada com sucesso.") return redirect('pending_requests') elif action == 'reject': rejection_reason = form.cleaned_data['rejection_reason'] vacation_request.status = VacationRequest.STATUS_REJECTED vacation_request.rejection_reason = rejection_reason vacation_request.save() VacationLog.objects.create( vacation_request=vacation_request, action=VacationLog.ACTION_REJECT, performed_by=request.user, details=f"Rejeitado. Motivo: {rejection_reason}" ) try: if vacation_request.employee.user.email: send_mail( 'Solicitação de Férias Rejeitada', f"Sua solicitação de férias de {vacation_request.start_date.strftime('%d/%m/%Y')} a {vacation_request.end_date.strftime('%d/%m/%Y')} foi rejeitada. Motivo: {rejection_reason}", settings.DEFAULT_FROM_EMAIL, [vacation_request.employee.user.email], fail_silently=True, ) except Exception as e: print(f"Erro ao enviar e-mail: {e}") messages.success(request, "Solicitação rejeitada.") return redirect('pending_requests') else: form = ApprovalForm() context = { 'vacation_request': vacation_request, 'form': form, } return render(request, 'admin/review_request.html', context) @login_required @role_required(EmployeeProfile.USER_ROLE_MANAGER) def team_calendar(request): manager = request.user.profile # Obter centros de custo do gestor cost_centers = manager.cost_centers.all() # Buscar colaboradores dos centros (excluindo o gestor) team_members = ( EmployeeProfile.objects .filter(cost_centers__in=cost_centers, is_active=True) .exclude(id=manager.id) .select_related('user', 'company') .prefetch_related('cost_centers') .order_by('cost_centers__name', 'user__first_name') .distinct() ) # Buscar férias aprovadas vacations = VacationRequest.objects.filter( employee__in=team_members, status=VacationRequest.STATUS_APPROVED ).order_by('start_date') # Filtro por data start_date = request.GET.get('start_date') end_date = request.GET.get('end_date') if start_date: try: start_date = date.fromisoformat(start_date) vacations = vacations.filter(start_date__gte=start_date) except ValueError: start_date = None if end_date: try: end_date = date.fromisoformat(end_date) vacations = vacations.filter(end_date__lte=end_date) except ValueError: end_date = None # Agrupar por centro de custo grouped_members = {} for member in team_members: for cc in member.cost_centers.all(): grouped_members.setdefault(cc.name, []).append(member) context = { 'grouped_members': grouped_members, 'vacations': vacations, 'start_date': start_date, 'end_date': end_date, } return render(request, 'manager/team_calendar.html', context) from django.db.models.functions import TruncMonth from django.db.models import Count from django.db.models.functions import TruncMonth from django.db.models import Count, Q from django.contrib.auth.decorators import login_required from django.utils import timezone from django.db.models.functions import TruncMonth from django.db.models import Count, Q from datetime import timedelta from django.shortcuts import render from vacations.models import VacationRequest, EmployeeProfile, Company, CostCenter from vacations.decorators import role_required @login_required @role_required(EmployeeProfile.USER_ROLE_ADMIN) def admin_dashboard(request): today = timezone.now().date() in_90_days = today + timedelta(days=90) last_month = today - timedelta(days=30) # Filtros recebidos via GET company_filter = request.GET.get('company') cost_center_filter = request.GET.get('cost_center') # Base da query para férias futuras upcoming_qs = VacationRequest.objects.filter( status=VacationRequest.STATUS_APPROVED, start_date__gte=today, start_date__lte=in_90_days ) # Aplica os filtros, se houver if company_filter: upcoming_qs = upcoming_qs.filter(employee__company__name=company_filter) if cost_center_filter: upcoming_qs = upcoming_qs.filter(employee__cost_centers__name=cost_center_filter) # Gráfico: agrupando por mês upcoming_vacations = upcoming_qs.annotate(month=TruncMonth('start_date')) \ .values('month').annotate(count=Count('id')).order_by('month') chart_data = { 'labels': [v['month'].strftime('%b/%Y') for v in upcoming_vacations], 'data': [v['count'] for v in upcoming_vacations] } # Status de aprovação por departamento com gestor dinâmico status_por_departamento = CostCenter.objects.filter(is_active=True).annotate( pending_count=Count('employees__vacation_requests', filter=Q( employees__vacation_requests__status=VacationRequest.STATUS_PENDING )), approved_count=Count('employees__vacation_requests', filter=Q( employees__vacation_requests__status=VacationRequest.STATUS_APPROVED, employees__vacation_requests__approval_date__gte=last_month )), rejected_count=Count('employees__vacation_requests', filter=Q( employees__vacation_requests__status=VacationRequest.STATUS_REJECTED, employees__vacation_requests__approval_date__gte=last_month )) ).prefetch_related('employees__user', 'company') # Simula o "gestor" para cada centro for centro in status_por_departamento: gestores = centro.employees.filter(role='manager').order_by('user__first_name') centro.manager = gestores.first() if gestores.exists() else None context = { 'total_employees': EmployeeProfile.objects.filter(is_active=True).count(), 'pending_requests': VacationRequest.objects.filter(status=VacationRequest.STATUS_PENDING).count(), 'approved_vacations': upcoming_qs.count(), 'current_vacations': VacationRequest.objects.filter( status=VacationRequest.STATUS_APPROVED, start_date__lte=today, end_date__gte=today ).order_by('employee__user__first_name'), 'vacations_requiring_notice': VacationRequest.objects.filter( status=VacationRequest.STATUS_APPROVED, start_date__gte=today, start_date__lte=today + timedelta(days=30) ).order_by('start_date'), 'chart_data': chart_data, 'companies': Company.objects.filter(is_active=True).order_by('name'), 'cost_centers': CostCenter.objects.filter(is_active=True).order_by('name'), 'status_por_departamento': status_por_departamento, } return render(request, 'admin/dashboard.html', context) @login_required @role_required(EmployeeProfile.USER_ROLE_ADMIN) def manage_employees(request): if request.method == 'POST': form = EmployeeForm(request.POST) if form.is_valid(): # Verifica duplicidade de username if User.objects.filter(username=form.cleaned_data['username']).exists(): messages.error(request, "Já existe um usuário com este nome de usuário.") return redirect('manage_employees') # Verifica duplicidade de matrícula if EmployeeProfile.objects.filter(employee_id=form.cleaned_data['employee_id']).exists(): messages.error(request, "Já existe um colaborador com esta matrícula.") return redirect('manage_employees') # Cria o usuário user = form.save(commit=False) user.set_password(form.cleaned_data['password1']) user.save() # Cria o perfil profile = EmployeeProfile.objects.create( user=user, company=form.cleaned_data['company'], employee_id=form.cleaned_data['employee_id'], hire_date=form.cleaned_data['hire_date'], role=form.cleaned_data['role'], is_active=True, is_tutor=form.cleaned_data.get('is_tutor', False) ) # Associa centros de custo corretamente cost_centers = form.cleaned_data.get('cost_centers') if cost_centers: profile.cost_centers.set(cost_centers) else: messages.warning(request, "Nenhum centro de custo foi atribuído a este colaborador.") # Se estagiário, vincula o tutor if form.cleaned_data['role'] == 'intern': profile.tutor = form.cleaned_data.get('tutor') profile.save() messages.success(request, "Colaborador cadastrado com sucesso!") return redirect('manage_employees') else: print("Formulário inválido:", form.errors) else: form = EmployeeForm() employees = EmployeeProfile.objects.all().order_by('-is_active', 'user__first_name') context = { 'form': form, 'employees': employees, 'companies': Company.objects.filter(is_active=True), 'cost_centers': CostCenter.objects.filter(is_active=True), } return render(request, 'admin/manage_employees.html', context) @login_required @role_required(EmployeeProfile.USER_ROLE_ADMIN) def edit_employee(request, employee_id): employee_profile = get_object_or_404(EmployeeProfile, id=employee_id) user = employee_profile.user if request.method == 'POST': form = EmployeeForm(request.POST, instance=employee_profile) if form.is_valid(): user.first_name = form.cleaned_data['first_name'] user.last_name = form.cleaned_data['last_name'] user.email = form.cleaned_data['email'] user.username = form.cleaned_data['username'] user.save() employee_profile.company = form.cleaned_data['company'] employee_profile.employee_id = form.cleaned_data['employee_id'] employee_profile.hire_date = form.cleaned_data['hire_date'] employee_profile.role = form.cleaned_data['role'] employee_profile.is_active = 'is_active' in request.POST employee_profile.is_tutor = form.cleaned_data.get('is_tutor', False) employee_profile.tutor = form.cleaned_data.get('tutor') if form.cleaned_data['role'] == 'intern' else None employee_profile.cost_centers.set(form.cleaned_data['cost_centers']) employee_profile.save() messages.success(request, "Colaborador atualizado com sucesso!") return redirect('manage_employees') else: messages.error(request, "Erro ao atualizar colaborador.") else: initial_data = { 'username': user.username, 'first_name': user.first_name, 'last_name': user.last_name, 'email': user.email, 'company': employee_profile.company, 'employee_id': employee_profile.employee_id, 'hire_date': employee_profile.hire_date, 'role': employee_profile.role, 'cost_centers': employee_profile.cost_centers.all(), 'is_tutor': employee_profile.is_tutor, 'tutor': employee_profile.tutor } form = EmployeeForm(instance=employee_profile, initial=initial_data) context = { 'form': form, 'employee_profile': employee_profile, } return render(request, 'admin/edit_employee.html', context) @login_required @role_required(EmployeeProfile.USER_ROLE_ADMIN) def manage_companies(request): """View for HR to manage companies""" if request.method == 'POST': # Handle new company creation name = request.POST.get('name') cnpj = request.POST.get('cnpj') address = request.POST.get('address') if name and cnpj: Company.objects.create( name=name, cnpj=cnpj, address=address, is_active=True ) messages.success(request, "Empresa cadastrada com sucesso!") return redirect('manage_companies') else: messages.error(request, "Nome e CNPJ são obrigatórios.") # Get all companies companies = Company.objects.all().order_by('-is_active', 'name') context = { 'companies': companies, } return render(request, 'admin/manage_companies.html', context) @login_required @role_required(EmployeeProfile.USER_ROLE_ADMIN) def edit_company(request, company_id): """View for HR to edit a company""" company = get_object_or_404(Company, id=company_id) if request.method == 'POST': company.name = request.POST.get('name') company.cnpj = request.POST.get('cnpj') company.address = request.POST.get('address') company.is_active = 'is_active' in request.POST company.save() messages.success(request, "Empresa atualizada com sucesso!") return redirect('manage_companies') context = { 'company': company, } return render(request, 'admin/edit_company.html', context) @login_required @role_required(EmployeeProfile.USER_ROLE_ADMIN) def manage_cost_centers(request): """View for HR to manage cost centers""" if request.method == 'POST': # Handle new cost center creation company_id = request.POST.get('company') code = request.POST.get('code') name = request.POST.get('name') if company_id and code and name: CostCenter.objects.create( company_id=company_id, code=code, name=name, is_active=True ) messages.success(request, "Centro de custo cadastrado com sucesso!") return redirect('manage_cost_centers') else: messages.error(request, "Empresa, código e nome são obrigatórios.") # Get all cost centers cost_centers = CostCenter.objects.select_related('company').all().order_by('-is_active', 'company__name', 'code') # Get companies for form companies = Company.objects.filter(is_active=True).order_by('name') # Filter by company if provided company_filter = request.GET.get('company') if company_filter: cost_centers = cost_centers.filter(company_id=company_filter) context = { 'cost_centers': cost_centers, 'companies': companies, 'company_filter': company_filter, } return render(request, 'admin/manage_cost_centers.html', context) @login_required @role_required(EmployeeProfile.USER_ROLE_ADMIN) def edit_cost_center(request, cost_center_id): """View for HR to edit a cost center""" cost_center = get_object_or_404(CostCenter, id=cost_center_id) if request.method == 'POST': cost_center.company_id = request.POST.get('company') cost_center.code = request.POST.get('code') cost_center.name = request.POST.get('name') cost_center.is_active = 'is_active' in request.POST cost_center.save() messages.success(request, "Centro de custo atualizado com sucesso!") return redirect('manage_cost_centers') # Get companies for form companies = Company.objects.filter(is_active=True).order_by('name') context = { 'cost_center': cost_center, 'companies': companies, } return render(request, 'admin/edit_cost_center.html', context) @login_required @role_required(EmployeeProfile.USER_ROLE_ADMIN) def reports(request): """View for HR to generate reports""" if request.method == 'POST': form = ReportForm(request.POST) if form.is_valid(): report_type = form.cleaned_data['report_type'] company = form.cleaned_data.get('company') cost_center = form.cleaned_data.get('cost_center') start_date = form.cleaned_data.get('start_date') end_date = form.cleaned_data.get('end_date') # Generate report based on type if report_type == 'vacation_balance': return generate_vacation_balance_report(company, cost_center) elif report_type == 'vacation_schedule': return generate_vacation_schedule_report(company, cost_center, start_date, end_date) elif report_type == 'pending_requests': return generate_pending_requests_report(company, cost_center) else: form = ReportForm() context = { 'form': form, } return render(request, 'admin/reports.html', context) def generate_vacation_balance_report(company=None, cost_center=None): """Generate Excel report of employee vacation balances""" import io import xlsxwriter buffer = io.BytesIO() workbook = xlsxwriter.Workbook(buffer) worksheet = workbook.add_worksheet('Saldo de Férias') # Cabeçalhos headers = ['Matrícula', 'Nome', 'Empresa', 'Centro(s) de Custo', 'Data de Admissão', 'Saldo de Férias (dias)'] for col_num, header in enumerate(headers): worksheet.write(0, col_num, header) # Consulta de colaboradores employees = EmployeeProfile.objects.filter(is_active=True) if company: employees = employees.filter(company=company) if cost_center: employees = employees.filter(cost_centers=cost_center) employees = employees.select_related('user', 'company').prefetch_related('cost_centers').order_by( 'company__name', 'user__first_name' ) for row_num, employee in enumerate(employees, 1): vacation_balance = calculate_vacation_balance(employee) full_name = f"{employee.user.first_name} {employee.user.last_name}" cost_centers_names = ", ".join([cc.name for cc in employee.cost_centers.all()]) worksheet.write(row_num, 0, employee.employee_id) worksheet.write(row_num, 1, full_name) worksheet.write(row_num, 2, employee.company.name) worksheet.write(row_num, 3, cost_centers_names) worksheet.write(row_num, 4, employee.hire_date.strftime('%d/%m/%Y') if employee.hire_date else '') worksheet.write(row_num, 5, vacation_balance) workbook.close() buffer.seek(0) response = HttpResponse( buffer.read(), content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' ) response['Content-Disposition'] = 'attachment; filename=saldo_ferias.xlsx' return response def generate_vacation_schedule_report(company=None, cost_center=None, start_date=None, end_date=None): """Generate Excel report of approved vacation schedules""" # Create a file-like buffer to receive Excel data buffer = io.BytesIO() # Create the workbook and add a worksheet workbook = xlsxwriter.Workbook(buffer) worksheet = workbook.add_worksheet('Programação de Férias') # Add headers headers = ['Matrícula', 'Nome', 'Empresa', 'Centro de Custo', 'Data Início', 'Data Fim', 'Total Dias', 'Dias Vendidos'] for col_num, header in enumerate(headers): worksheet.write(0, col_num, header) # Query vacation requests vacations = VacationRequest.objects.filter(status=VacationRequest.STATUS_APPROVED) if company: vacations = vacations.filter(employee__company=company) if cost_center: vacations = vacations.filter(employee__cost_centers=cost_center) if start_date: vacations = vacations.filter(start_date__gte=start_date) if end_date: vacations = vacations.filter(end_date__lte=end_date) vacations = vacations.select_related( 'employee', 'employee__user', 'employee__company' ).prefetch_related('employee__cost_centers') # Add data for row_num, vacation in enumerate(vacations, 1): employee = vacation.employee full_name = f"{employee.user.first_name} {employee.user.last_name}" total_days = vacation.total_days - vacation.selling_days worksheet.write(row_num, 0, employee.employee_id) worksheet.write(row_num, 1, full_name) worksheet.write(row_num, 2, employee.company.name) worksheet.write(row_num, 3, ", ".join(cc.name for cc in employee.cost_centers.all())) worksheet.write(row_num, 4, vacation.start_date.strftime('%d/%m/%Y')) worksheet.write(row_num, 5, vacation.end_date.strftime('%d/%m/%Y')) worksheet.write(row_num, 6, total_days) worksheet.write(row_num, 7, vacation.selling_days) workbook.close() # Set up the response buffer.seek(0) response = HttpResponse(buffer.read(), content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet') response['Content-Disposition'] = 'attachment; filename=programacao_ferias.xlsx' return response def generate_pending_requests_report(company=None, cost_center=None): """Generate Excel report of pending vacation requests""" buffer = io.BytesIO() workbook = xlsxwriter.Workbook(buffer) worksheet = workbook.add_worksheet('Solicitações Pendentes') headers = [ 'Matrícula', 'Nome', 'Empresa', 'Centro(s) de Custo', 'Gestor(es)', 'Data Solicitação', 'Data Início', 'Data Fim', 'Total Dias', 'Dias Vendidos' ] for col_num, header in enumerate(headers): worksheet.write(0, col_num, header) pending = VacationRequest.objects.filter(status=VacationRequest.STATUS_PENDING) if company: pending = pending.filter(employee__company=company) if cost_center: pending = pending.filter(employee__cost_centers=cost_center) pending = pending.select_related( 'employee', 'employee__user', 'employee__company' ).prefetch_related( 'employee__cost_centers' ).order_by('start_date') for row_num, request in enumerate(pending, 1): employee = request.employee full_name = f"{employee.user.first_name} {employee.user.last_name}" cost_centers_names = ", ".join(cc.name for cc in employee.cost_centers.all()) # Gestores relacionados aos centros de custo gestores = EmployeeProfile.objects.filter( cost_centers__in=employee.cost_centers.all(), role=EmployeeProfile.USER_ROLE_MANAGER, is_active=True ).distinct() manager_names = ", ".join(g.user.get_full_name() for g in gestores) if gestores.exists() else "Não definido" total_days = request.total_days - request.selling_days worksheet.write(row_num, 0, employee.employee_id) worksheet.write(row_num, 1, full_name) worksheet.write(row_num, 2, employee.company.name) worksheet.write(row_num, 3, cost_centers_names) worksheet.write(row_num, 4, manager_names) worksheet.write(row_num, 5, request.created_at.strftime('%d/%m/%Y')) worksheet.write(row_num, 6, request.start_date.strftime('%d/%m/%Y')) worksheet.write(row_num, 7, request.end_date.strftime('%d/%m/%Y')) worksheet.write(row_num, 8, total_days) worksheet.write(row_num, 9, request.selling_days) workbook.close() buffer.seek(0) response = HttpResponse( buffer.read(), content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' ) response['Content-Disposition'] = 'attachment; filename=solicitacoes_pendentes.xlsx' return response @login_required @role_required(EmployeeProfile.USER_ROLE_ADMIN) def get_cost_centers_json(request): """AJAX view to get cost centers for a company""" company_id = request.GET.get('company_id') if not company_id: return JsonResponse({'error': 'Company ID is required'}, status=400) cost_centers = CostCenter.objects.filter(company_id=company_id, is_active=True).values('id', 'name') return JsonResponse(list(cost_centers), safe=False) from django.contrib.auth.decorators import login_required, user_passes_test from django.shortcuts import render, redirect from .forms import ManualVacationForm def is_admin(user): return hasattr(user, 'profile') and user.profile.role == 'admin' @login_required @user_passes_test(is_admin) def register_manual_vacation(request): if request.method == 'POST': form = ManualVacationForm(request.POST) if form.is_valid(): form.save() return redirect('admin_dashboard') # ou qualquer outra rota de confirmação else: form = ManualVacationForm() return render(request, 'vacations/register_manual_vacation.html', {'form': form}) @login_required @role_required(EmployeeProfile.USER_ROLE_ADMIN) def delete_employee(request, employee_id): employee = get_object_or_404(EmployeeProfile, id=employee_id) user = employee.user if request.method == 'POST': user.delete() # Deleta o usuário e automaticamente o perfil messages.success(request, "Colaborador excluído com sucesso.") return redirect('manage_employees') return redirect('manage_employees') @login_required @role_required(EmployeeProfile.USER_ROLE_ADMIN) def delete_cost_center(request, cost_center_id): cost_center = get_object_or_404(CostCenter, id=cost_center_id) if request.method == 'POST': cost_center.delete() messages.success(request, "Centro de custo excluído com sucesso.") return redirect('manage_cost_centers') from django.shortcuts import render, redirect from django.contrib.auth.decorators import login_required from django.contrib import messages from django.utils import timezone from .models import ClockRecord @login_required def intern_dashboard(request): intern = request.user.profile if intern.role != 'intern': messages.error(request, "Acesso negado.") return redirect('dashboard') if request.method == 'POST': if 'update_time' in request.POST: record_id = request.POST.get('record_id') new_time = request.POST.get('new_time') try: record = ClockRecord.objects.get(id=record_id, employee=intern) current_date = record.timestamp.date() new_datetime = timezone.datetime.combine(current_date, timezone.datetime.strptime(new_time, '%H:%M').time()) record.timestamp = timezone.make_aware(new_datetime) record.save() messages.success(request, "Horário atualizado com sucesso.") except ClockRecord.DoesNotExist: messages.error(request, "Registro não encontrado.") else: point_type = request.POST.get('type') if point_type: today = timezone.now().date() if not ClockRecord.objects.filter(employee=intern, type=point_type, timestamp__date=today).exists(): ClockRecord.objects.create(employee=intern, type=point_type) messages.success(request, "Ponto registrado com sucesso.") else: messages.warning(request, "Você já registrou esse tipo de ponto hoje.") else: messages.error(request, "Tipo de ponto não informado.") date_str = request.GET.get('date') try: selected_date = timezone.datetime.strptime(date_str, '%Y-%m-%d').date() if date_str else timezone.now().date() except ValueError: selected_date = timezone.now().date() records = ClockRecord.objects.filter(employee=intern, timestamp__date=selected_date) return render(request, 'intern/dashboard.html', {'records': records, 'selected_date': selected_date}) from .models import ClockReportApproval from django.contrib.auth.decorators import login_required, user_passes_test from django.shortcuts import render, redirect, get_object_or_404 from django.contrib import messages from django.utils import timezone from django.contrib.auth.decorators import login_required, user_passes_test from datetime import datetime, time from .models import EmployeeProfile, ClockRecord, ClockReportApproval from django.contrib.auth.decorators import login_required, user_passes_test from django.shortcuts import render, get_object_or_404, redirect from django.contrib import messages from django.utils import timezone from datetime import datetime, time import calendar import sys from django.utils import timezone from django.http import HttpResponse, JsonResponse import sys from .forms import InternProfileExtraForm # importe o formulário from django.core.files.storage import default_storage from django.core.files.base import ContentFile from django.shortcuts import render, redirect, get_object_or_404 from django.contrib import messages from django.contrib.auth.decorators import login_required, user_passes_test from django.utils import timezone from datetime import datetime, time import calendar import sys from .models import EmployeeProfile, ClockRecord, ClockReportApproval from .forms import InternProfileExtraForm, LogoUploadForm def is_manager_or_tutor(user): return hasattr(user, 'profile') and (user.profile.role == 'manager' or user.profile.is_tutor) @login_required @user_passes_test(is_manager_or_tutor) def approve_intern_report(request): today = timezone.now() month = today.month year = today.year tutor = request.user.profile interns = EmployeeProfile.objects.filter(role='intern', tutor=tutor, is_active=True) form = None logo_form = LogoUploadForm() if request.method == 'POST': # Envio de logomarca if 'upload_logo' in request.POST: intern_id = request.POST.get('intern_id') intern = get_object_or_404(EmployeeProfile, id=intern_id, role='intern') logo_form = LogoUploadForm(request.POST, request.FILES) if logo_form.is_valid() and 'imagem' in request.FILES: intern.logo_file = request.FILES['imagem'] intern.save() messages.success(request, "Logomarca enviada com sucesso.") else: messages.error(request, "Erro ao enviar logomarca.") return redirect('approve_intern_report') # Atualização de ponto elif 'record_id' in request.POST: record_id = request.POST.get('record_id') new_time = request.POST.get('timestamp') new_type = request.POST.get('type') try: record = ClockRecord.objects.get(id=record_id) record.timestamp = timezone.make_aware( datetime.combine(record.timestamp.date(), time.fromisoformat(new_time)) ) record.type = new_type record.save() messages.success(request, "Registro de ponto atualizado com sucesso.") except Exception as e: messages.error(request, f"Erro ao atualizar registro: {e}") # Atualização do perfil elif 'save_profile' in request.POST: intern_id = request.POST.get('intern_id') intern = get_object_or_404(EmployeeProfile, id=intern_id, role='intern') form = InternProfileExtraForm(request.POST, request.FILES, instance=intern) if form.is_valid(): form.save() messages.success(request, f"Dados do estagiário {intern.user.get_full_name()} atualizados com sucesso.") return redirect('approve_intern_report') else: messages.error(request, "Erro ao atualizar dados do estagiário.") # Aprovação ou cancelamento elif 'action' in request.POST: intern_id = request.POST.get('intern_id') intern = get_object_or_404(EmployeeProfile, id=intern_id, role='intern') month_str = request.POST.get('month') if month_str: try: month = int(month_str) except ValueError: try: month = list(calendar.month_name).index(month_str.capitalize()) except ValueError: messages.error(request, "Mês inválido.") return redirect('approve_intern_report') else: messages.error(request, "Mês não especificado.") return redirect('approve_intern_report') if request.user.profile.role == 'tutor' and intern.tutor != request.user.profile: messages.error(request, "Você não é tutor deste estagiário.") return redirect('manager_dashboard') action = request.POST.get('action', 'approve') if action == 'approve': ClockReportApproval.objects.update_or_create( tutor=tutor, intern=intern, month=month, year=year, defaults={'signed': True, 'approved_at': timezone.now()} ) messages.success(request, f"Relatório do estagiário {intern.user.get_full_name()} aprovado com sucesso.") elif action == 'cancel': ClockReportApproval.objects.filter( tutor=tutor, intern=intern, month=month, year=year ).delete() messages.success(request, f"Aprovação do estagiário {intern.user.get_full_name()} foi cancelada.") # Preparar dados para exibição relatorios = [] for intern in interns: registros = ClockRecord.objects.filter( employee=intern, timestamp__year=year, timestamp__month=month ).order_by('timestamp') dias = {} for r in registros: dia = r.timestamp.date() dias.setdefault(dia, []).append(r) aprovado = ClockReportApproval.objects.filter( intern=intern, tutor=tutor, month=month, year=year ).exists() form_inst = form if form and form.instance == intern else InternProfileExtraForm(instance=intern) relatorios.append({ 'estagiario': intern, 'matricula': intern.employee_id, 'dias': dias, 'aprovado': aprovado, 'form': form_inst, }) context = { 'relatorios': relatorios, 'mes_atual': today.date(), 'logo_form': logo_form, } return render(request, 'manager/approve_intern_report.html', context) @login_required @role_required(EmployeeProfile.USER_ROLE_MANAGER) def editar_registro_ponto(request): if request.method == "POST": record_id = request.POST.get("record_id") timestamp = request.POST.get("timestamp") tipo = request.POST.get("type") try: registro = ClockRecord.objects.get(id=record_id) # Garante que o gestor é tutor do estagiário if registro.employee.tutor != request.user.profile: messages.error(request, "Você não tem permissão para editar este registro.") return redirect("approve_intern_report") # Atualiza o horário mantendo a data data_original = registro.timestamp.date() nova_hora = timezone.datetime.strptime(timestamp, "%H:%M").time() nova_datahora = timezone.make_aware(datetime.combine(data_original, nova_hora)) registro.timestamp = nova_datahora registro.type = tipo registro.save() messages.success(request, "Registro de ponto atualizado com sucesso.") except ClockRecord.DoesNotExist: messages.error(request, "Registro de ponto não encontrado.") return redirect("approve_intern_report") # vacations/views.py from django.http import HttpResponse import csv from .models import ClockRecord from django.utils import timezone @login_required @role_required(EmployeeProfile.USER_ROLE_INTERN) def export_clock_records(request): intern = request.user.profile selected_date = request.GET.get("date") if selected_date: records = ClockRecord.objects.filter(employee=intern, timestamp__date=selected_date) else: records = ClockRecord.objects.filter(employee=intern, timestamp__date=timezone.now().date()) response = HttpResponse(content_type='text/csv') response['Content-Disposition'] = 'attachment; filename="registros_ponto.csv"' writer = csv.writer(response) writer.writerow(['Data', 'Hora', 'Tipo']) for record in records: writer.writerow([ record.timestamp.date().strftime("%d/%m/%Y"), record.timestamp.time().strftime("%H:%M"), record.get_type_display() ]) return response from django.http import HttpResponse from django.template.loader import render_to_string from weasyprint import HTML from django.utils.timezone import localtime from calendar import monthrange from datetime import date import sys @login_required def gerar_espelho_ponto_pdf(request, intern_id, year, month): intern = get_object_or_404(EmployeeProfile, id=intern_id) registros = list(ClockRecord.objects.filter( employee=intern, timestamp__year=year, timestamp__month=month ).order_by('timestamp')) num_dias = monthrange(year, month)[1] dias_do_mes = [] for dia_num in range(1, num_dias + 1): dia_data = date(year, month, dia_num) registros_dia = [r for r in registros if r.timestamp.date() == dia_data] print(f"[DEBUG] {dia_data} - {len(registros_dia)} registro(s)", file=sys.stderr) for r in registros_dia: print(f" -> {r.timestamp.strftime('%Y-%m-%d %H:%M')} [{r.type}]", file=sys.stderr) horarios = { 'entrada': '', 'saida_almoco': '', 'retorno_almoco': '', 'saida_final': '' } for r in registros_dia: tipo = r.type.lower() horario_local = localtime(r.timestamp).strftime('%H:%M') if tipo in ['entrada', 'in']: horarios['entrada'] = horario_local elif tipo in ['saida_almoco', 'lunch_out']: horarios['saida_almoco'] = horario_local elif tipo in ['retorno_almoco', 'lunch_in']: horarios['retorno_almoco'] = horario_local elif tipo in ['saida_final', 'out']: horarios['saida_final'] = horario_local dias_do_mes.append({ 'dia': dia_num, 'nome_dia': dia_data.strftime('%A'), 'is_weekend': dia_data.weekday() >= 5, 'horarios': horarios, 'tem_registro': any(horarios.values()) }) MES_NOMES = { 1: 'janeiro', 2: 'fevereiro', 3: 'março', 4: 'abril', 5: 'maio', 6: 'junho', 7: 'julho', 8: 'agosto', 9: 'setembro', 10: 'outubro', 11: 'novembro', 12: 'dezembro' } # Gera URL absoluta da logo se houver logo_url = None if intern.logo_file: logo_url = request.build_absolute_uri(intern.logo_file.url) html_string = render_to_string("relatorios/espelho_ponto.html", { "intern": intern, "dias_do_mes": dias_do_mes, "mes_nome": MES_NOMES[month], "ano": year, "carga_horaria": intern.carga_horaria if hasattr(intern, 'carga_horaria') else '', "turma": intern.turma if hasattr(intern, 'turma') else '', "funcao": intern.funcao or '', "data_admissao": intern.hire_date.strftime('%d/%m/%Y') if intern.hire_date else '', "inicio_turno": intern.horario_trabalho_inicio.strftime('%H:%M') if intern.horario_trabalho_inicio else '--:--', "fim_turno": intern.horario_trabalho_fim.strftime('%H:%M') if intern.horario_trabalho_fim else '--:--', "logo_url": logo_url # <- adicionada aqui }) pdf_file = HTML(string=html_string).write_pdf() response = HttpResponse(pdf_file, content_type='application/pdf') response['Content-Disposition'] = f'inline; filename="espelho_{intern.employee_id}_{month}_{year}.pdf"' return response from django.contrib.auth.models import User from django.contrib.auth.decorators import login_required from django.shortcuts import redirect, get_object_or_404 from django.contrib import messages @login_required def activate_employee(request, user_id): user = get_object_or_404(User, pk=user_id) user.is_active = True user.save() messages.success(request, f"{user.get_full_name()} foi ativado com sucesso.") return redirect('manage_employees') @login_required def deactivate_employee(request, user_id): user = get_object_or_404(User, pk=user_id) user.is_active = False user.save() messages.success(request, f"{user.get_full_name()} foi desativado com sucesso.") return redirect('manage_employees') from datetime import timedelta from django.shortcuts import render, redirect from django.contrib import messages from .models import VacationRequest from .forms import VacationChoiceForm from django.contrib.auth.decorators import login_required # Tabela com as regras FLEXIBLE_VACATION_RULES = { 'Férias integrais (30 dias, sem venda)': { 'periods': [30], 'sold_days': 0 }, 'Férias com venda de 10 dias': { 'periods': [20], 'sold_days': 10 }, 'Férias com venda de 5 dias': { 'periods': [25], 'sold_days': 5 }, 'Férias com venda de 3 dias': { 'periods': [27], 'sold_days': 3 }, 'Parcelamento 20 + 10': { 'periods': [20, 10], 'sold_days': 0 }, 'Parcelamento 14 + 16': { 'periods': [14, 16], 'sold_days': 0 }, 'Parcelamento 15 + 10 (com venda de 5)': { 'periods': [15, 10], 'sold_days': 5 }, 'Parcelamento 14 + 5 + 6': { 'periods': [14, 5, 6], 'sold_days': 0 }, 'Parcelamento 14 + 8 + 8': { 'periods': [14, 8, 8], 'sold_days': 0 }, 'Parcelamento 16 + 9 + 5': { 'periods': [16, 9, 5], 'sold_days': 0 }, } @login_required @role_required(EmployeeProfile.USER_ROLE_MANAGER, EmployeeProfile.USER_ROLE_ADMIN) def manager_review_request(request, vacation_id): vacation_request = get_object_or_404( VacationRequest, id=vacation_id, status=VacationRequest.STATUS_PENDING ) gestor = request.user.profile # Restrição apenas se o usuário for gestor if gestor.role == EmployeeProfile.USER_ROLE_MANAGER: if ( vacation_request.employee == gestor or vacation_request.employee.role == EmployeeProfile.USER_ROLE_MANAGER or not vacation_request.employee.cost_centers.filter(id__in=gestor.cost_centers.values_list('id', flat=True)).exists() ): messages.error(request, "Você não tem permissão para revisar essa solicitação.") return redirect('pending_requests') if request.method == 'POST': form = ApprovalForm(request.POST) if form.is_valid(): action = form.cleaned_data['action'] if action == 'approve': vacation_request.status = VacationRequest.STATUS_APPROVED vacation_request.approved_by = gestor vacation_request.approval_date = timezone.now() vacation_request.save() VacationLog.objects.create( vacation_request=vacation_request, action=VacationLog.ACTION_APPROVE, performed_by=request.user, details="Solicitação aprovada pelo gestor" ) messages.success(request, "Solicitação aprovada com sucesso.") return redirect('pending_requests') elif action == 'reject': reason = form.cleaned_data['rejection_reason'] vacation_request.status = VacationRequest.STATUS_REJECTED vacation_request.rejection_reason = reason vacation_request.save() VacationLog.objects.create( vacation_request=vacation_request, action=VacationLog.ACTION_REJECT, performed_by=request.user, details=f"Rejeitada pelo gestor: {reason}" ) messages.warning(request, "Solicitação rejeitada.") return redirect('pending_requests') else: form = ApprovalForm() return render(request, 'manager/review_request.html', { 'vacation_request': vacation_request, 'form': form, }) @login_required @role_required(EmployeeProfile.USER_ROLE_ADMIN) def all_pending_requests(request): pending_requests = VacationRequest.objects.filter( status=VacationRequest.STATUS_PENDING ).select_related('employee', 'employee__user', 'employee__company') \ .prefetch_related('employee__cost_centers') \ .order_by('start_date') return render(request, 'admin/all_pending_requests.html', { 'pending_requests': pending_requests }) @login_required @role_required(EmployeeProfile.USER_ROLE_ADMIN) def approved_vacations_list(request): vacations = VacationRequest.objects.filter( status=VacationRequest.STATUS_APPROVED ).select_related('employee', 'employee__user', 'employee__company') \ .prefetch_related('employee__cost_centers') \ .order_by('start_date') return render(request, 'admin/approved_vacations_list.html', { 'vacations': vacations }) from .forms import CancelVacationForm from django.core.mail import send_mail from django.conf import settings @login_required def cancelar_ferias(request, vacation_id): vacation = get_object_or_404(VacationRequest, id=vacation_id, employee=request.user.profile) if vacation.status != VacationRequest.STATUS_APPROVED: messages.error(request, "Apenas férias aprovadas podem ser canceladas.") return redirect('view_history') dias_ate_inicio = (vacation.start_date - timezone.now().date()).days if dias_ate_inicio < 15: messages.error(request, "O cancelamento só é permitido até 15 dias antes da data de início.") return redirect('view_history') if request.method == 'POST': form = CancelVacationForm(request.POST) if form.is_valid(): motivo = form.cleaned_data['reason'] vacation.status = VacationRequest.STATUS_CANCELLED vacation.cancellation_date = timezone.now() vacation.cancellation_reason = motivo vacation.save() VacationLog.objects.create( vacation_request=vacation, action=VacationLog.ACTION_CANCEL, performed_by=request.user, details=f"Motivo: {motivo}" ) # Envia email try: send_mail( 'Solicitação de Cancelamento de Férias', f"O colaborador {request.user.get_full_name()} solicitou o cancelamento das férias de " f"{vacation.start_date.strftime('%d/%m/%Y')} a {vacation.end_date.strftime('%d/%m/%Y')}.\n\n" f"Motivo informado:\n{motivo}", settings.DEFAULT_FROM_EMAIL, ['rh@kuttner.com.br'], fail_silently=True, ) except Exception as e: print("Erro ao enviar email de cancelamento:", e) messages.success(request, "Solicitação de cancelamento enviada com sucesso.") return redirect('view_history') else: form = CancelVacationForm() return render(request, 'employee/cancel_vacation.html', { 'vacation': vacation, 'form': form })