AquiferSupervision/WorkerService1/WebApplication3/Controllers/AcuiferoController.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;
using System.IO.Compression;
using System.IO;


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

        public AcuiferoController(AquiferContext context)
        {
            _context = context;
            pozoController = new PozoController(context);
            recargaController = new RecargasController(context);

        }

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

        // GET: api/Acuifero/5
        [HttpGet("{id}")]
        public async Task<ActionResult<Acuifero>> GetAcuifero(uint id)
        {
            var acuifero = await _context.Acuiferos.FindAsync(id);

            if (acuifero == null)
            {
                return NotFound();
            }

            return acuifero;
        }

        [HttpGet("GeoRecharge/{id}")]
        public async Task<bool> GetRechargeColorMap(uint id)
        {
            Acuifero aquifer = await _context.Acuiferos.FindAsync(id);

            return Utilities.String2Png(aquifer.RechargeGeometry);

        }

        // PUT: api/Acuifero/5
        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
        [HttpPut("{id}")]
        public async Task<IActionResult> PutAcuifero(uint id, [FromBody] DatosPostAcuifero datos)
        {

            Acuifero acuifero = _context.Acuiferos.Find(id);
            //string pathZip = @"C:\Users\Admin\Desktop\";
            //string pathExtract = @"C:\Users\Admin\Desktop\TestExtract\";
            string pozoFile, recargaFile;
            List<string> files;

            if (id != acuifero.Id)
            {
                return BadRequest();
            }

            try
            {
                //Se parsea el base 64 que nos llega
                byte[] tempBytes = Convert.FromBase64String(datos.Fichero.Base64);
                //Guardamos en disco el archivo obtenido del base 64
                System.IO.File.WriteAllBytes(@"C:\Users\Admin\Desktop\" + datos.Fichero.Nombre, tempBytes);
            }
            catch (Exception ex)
            {
                return Problem(ex.Message);
            }


            //Guardamos en bbdd la actualizacion del nombre de fichero
            acuifero.Fichero = datos.Fichero.Nombre;

            _context.Entry(acuifero).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
                Pozo[] pozos = pozoController.GetPozosAcuiferoSimulacionInicial(acuifero.Id);
                Recarga[] recargas = recargaController.GetRecargasAcuiferoSimulacionInicial(acuifero.Id);

                foreach (Pozo p in pozos)
                {
                    await pozoController.DeletePozo(p.Id);
                }

                foreach (Recarga r in recargas)
                {
                    await recargaController.DeleteRecarga(r.Id);
                }

                //1- Descomprimimos el fichero zip
                ZipFile.ExtractToDirectory(Constants.PathZip + datos.Fichero.Nombre, Constants.PathExtract, true);
                //2- Obtenemos nombre de los ficheros de pozos y recargas 
                files = Directory.GetFiles(Constants.PathExtract).ToList<string>();
                pozoFile = files.Find(x => x.Contains(".VMW"));
                recargaFile = files.Find(x => x.Contains(".VMP"));
                //3- Parseamos pozos
                if (System.IO.File.Exists(pozoFile))
                {
                    await pozoController.ParseoFichero(acuifero.Id, pozoFile);
                }
                //4- Parseamos recargas
                if (System.IO.File.Exists(recargaFile))
                {
                    await recargaController.ParseoFichero(acuifero.Id, recargaFile);
                }

            }
            catch (DbUpdateConcurrencyException)
            {
                if (!AcuiferoExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return CreatedAtAction("GetAcuifero", new { id = acuifero.Id }, acuifero);
        }

        // POST: api/Acuifero
        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
        [HttpPost]
        public async Task<ActionResult<Acuifero>> PostAcuifero([FromBody] DatosPostAcuifero datos)
        {
            Acuifero acuifero = new Acuifero();
            acuifero.Nombre = datos.Nombre;
            string pathZip = @"C:\Users\Admin\Desktop\";
            string pathExtract = @"C:\Users\Admin\Desktop\TestExtract\";
            string pozoFile, recargaFile;
            List<string> files;
            Parser parser = new();

            try
            {
                byte[] tempBytes = Convert.FromBase64String(datos.Fichero.Base64);
                System.IO.File.WriteAllBytes(pathZip + datos.Fichero.Nombre, tempBytes);

            }
            catch (Exception ex)
            {
                return Problem(ex.Message);
            }

            acuifero.Fichero = datos.Fichero.Nombre;

            try
            {

                //Como se crea el acuifero, no tiene simulacion 0, por lo que se insertan los datos de los pozos y recargas
                //1- Descomprimimos el fichero zip
                ZipFile.ExtractToDirectory(pathZip + datos.Fichero.Nombre, pathExtract, true);
                files = Directory.GetFiles(pathExtract).ToList<string>();
                //1.2 - Obtencion de coordenadas de origen (en el mundo) del modelo
                string geoFile = files.Find(x => x.Contains(".vmf"));
                string world_origin_x, world_origin_y;

                parser.GetGeolocalizationFromFile(geoFile, out world_origin_x, out world_origin_y);

                acuifero.WorldOriginX = world_origin_x;
                acuifero.WorldOriginY = world_origin_y;

                _context.Acuiferos.Add(acuifero);
                await _context.SaveChangesAsync();

                //2- Obtenemos nombre de los ficheros de pozos y recargas 
                pozoFile = files.Find(x => x.Contains(".VMW"));
                recargaFile = files.Find(x => x.Contains(".VMP"));

                //3- Parseamos pozos
                if (System.IO.File.Exists(pozoFile))
                {
                    await pozoController.ParseoFichero(acuifero.Id, pozoFile);
                }
                //4- Parseamos recargas
                if (System.IO.File.Exists(recargaFile))
                {
                    await recargaController.ParseoFichero(acuifero.Id, recargaFile);
                }
            }
            catch (DbUpdateException)
            {
                if (AcuiferoExists(acuifero.Id))
                {
                    return Conflict();
                }
                else
                {
                    throw;
                }
            }

            return CreatedAtAction("GetAcuifero", new { id = acuifero.Id }, acuifero);
        }

        // DELETE: api/Acuifero/5
        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteAcuifero(int id)
        {
            var acuifero = await _context.Acuiferos.FindAsync(id);
            if (acuifero == null)
            {
                return NotFound();
            }

            _context.Acuiferos.Remove(acuifero);
            await _context.SaveChangesAsync();

            return NoContent();
        }

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

        [NonAction]
        public string GetFicheroZip(uint id)
        {
            var acuifero = _context.Acuiferos.Find(id);

            if (acuifero != null)
            {
                return acuifero.Fichero;
            }

            return string.Empty;
        }

        [NonAction]
        public async Task<IActionResult> SetRechargeGeometry(uint id, string recharge_geometry)
        {
            Acuifero aquifer = _context.Acuiferos.Find(id);

            aquifer.RechargeGeometry = recharge_geometry;

            _context.Entry(aquifer).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!AcuiferoExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return CreatedAtAction("GetAcuifero", new { id = aquifer.Id }, aquifer);
        }
    }
}