Create fuel efficincy

Vpassbackend/Controllers/FuelEfficiencyController.cs

@@ -0,0 +1,175 @@
+using Microsoft.AspNetCore.Mvc;
+using Vpassbackend.DTOs;
+using Vpassbackend.Services;
+using System.Globalization;
+
+namespace Vpassbackend.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class FuelEfficiencyController : ControllerBase
+    {
+        private readonly IFuelEfficiencyService _fuelEfficiencyService;
+
+        public FuelEfficiencyController(IFuelEfficiencyService fuelEfficiencyService)
+        {
+            _fuelEfficiencyService = fuelEfficiencyService;
+        }
+
+        // GET: api/FuelEfficiency/vehicle/{vehicleId}
+        [HttpGet("vehicle/{vehicleId}")]
+        public async Task<ActionResult<List<FuelEfficiencyDTO>>> GetFuelEfficienciesByVehicle(int vehicleId)
+        {
+            try
+            {
+                var fuelEfficiencies = await _fuelEfficiencyService.GetFuelRecordsByVehicleAsync(vehicleId);
+                return Ok(fuelEfficiencies);
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(ex.Message);
+            }
+        }
+
+        // GET: api/FuelEfficiency/vehicle/{vehicleId}/summary
+        [HttpGet("vehicle/{vehicleId}/summary")]
+        public async Task<ActionResult<FuelEfficiencySummaryDTO>> GetFuelEfficiencySummary(int vehicleId, [FromQuery] int? year = null)
+        {
+            try
+            {
+                var summary = await _fuelEfficiencyService.GetFuelSummaryAsync(vehicleId, year);
+                return Ok(summary);
+            }
+            catch (ArgumentException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(ex.Message);
+            }
+        }
+
+        // GET: api/FuelEfficiency/vehicle/{vehicleId}/chart/{year}
+        [HttpGet("vehicle/{vehicleId}/chart/{year}")]
+        public async Task<ActionResult<List<MonthlyFuelSummaryDTO>>> GetMonthlyChartData(int vehicleId, int year)
+        {
+            try
+            {
+                var chartData = await _fuelEfficiencyService.GetMonthlyChartDataAsync(vehicleId, year);
+                return Ok(chartData);
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(ex.Message);
+            }
+        }
+
+        // POST: api/FuelEfficiency
+        [HttpPost]
+        public async Task<ActionResult<FuelEfficiencyDTO>> AddFuelEfficiency(AddFuelEfficiencyDTO addFuelDto)
+        {
+            try
+            {
+                var result = await _fuelEfficiencyService.AddFuelRecordAsync(addFuelDto);
+                return CreatedAtAction(nameof(GetFuelEfficienciesByVehicle), 
+                    new { vehicleId = result.VehicleId }, result);
+            }
+            catch (ArgumentException ex)
+            {
+                return BadRequest(ex.Message);
+            }
+            catch (Exception)
+            {
+                return BadRequest("An error occurred while adding fuel record");
+            }
+        }
+
+        // PUT: api/FuelEfficiency/{id}
+        [HttpPut("{id}")]
+        public async Task<IActionResult> UpdateFuelEfficiency(int id, AddFuelEfficiencyDTO updateFuelDto)
+        {
+            try
+            {
+                var success = await _fuelEfficiencyService.UpdateFuelRecordAsync(id, updateFuelDto);
+                if (!success)
+                {
+                    return NotFound("Fuel efficiency record not found");
+                }
+                return NoContent();
+            }
+            catch (ArgumentException ex)
+            {
+                return BadRequest(ex.Message);
+            }
+            catch (Exception)
+            {
+                return BadRequest("An error occurred while updating fuel record");
+            }
+        }
+
+        // DELETE: api/FuelEfficiency/{id}
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeleteFuelEfficiency(int id)
+        {
+            try
+            {
+                var success = await _fuelEfficiencyService.DeleteFuelRecordAsync(id);
+                if (!success)
+                {
+                    return NotFound("Fuel efficiency record not found");
+                }
+                return NoContent();
+            }
+            catch (Exception)
+            {
+                return BadRequest("An error occurred while deleting fuel record");
+            }
+        }
+
+        // GET: api/FuelEfficiency/vehicle/{vehicleId}/monthly/{year}/{month}
+        [HttpGet("vehicle/{vehicleId}/monthly/{year}/{month}")]
+        public async Task<ActionResult<List<FuelEfficiencyDTO>>> GetMonthlyFuelRecords(int vehicleId, int year, int month)
+        {
+            try
+            {
+                var fuelRecords = await _fuelEfficiencyService.GetFuelRecordsByMonthAsync(vehicleId, year, month);
+                return Ok(fuelRecords);
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(ex.Message);
+            }
+        }
+
+        // GET: api/FuelEfficiency/vehicle/{vehicleId}/period
+        [HttpGet("vehicle/{vehicleId}/period")]
+        public async Task<ActionResult<decimal>> GetFuelForPeriod(int vehicleId, [FromQuery] DateTime startDate, [FromQuery] DateTime endDate)
+        {
+            try
+            {
+                var totalFuel = await _fuelEfficiencyService.GetTotalFuelForPeriodAsync(vehicleId, startDate, endDate);
+                return Ok(new { TotalFuel = totalFuel, StartDate = startDate, EndDate = endDate });
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(ex.Message);
+            }
+        }
+
+        // GET: api/FuelEfficiency/vehicle/{vehicleId}/average/{year}
+        [HttpGet("vehicle/{vehicleId}/average/{year}")]
+        public async Task<ActionResult<decimal>> GetAverageFuelPerMonth(int vehicleId, int year)
+        {
+            try
+            {
+                var averageFuel = await _fuelEfficiencyService.GetAverageFuelPerMonthAsync(vehicleId, year);
+                return Ok(new { AverageMonthlyFuel = averageFuel, Year = year });
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(ex.Message);
+            }
+        }
+    }
+}

Vpassbackend/DTOs/FuelEfficiencyDTO.cs

@@ -0,0 +1,44 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Vpassbackend.DTOs
+{
+    public class AddFuelEfficiencyDTO
+    {
+        [Required]
+        public int VehicleId { get; set; }
+
+        [Required]
+        [Range(0.01, 1000, ErrorMessage = "Fuel amount must be between 0.01 and 1000 liters")]
+        public decimal FuelAmount { get; set; }
+
+        [Required]
+        public DateTime Date { get; set; }
+    }
+
+    public class FuelEfficiencyDTO
+    {
+        public int FuelEfficiencyId { get; set; }
+        public int VehicleId { get; set; }
+        public decimal FuelAmount { get; set; }
+        public DateTime Date { get; set; }
+        public DateTime CreatedAt { get; set; }
+    }
+
+    public class MonthlyFuelSummaryDTO
+    {
+        public int Year { get; set; }
+        public int Month { get; set; }
+        public string MonthName { get; set; } = string.Empty;
+        public decimal TotalFuelAmount { get; set; }
+        public int RecordCount { get; set; }
+    }
+
+    public class FuelEfficiencySummaryDTO
+    {
+        public int VehicleId { get; set; }
+        public string VehicleRegistrationNumber { get; set; } = string.Empty;
+        public List<MonthlyFuelSummaryDTO> MonthlySummary { get; set; } = new List<MonthlyFuelSummaryDTO>();
+        public decimal TotalFuelThisYear { get; set; }
+        public decimal AverageMonthlyFuel { get; set; }
+    }
+}

Vpassbackend/Data/ApplicationDbContext.cs

@@ -24,6 +24,7 @@ public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
         public DbSet<Vehicle> Vehicles { get; set; }
         public DbSet<VehicleServiceHistory> VehicleServiceHistories { get; set; }
         public DbSet<EmergencyCallCenter> EmergencyCallCenters { get; set; }
+        public DbSet<FuelEfficiency> FuelEfficiencies { get; set; }
 
 
         protected override void OnModelCreating(ModelBuilder modelBuilder)
@@ -104,6 +105,13 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
                 .WithMany(s => s.ServiceReminders)
                 .HasForeignKey(sr => sr.ServiceId)
                 .OnDelete(DeleteBehavior.Cascade);
+
+            // Configure FuelEfficiency relationships
+            modelBuilder.Entity<FuelEfficiency>()
+                .HasOne(fe => fe.Vehicle)
+                .WithMany(v => v.FuelEfficiencies)
+                .HasForeignKey(fe => fe.VehicleId)
+                .OnDelete(DeleteBehavior.Cascade);
         }
     }
 }