AquiferSupervision/WorkerService1/WebApplication3/Controllers/BalanceHidricoController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using WebApplication3.Models;
using WebApplication3.Clases;

namespace WebApplication3.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class BalanceHidricoController : ControllerBase
    {
        private readonly AquiferContext _context;

        public BalanceHidricoController(AquiferContext context)
        {
            _context = context;
        }

        // GET: api/BalanceHidrico
        [HttpGet]
        public async Task<ActionResult<IEnumerable<BalanceHidrico>>> GetBalances()
        {
            return await _context.BalancesHidricos.ToListAsync();
        }

        // GET: api/balance/5
        [HttpGet("{idSimulacion}")]
        public async Task<ActionResult<IEnumerable<ZoneBalance>>> GetBalance(uint idSimulacion)
        {            
            List<BalanceHidrico> dbBalances = await _context.BalancesHidricos.Where( x=> x.IdSimulacion == idSimulacion).ToListAsync<BalanceHidrico>();
                       
            List<ZoneBalance> balancesOutput = new List<ZoneBalance>();

            foreach (BalanceHidrico bh in dbBalances)
            {
                DatosBalanceIn dataIn = _context.DatosBalanceIns.Where(x => x.IdBalance == bh.Id).First();
                DatosBalanceOut dataOut = _context.DatosBalanceOuts.Where(x => x.IdBalance == bh.Id).First();

                List<ConexionZonasIn> connectionsIn = _context.ConexionZonasIns.Where(x => x.IdDatosBalanceIn == dataIn.Id).ToList();
                List<ConexionZonasOut> connectionsOut = _context.ConexionZonasOuts.Where(x => x.IdDatosBalanceOut == dataOut.Id).ToList();


                ZoneBalance zb = new ZoneBalance(bh);
                ZoneData dataBalanceIn = new ZoneData(dataIn);
                ZoneData dataBalanceOut = new ZoneData(dataOut);

                /*
                 * TODO: Hacer la discretización por tipo de zona, AGREGAR EL CAMPO A LA TABLA DE LA BBDD Y GUARDARLO TAMBIEN, que no se quede solo en la IMPORTACIÓN (?)
                 */
                if (bh.Zona != "Zone 0")
                {
                    List<ZoneConnection> zoneConnectionsIn = new List<ZoneConnection>();
                    connectionsIn.ForEach(x => zoneConnectionsIn.Add(new ZoneConnection(x)));
                    dataBalanceIn.ZoneConnections = zoneConnectionsIn;

                    List<ZoneConnection> zoneConnectionsOut = new List<ZoneConnection>();
                    connectionsOut.ForEach(x => zoneConnectionsOut.Add(new ZoneConnection(x)));
                    dataBalanceOut.ZoneConnections = zoneConnectionsOut;
                }

                zb.SetInOutData(dataBalanceIn, dataBalanceOut);
                balancesOutput.Add(zb);

            }

            return balancesOutput;
        }

        [NonAction]
        public BalanceHidrico GetBalanceById(uint id)
        {
            var balance = _context.BalancesHidricos.Find(id);

            return balance;
        }

        [NonAction]
        public DatosBalanceIn GetBalanceIn(uint id)
        {
            var balanceIn = _context.DatosBalanceIns.Find(id);

            return balanceIn;
        }

        [NonAction]
        public DatosBalanceOut GetBalanceOut(uint id)
        {
            var balanceOut = _context.DatosBalanceOuts.Find(id);

            return balanceOut;
        }

        [NonAction]
        public ConexionZonasIn GetConnectionIn(uint id)
        {
            var connectionIn = _context.ConexionZonasIns.Find(id);

            return connectionIn;
        }

        [NonAction]
        public ConexionZonasOut GetConnectionOut(uint id)
        {
            var connectionOut = _context.ConexionZonasOuts.Find(id);

            return connectionOut;
        }

        // POST: api/TsPozo
        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
        [HttpPost]
        [ProducesResponseType(200)]
        [ProducesResponseType(409)]
        public async Task<ActionResult<uint>> PostBalance(BalanceHidrico balance)
        {
            _context.BalancesHidricos.Add(balance);
            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateException)
            {
                if (BalanceExist(balance.Id))
                {
                    return Conflict();
                }
                else
                {
                    throw;
                }
            }

            return balance.Id;
        }

        [NonAction]
        public async Task<ActionResult<uint>> PostBalanceIn(DatosBalanceIn balanceIn)
        {
            _context.DatosBalanceIns.Add(balanceIn);
            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateException)
            {
                if (BalanceInExist(balanceIn.Id))
                {
                    return Conflict();
                }
                else
                {
                    throw;
                }
            }

            return balanceIn.Id;
        }

        [NonAction]
        public async Task<ActionResult<uint>> PostBalanceOut(DatosBalanceOut balanceOut)
        {
            _context.DatosBalanceOuts.Add(balanceOut);
            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateException)
            {
                if (BalanceOutExist(balanceOut.Id))
                {
                    return Conflict();
                }
                else
                {
                    throw;
                }
            }

            return balanceOut.Id;
        }

        [NonAction]
        public async Task<ActionResult<ConexionZonasIn>> PostConnectionIn(ConexionZonasIn connectionIn)
        {
            _context.ConexionZonasIns.Add(connectionIn);
            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateException)
            {
                if (ConnectionInExist(connectionIn.Id))
                {
                    return Conflict();
                }
                else
                {
                    throw;
                }
            }

            return CreatedAtAction("GetConnectionIn", new { id = connectionIn.Id }, connectionIn);
        }

        [NonAction]
        public async Task<ActionResult<bool>> PostMultipleConnectionIn(ConexionZonasIn[] connectionsIn)
        {
            _context.ConexionZonasIns.AddRange(connectionsIn);
            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateException)
            {
                
                throw;
                
            }

            return true;
        }

        [NonAction]
        public async Task<ActionResult<ConexionZonasOut>> PostConnectionOut(ConexionZonasOut connectionOut)
        {
            _context.ConexionZonasOuts.Add(connectionOut);
            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateException)
            {
                if (ConnectionOutExist(connectionOut.Id))
                {
                    return Conflict();
                }
                else
                {
                    throw;
                }
            }

            return CreatedAtAction("GetConnectionOut", new { id = connectionOut.Id }, connectionOut);
        }

        [NonAction]
        public async Task<ActionResult<bool>> PostMultipleConnectionOut(ConexionZonasOut[] connectionsOut)
        {
            _context.ConexionZonasOuts.AddRange(connectionsOut);
            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateException)
            {
                throw;
            }

            return true;
        }

        private bool BalanceExist(uint id)
        {
            return _context.BalancesHidricos.Any(e => e.Id == id);
        }

        private bool BalanceInExist(uint id)
        {
            return _context.DatosBalanceIns.Any(e => e.Id == id);
        }

        private bool BalanceOutExist(uint id)
        {
            return _context.DatosBalanceOuts.Any(e => e.Id == id);
        }

        private bool ConnectionInExist(uint id)
        {
            return _context.ConexionZonasIns.Any(e => e.Id == id);
        }

        private bool ConnectionOutExist(uint id)
        {
            return _context.ConexionZonasOuts.Any(e => e.Id == id);
        }
    }
}