App Orametro in Django per il monitoraggio dei tempi motore: Un Supporto Digitale per i Corsi di Volo di PilotaperSempre

Pubblicato il di

Qualche tempo fa ho sviluppato un’applicazione in Django per il monitoraggio dei tempi motore degli aerei (orametro), pensata specificamente per le esigenze della scuola di volo PilotaperSempre. Questa app consente ai piloti, durante i corsi di volo, di registrare i tempi motore tramite smartphone e periodicamente esportare i dati in formato Excel per facilitare le statistiche e la fatturazione.

PilotaperSempre

PilotaperSempre offre corsi di volo completi e servizi unici per appassionati e professionisti dell’aviazione.

Per altre informazioni, visita il sito ufficiale di PilotaperSempre.

Monitoraggio dei Tempi Motore

Quest’applicazione permette un monitoraggio preciso e in tempo reale dei tempi motore, fondamentale per le attività quotidiane di una scuola di volo.

Ecco le sue funzionalità principali:

Registrazione in Tempo Reale: I piloti registrano i tempi motore direttamente dallo smartphone,  ideale per i corsi di volo che richiedono monitoraggio accurato dei voli.
Esportazione in Excel: A fine giornata, i dati dei voli possono essere esportati in un file Excel, utile per analisi e fatturazione, riducendo il carico amministrativo per la scuola.

Struttura Tecnica dell’applicazione Orametro

L’applicazione orametro utilizza il framework Django per gestire le diverse funzionalità.

 

Organizzazione dei Moduli: L’applicazione si struttura in moduli che gestiscono i voli, i piloti e i tempi motore. Il modulo principale flights contiene i modelli e le viste per raccogliere e mostrare i dati relativi ai voli.

In Django, un progetto è suddiviso in diverse applicazioni o moduli. Ciascun modulo è responsabile di una specifica parte della funzionalità del progetto. Questo permette di gestire in modo organizzato e modulare le varie parti dell’applicazione.

La struttura di un progetto Django di base appare così:

my_project/
├── manage.py
├── my_project/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ ├── wsgi.py
│ └── asgi.py
└── flights/ # Modulo principale per i voli
├── migrations/
├── __init__.py
├── admin.py
├── apps.py
├── models.py
├── tests.py
├── urls.py
└── views.py
  • manage.py: Il file principale per eseguire comandi Django come l’avvio del server, la gestione delle migrazioni, e altro.
  • settings.py: Contiene la configurazione del progetto, come database, percorsi di file statici, e configurazioni di app di terze parti.
  • urls.py: Mappa gli URL alle viste, permettendo di definire gli endpoint che gli utenti o altre applicazioni possono chiamare.

2. Il Modulo ‘flights’

Gestione orametro voli

Nel contesto del progetto, il modulo flights gestisce tutte le operazioni correlate al monitoraggio dei tempi di volo. Vediamo ogni file importante:

  • admin.py: Consente di registrare i modelli in modo che siano visibili e gestibili nell’area di amministrazione di Django. Per esempio, puoi registrare il modello Flight per visualizzare e modificare i voli dall’interfaccia di amministrazione. 
    from django.contrib import admin
from .models import Flight

admin.site.register(Flight)

     

  • apps.py: Definisce la configurazione specifica del modulo (non è molto usato per le funzionalità standard, ma permette configurazioni avanzate se necessario).
  • models.py: Qui definiamo le strutture dati, come il modello Flight, che rappresenta un volo e memorizza dati come pilota, orario di inizio e fine, e durata. Ogni modello Django corrisponde a una tabella del database. 
    from django.db import models
from django.contrib.auth.models import User

class Flight(models.Model):
    pilot = models.ForeignKey(User, on_delete=models.CASCADE)
    start_time = models.DateTimeField()
    end_time = models.DateTimeField()
    aircraft_type = models.CharField(max_length=100)
    notes = models.TextField(blank=True, null=True)

    def duration(self):
        return (self.end_time - self.start_time).total_seconds() / 3600

    In questo esempio:

    • Flight è una tabella nel database.
    • duration è un metodo che calcola la durata del volo.

Il modello Flight gestisce i dati di volo, collegando il pilota e l’aereo. Le date di inizio e fine permettono di calcolare la durata, utile per le fatturazioni legate ai corsi di volo.

  • migrations/: Directory che contiene le migrazioni per il database, ovvero file che tengono traccia delle modifiche al database Django (come la creazione o modifica di tabelle).
  • views.py: Contiene le funzioni che gestiscono le richieste e generano le risposte. Per esempio, la vista flight_list recupera i dati di tutti i voli e li passa a un template HTML. 
    from django.shortcuts import render
from .models import Flight

def flight_list(request):
    flights = Flight.objects.all()
    return render(request, 'flights/flight_list.html', {'flights': flights})

    Qui, flight_list elenca i voli e invia i dati a un template per la visualizzazione.

    La vista mostra tutti i voli attivi, facilitando il monitoraggio da parte degli istruttori.

  • urls.py: Mappa gli URL specifici del modulo flights. Ad esempio, puoi definire un URL per accedere alla lista dei voli: 
    from django.urls import path
from . import views

urlpatterns = [
    path('', views.flight_list, name='flight_list'),
    path('export/', views.export_flights_xls, name='export_flights_xls'),
]

    In questo file, puoi aggiungere altri URL specifici per il modulo flights.

  • templates/flights/: Contiene i file HTML (template) utilizzati per visualizzare i dati. Ogni vista può essere associata a un template per mostrare i dati in una pagina web. 
    {% extends "base_generic.html" %}

{% block content %}

<h1>Flights List</h1>

{% if flight_list %}
  <ul>

  {% for cflights in flight_list %}
    <li><a href="{% url 'flights:detail' cflights.id %}">{{ cflights.flight_start }}</a></li>
  {% endfor %}

 </ul>
{% else %}
  <p>There are no flights available.</p>
{% endif %}
        
        
        
{% endblock %}

Export in Excel per Report e Fatturazione

L’applicazione permette l’esportazione in Excel. Utilizzando il modulo xlwt, è possibile generare un report contenente dati chiave utili per l’amministrazione e la fatturazione dei corsi di volo.

import xlwt
from django.http import HttpResponse

def export_flights_xls(request):
    response = HttpResponse(content_type='application/ms-excel')
    response['Content-Disposition'] = 'attachment; filename="flights.xls"'
    
    wb = xlwt.Workbook(encoding='utf-8')
    ws = wb.add_sheet('Flights')
    
    # Header
    columns = ['Pilot', 'Aircraft Type', 'Start Time', 'End Time', 'Duration (hours)']
    for col_num, column_title in enumerate(columns):
        ws.write(0, col_num, column_title)
    
    # Data
    rows = Flight.objects.all().values_list('pilot__username', 'aircraft_type', 'start_time', 'end_time', 'duration')
    for row_num, row in enumerate(rows, 1):
        for col_num, cell_value in enumerate(row):
            ws.write(row_num, col_num, cell_value)
    
    wb.save(response)
    return response

Vantaggi della Struttura Modulare

  1. Manutenibilità: Suddividere il codice in moduli rende il progetto più facile da gestire e manutenere.
  2. Riutilizzabilità: Ogni modulo è autonomo, per cui può essere facilmente riutilizzato o adattato in altri progetti.
  3. Collaborazione: In un team, i membri possono lavorare su moduli diversi senza interferenze, riducendo i conflitti di codice.

Questa struttura modulare permette di aggiungere nuove funzionalità (come un sistema di esportazione dei report) nel modulo flights senza dover cambiare altre parti del progetto Django.

Conclusione

L’applicazione orametro ha migliorato l’efficienza dei corsi e delle operazioni di PilotaperSempre, offrendo un monitoraggio preciso e riducendo il carico amministrativo grazie alla funzione di esportazione in Excel. PilotaperSempre continua a essere un esempio di eccellenza nell’addestramento al volo, con servizi dedicati sia ai nuovi piloti che agli esperti.

Per scoprire di più su questi corsi di volo, visita il sito pilotapersempre.it.