Version estable

WorkerService1/WebApplication3/Clases/Constants.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace WebApplication3.Clases
+{
+    public static class Constants
+    {
+        public const string PathZip = @"C:\Users\Admin\Desktop\";
+        public const string PathExtract = @"C:\Users\Admin\Desktop\TestExtract\";
+        public const string PathModflow = @"C:\Users\Admin\Downloads\MF2005.1_12\MF2005.1_12\bin\mf2005.exe";
+        public static readonly Dictionary<string, string> _recharge_geometry_colors = new()
+        {
+            { "1", "#003366" },
+            { "2", "#996699" },
+            { "3", "#CCFF33" },
+            { "4", "#00FF99" },
+            { "5", "#CC0000" },
+            { "6", "#FF6600" },
+            { "7", "#660099" },
+            { "8", "#266A2E" }
+        };
+    }
+}

WorkerService1/WebApplication3/Clases/DatosPostAcuifero.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace WebApplication3.Clases
+{
+    public class DatosPostAcuifero
+    {
+        public string Nombre { get; set; }
+        public Fichero Fichero { get; set; }
+    }
+}

WorkerService1/WebApplication3/Clases/DatosPostSimulacion.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace WebApplication3.Clases
+{
+    public class DatosPostSimulacion
+    {
+        public string Nombre { get; set; }
+        public Fichero Fichero { get; set; }
+    }
+}

WorkerService1/WebApplication3/Clases/DatosPozoRecarga.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace WebApplication3.Clases
+{
+    public class DatosPozoRecarga
+    {
+        public uint Id { get; set; }
+        public string Nombre { get; set; }
+        public uint? Acuifero { get; set; }
+        public uint? Simulacion { get; set; }
+        public string Minimo { get; set; }
+        public string Maximo { get; set; }
+        public string Latitud { get; set; }
+        public string Longitud { get; set; }
+        public TimeSerie[] Ts {get; set;}
+    }
+}

WorkerService1/WebApplication3/Clases/Feature.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WebApplication3.Clases
+{
+    public class Feature
+    {
+        public string Type { get; set; }
+        public string Properties { get; set; }
+        public Geometry Geometry { get; set; }
+    }
+}

WorkerService1/WebApplication3/Clases/Fichero.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace WebApplication3.Clases
+{
+    public class Fichero
+    {
+        public string Nombre { get; set; }
+        public string Base64 { get; set; }
+    }
+}

WorkerService1/WebApplication3/Clases/GeoJson.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WebApplication3.Clases
+{
+    public class GeoJson
+    {
+        public string Type { get; set; }
+        public string Creator { get; set; }
+        public Feature[] Features { get; set; }
+
+    }
+}

WorkerService1/WebApplication3/Clases/Geometry.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WebApplication3.Clases
+{
+    public class Geometry
+    {
+        public string Type { get; set; }
+        public List<List<float>> Coordinates { get; set; }
+    }
+}

WorkerService1/WebApplication3/Clases/Logger.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Diagnostics;
+using System.Net.Http;
+using System.IO;
+
+namespace WebApplication3.Clases
+{
+    class Logger
+    {
+        
+        private static readonly Logger _instancia = new Logger();
+        
+
+        private Logger()
+        {
+
+        }
+
+        public static Logger GetInstance() => _instancia;
+
+        public static void WriteLog(string message)
+        {
+            string path = @"C:\Users\Admin\Desktop\log.txt";
+
+            if (!File.Exists(path))
+            {
+                // Create a file to write to.
+                using (StreamWriter sw = File.CreateText(path))
+                {
+                    sw.WriteLine(DateTime.Now + " " + message);
+                }
+            }
+            else
+            {
+
+                using (StreamWriter sw = File.AppendText(path))
+                {
+                    sw.WriteLine(DateTime.Now + " " + message);
+                }
+            }
+        }
+    }
+}

WorkerService1/WebApplication3/Clases/Parser.cs

@@ -0,0 +1,779 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using System.IO;
+using WebApplication3.Models;
+using System.Globalization;
+using Microsoft.VisualBasic.FileIO;
+
+namespace WebApplication3.Clases
+{
+    public class Parser
+    {
+        public WellData[] ParseWellData(string textFile)
+        {
+            if (File.Exists(textFile))
+            {
+                StreamReader file = new StreamReader(textFile);
+                //WellData[] wellData = null;
+                List<WellData> wellDataList = null;
+                
+                WellData wellData = null;
+                string ln;
+                int cont = 0;
+                int index = 0;
+                bool intervalSkipped = false;
+                int finalBloque = 0;
+                string[] values;
+
+
+                while ((ln = file.ReadLine()) != null)
+                {
+                    if (wellData == null)
+                    {
+                        //wellData = new WellData[int.Parse(ln)];
+                        wellDataList = new List<WellData>(int.Parse(ln));
+                        wellData = new WellData();
+                        cont++;
+                        continue;
+                    }
+
+                    if (!intervalSkipped)
+                    {
+                        switch (cont)
+                        {
+                            case 1:
+                                //wellData[index].ActiveFlag = (ln == "0") ? false : true;
+                                wellData.ActiveFlag = ln != "0";
+                                break;
+                            case 2:
+                                //wellData[index].WellName = ln;
+                                wellData.WellName = ln;
+                                break;
+                            case 3:
+                                //wellData[index].X = double.Parse(ln);
+                                wellData.X = ln;
+                                break;
+                            case 4:
+                                //wellData[index].Y = double.Parse(ln);
+                                wellData.Y = ln;
+                                break;
+                            case 5:
+                                //wellData[index].ZMin = ln;
+                                values = ln.Split(" ");
+                                wellData.ZMin = values[0].Replace(".", ",");
+                                break;
+                            case 6:
+                                //wellData[index].ZMax = ln;
+                                values = ln.Split(" ");
+                                wellData.ZMax = values[0].Replace(".", ",");
+                                break;
+                            case 7:
+                                //wellData[index].ScreenIntervals = int.Parse(ln);
+                                wellData.ScreenIntervals = int.Parse(ln);
+                                //cont += (wellData[index].ScreenIntervals * 2) - 1;
+                                intervalSkipped = true;
+                                //leemos tantas lineas hay como intervalos de pantalla (al ser 2 parametros por cada intervalo es nIntervalos * 2
+                                //for (int i = 0; i < wellData[index].ScreenIntervals * 2; i++)
+                                for (int i = 0; i < wellData.ScreenIntervals * 2; i++)
+                                {
+                                    file.ReadLine();
+                                    cont++;
+                                }
+
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                    else
+                    {
+                        //if (wellData[index].PumpPeriods == 0)
+                        if (wellData.PumpPeriods == 0)
+                        {
+                            //wellData[index].PumpPeriods = int.Parse(ln);
+                            wellData.PumpPeriods = int.Parse(ln);
+                            //se calcula en que linea termina el bloque del pozo
+                            //finalBloque = cont + wellData[index].PumpPeriods + 1;
+                            finalBloque = cont + 1 + wellData.PumpPeriods * 3;
+                        }
+                        else
+                        {
+                            TimeSerieInterno ts = new TimeSerieInterno();
+                            string aux = "";
+                            //Rate rate = new Rate();
+                            ts.Hora = ln;
+                            //rate.StartTime = float.Parse(ln.Replace('.', ','));
+
+                            ln = file.ReadLine();
+                            cont++;
+                            
+                            if(cont == finalBloque - 1)
+                            {
+                                aux = ln;
+                            }
+
+                            ln = file.ReadLine();
+                            cont++;
+                            //Separamos la cadena por " " 
+                            //TODO -> igual es un \t
+                            string[] exploded = ln.Split(" ");
+                            //Solo nos interesa el primer valor
+                            string value = exploded[0].Replace('.', ',');
+                            ts.Valor = value;
+                            ts.Info = ln.Replace(exploded[0] + ' ', "");
+                            //rate.Value = double.Parse(value);
+                            //wellData[index].Rates.Add(rate);
+                            wellData.Rates.Add(ts);
+
+                            if(aux != "")
+                            {
+                                ts = new TimeSerieInterno();
+                                ts.Hora = aux;
+                                ts.Valor = value;
+                                ts.Info = ln.Replace(exploded[0] + ' ', "");
+                                wellData.Rates.Add(ts);
+                            }
+                        }
+                    }
+
+                    cont++;
+
+                    //hemos llegado al final del primer bloque de pozo, preparamos para el siguiente
+                    if (finalBloque == cont)
+                    {
+                        intervalSkipped = false;
+                        index++;
+                        wellDataList.Add(wellData);
+                        wellData = new WellData();
+                        cont = 1;
+                    }
+
+                }
+                file.Close();
+
+                return wellDataList.ToArray();
+            }
+
+            return null;
+        }
+
+        public RechargeData[] ParseRechargeData(string textFile,out string recharge_geometry)
+        {
+            List<RechargeData> recharges = new List<RechargeData>();
+            RechargeData rechargeData = null;
+            TimeSerieInterno timeSerie;
+            string rechargeProperty="";
+            recharge_geometry = "";
+
+            if (File.Exists(textFile))
+            {
+                Console.WriteLine("File exist");
+                string text = File.ReadAllText(textFile);
+                string[] data = text.Split("\r\n\r\n");
+
+                int layers = int.Parse(data[0][0].ToString());
+                int blankLinePerBlock = layers + 1;
+                int rechargeBlockInex = blankLinePerBlock * 2;
+
+                Console.WriteLine(data[rechargeBlockInex]);
+                string[] explode = data[rechargeBlockInex].Split("\r\n");
+
+                for(int i = 3; i < explode.Length; i++)
+                {
+                    string[] values = explode[i].Split(" ", StringSplitOptions.RemoveEmptyEntries);
+
+                    //Si hay cambio de propiedad se crea otro RechargeData
+                    if(rechargeProperty != values[0])
+                    {
+                        if(rechargeProperty != "")
+                        {
+                            recharges.Add(rechargeData);
+                        }
+
+                        rechargeData = new RechargeData();
+                        rechargeData.Nombre = "Recarga_" + values[0];
+                        rechargeProperty = values[0];
+                    }
+
+                    timeSerie = new TimeSerieInterno();
+                    timeSerie.Hora = values[2];
+                    timeSerie.Valor = values[1];
+                    timeSerie.Info = values[4] + " " + values[5];
+
+                    rechargeData.Rates.Add(timeSerie);
+                    
+                    //se anyade el ultimo registro de tiempo ya que solo nos quedamos con la primera marca de tiempo de cada linea
+                    if(i == explode.Length - 1)
+                    {
+                        timeSerie = new TimeSerieInterno();
+                        timeSerie.Hora = values[3];
+                        timeSerie.Valor = values[1];
+                        timeSerie.Info = values[4] + " " + values[5];
+                        rechargeData.Rates.Add(timeSerie);
+                    }
+                }
+                recharge_geometry = data[rechargeBlockInex + layers];
+
+                //Se anyade la ultima instancia de rechargeData ya que no se produce cambio en la ultima iteracion del bucle
+                recharges.Add(rechargeData);
+
+                return recharges.ToArray();
+            }
+            else
+            {
+                Console.WriteLine("File does not exist");
+            }
+
+            return null;
+        }
+
+        public List<string> ParseInFile(string textFile)
+        {
+            Console.WriteLine("File exist");
+            string text = File.ReadAllText(textFile);
+
+            List<string> lines = new();
+            List<string> aux = new();
+
+            //Introducimos todas las lineas
+            aux.AddRange(text.Split("\r\n").ToList());
+
+            //Se eliminan las referencias a ficheros que no son validos para el modelo
+
+            aux.RemoveAll(x => x.Contains("WHS") || x.Contains("NDC") || x.Contains("CLB") || x == "");
+
+            foreach (string row in aux)
+            {
+                string[] rowSplit = row.Split(" ", StringSplitOptions.RemoveEmptyEntries);
+                Console.WriteLine(rowSplit);
+
+                if (rowSplit[0] == "LIST" && int.Parse(rowSplit[1]) < 10)
+                {
+                    rowSplit[1] = "12";
+                }
+
+                //Se tiene que parsear la 3a parte del string porque contiene la ruta absoluta del ordenador donde se han originado los ficheros
+                List<string> ficheroSplit = rowSplit[2].Split("\\").ToList();
+                rowSplit[2] = ficheroSplit.Last();
+
+                lines.Add(rowSplit[0] + " " + rowSplit[1] + " " + rowSplit[2]);
+            }
+            return lines;
+
+        }
+
+        public ZoneBalance[] ParseZonesBalance(string textFile)
+        {
+
+            List<ZoneBalance> zonesOutput = new List<ZoneBalance>();
+                
+            string text = File.ReadAllText(textFile);
+            string[] data = text.Split(" test                                                                            \r\n \r\n", StringSplitOptions.RemoveEmptyEntries);
+
+            List<string> data_aux = data[1].Split("\r\n").ToList();
+            string zones = data_aux.Find(x => x.Contains("zones"));
+            int index = data_aux.IndexOf(zones);
+            string[] zone_names = data_aux[index + 1].Split("    ", StringSplitOptions.RemoveEmptyEntries);
+            int zonesConectionPerZone = zone_names.Length - 1;
+            Logger logger = Logger.GetInstance();
+
+
+            for (int z = 2; z < data.Length; z++)
+            {
+                List<string> balanceData = data[z].Split("\r\n", StringSplitOptions.RemoveEmptyEntries).ToList();
+                ZoneBalance zoneBalance = new ZoneBalance();
+
+
+
+                string storage, constantHead, drains, recharge, total, percentDisparity;
+                string auxFind, auxSplit, zoneConnectionLine;
+                string[] split;
+
+                split = balanceData[0].Trim().Split(" ", StringSplitOptions.RemoveEmptyEntries);
+                zoneBalance.Zone = split[4];
+                zoneBalance.StressPeriod = int.Parse(split[12]);
+
+
+                #region IN
+                //buscamos el indice en el cual empieza el bloque de los datos de salida
+                auxFind = balanceData.Find(x => x.Contains("IN:"));
+                index = balanceData.IndexOf(auxFind);
+
+                //el primer dado del bloque se encuentra 2 indices despues del obtenido
+                index += 2;
+
+                auxSplit = balanceData[index].Split("STORAGE =")[1];
+                storage = auxSplit;
+                index++;
+
+                auxSplit = balanceData[index].Split("CONSTANT HEAD =")[1].Trim();
+                constantHead = auxSplit;
+                index++;
+
+                auxSplit = balanceData[index].Split("DRAINS =")[1].Trim();
+                drains = auxSplit;
+                index++;
+
+                auxSplit = balanceData[index].Split("RECHARGE =")[1].Trim();
+                recharge = auxSplit;
+                index++;
+
+                //Zone connections 
+                for (int i = index; i < index + zonesConectionPerZone; i++)
+                {
+                    zoneConnectionLine = balanceData[i].Trim();
+                    split = zoneConnectionLine.Split("to");
+
+                    ZoneConnection zoneConnection = new ZoneConnection();
+                    zoneConnection.From = split[0].Split("Zone")[1].Trim();
+                    zoneConnection.To = split[1].Split("=")[0].Trim();
+                    zoneConnection.Value = split[1].Split("=")[1].Trim();
+
+                    zoneBalance.In.ZoneConnections.Add(zoneConnection);
+                }
+
+                //Para el total hay que buscar el indice porque al haber fluctuacion entre zonas no podemos saber el indice fijo de la linea donde se encuentra de forma directa
+                auxFind = balanceData.Find(x => x.Contains("Total IN"));
+                index = balanceData.IndexOf(auxFind);
+                auxSplit = balanceData[index].Split("Total IN =")[1].Trim();
+                total = auxSplit;
+
+                zoneBalance.In.Storage = storage;
+                zoneBalance.In.ConstantHead = constantHead;
+                zoneBalance.In.Drains = drains;
+                zoneBalance.In.Recharge = recharge;
+                zoneBalance.In.Total = total;
+                #endregion
+
+                #region OUT
+                //buscamos el indice en el cual empieza el bloque de los datos de salida
+                auxFind = balanceData.Find(x => x.Contains("OUT:"));
+                index = balanceData.IndexOf(auxFind);
+
+                //el primer dado del bloque se encuentra 2 indices despues del obtenido
+                index += 2;
+
+                auxSplit = balanceData[index].Split("STORAGE =")[1];
+                storage = auxSplit;
+                index++;
+
+                auxSplit = balanceData[index].Split("CONSTANT HEAD =")[1].Trim();
+                constantHead = auxSplit;
+                index++;
+
+                auxSplit = balanceData[index].Split("DRAINS =")[1].Trim();
+                drains = auxSplit;
+                index++;
+
+                auxSplit = balanceData[index].Split("RECHARGE =")[1].Trim();
+                recharge = auxSplit;
+                index++;
+
+                //Zone connections
+                for (int i = index; i < index + zonesConectionPerZone; i++)
+                {
+                    zoneConnectionLine = balanceData[i].Trim();
+                    split = zoneConnectionLine.Split("to");
+
+                    ZoneConnection zoneConnection = new ZoneConnection();
+                    zoneConnection.From = split[0].Split("Zone")[1].Trim();
+                    zoneConnection.To = split[1].Split("=")[0].Trim();
+                    zoneConnection.Value = split[1].Split("=")[1].Trim();
+
+                    zoneBalance.Out.ZoneConnections.Add(zoneConnection);
+                }
+
+                //Para el total hay que buscar el indice porque al haber fluctuacion entre zonas no podemos saber el indice fijo de la linea donde se encuentra de forma directa
+                auxFind = balanceData.Find(x => x.Contains("Total OUT"));
+                index = balanceData.IndexOf(auxFind);
+                auxSplit = balanceData[index].Split("Total OUT =")[1].Trim();
+                total = auxSplit;
+
+                zoneBalance.Out.Storage = storage;
+                zoneBalance.Out.ConstantHead = constantHead;
+                zoneBalance.Out.Drains = drains;
+                zoneBalance.Out.Recharge = recharge;
+                zoneBalance.Out.Total = total;
+                #endregion
+
+                auxFind = balanceData.Find(x => x.Contains("IN - OUT"));
+                index = balanceData.IndexOf(auxFind);
+
+                auxSplit = balanceData[index].Split("IN - OUT = ")[1].Trim();
+                total = auxSplit;
+
+                auxFind = balanceData.Find(x => x.Contains("Percent Discrepancy = "));
+                index = balanceData.IndexOf(auxFind);
+                auxSplit = balanceData[index].Split("Percent Discrepancy = ")[1].Trim();
+                percentDisparity = auxSplit;
+
+                zoneBalance.TotalInOut = total;
+                zoneBalance.PercentDiscrepancy = percentDisparity;
+
+                zonesOutput.Add(zoneBalance);
+            }
+            return zonesOutput.ToArray();
+        }
+
+        public ZoneBalance[] ParseWholeModelBalance(string textfile)
+        {
+            
+            string text = File.ReadAllText(textfile);
+            string[] data = text.Split(" DRAWDOWN WILL BE SAVED ON UNIT  151 AT END OF TIME STEP   10, STRESS PERIOD", StringSplitOptions.RemoveEmptyEntries);
+
+            List<ZoneBalance> zoneBalances = new List<ZoneBalance>();
+
+
+            for (int i = 1; i < data.Length; i++)
+            {
+                ZoneBalance cummulative = new ZoneBalance();
+                ZoneBalance current = new ZoneBalance();
+
+                cummulative.Zone = "Zone 0";
+                cummulative.StressPeriod = i;
+                cummulative.Type = 1;
+
+                current.Zone = "Zone 0";
+                current.StressPeriod = i;
+                current.Type = 2;
+
+
+                List<string> data_aux = data[i].Split("\r\n").ToList();
+                string[] split = data_aux[2].Split("STRESS PERIOD");
+
+
+                #region IN
+                split = data_aux[10].Split("STORAGE =", StringSplitOptions.RemoveEmptyEntries);
+                cummulative.In.Storage = split[1].Trim();
+                current.In.Storage = split[2].Trim();
+
+                split = data_aux[11].Split("CONSTANT HEAD =", StringSplitOptions.RemoveEmptyEntries);
+                cummulative.In.ConstantHead = split[1].Trim();
+                current.In.ConstantHead = split[2].Trim();
+
+                split = data_aux[12].Split("DRAINS =", StringSplitOptions.RemoveEmptyEntries);
+                cummulative.In.Drains = split[1].Trim();
+                current.In.Drains = split[2].Trim();
+
+                split = data_aux[13].Split("RECHARGE =", StringSplitOptions.RemoveEmptyEntries);
+                cummulative.In.Recharge = split[1].Trim();
+                current.In.Recharge = split[2].Trim();
+
+                split = data_aux[15].Split("TOTAL IN =", StringSplitOptions.RemoveEmptyEntries);
+                cummulative.In.Total = split[1].Trim();
+                current.In.Total = split[2].Trim();
+                #endregion
+
+                #region OUT
+                split = data_aux[19].Split("STORAGE =", StringSplitOptions.RemoveEmptyEntries);
+                cummulative.Out.Storage = split[1].Trim();
+                current.Out.Storage = split[2].Trim();
+
+                split = data_aux[20].Split("CONSTANT HEAD =", StringSplitOptions.RemoveEmptyEntries);
+                cummulative.Out.ConstantHead = split[1].Trim();
+                current.Out.ConstantHead = split[2].Trim();
+
+                split = data_aux[21].Split("DRAINS =", StringSplitOptions.RemoveEmptyEntries);
+                cummulative.Out.Drains = split[1].Trim();
+                current.Out.Drains = split[2].Trim();
+
+                split = data_aux[22].Split("RECHARGE =", StringSplitOptions.RemoveEmptyEntries);
+                cummulative.Out.Recharge = split[1].Trim();
+                current.Out.Recharge = split[2].Trim();
+
+                split = data_aux[24].Split("TOTAL OUT =", StringSplitOptions.RemoveEmptyEntries);
+                cummulative.Out.Total = split[1].Trim();
+                current.Out.Total = split[2].Trim();
+                #endregion
+
+                split = data_aux[26].Split("IN - OUT =", StringSplitOptions.RemoveEmptyEntries);
+                cummulative.TotalInOut = split[1].Trim();
+                current.TotalInOut = split[2].Trim();
+
+                split = data_aux[28].Split("PERCENT DISCREPANCY =", StringSplitOptions.RemoveEmptyEntries);
+                cummulative.PercentDiscrepancy = split[1].Trim();
+                current.PercentDiscrepancy = split[2].Trim();
+
+                zoneBalances.Add(cummulative);
+                zoneBalances.Add(current);
+            }
+
+            return zoneBalances.ToArray();
+        }
+
+        public List<Piezometria> ParseBinaryFile(string file, uint? simulacionId)
+        {
+            List<Piezometria> piezometria = new List<Piezometria>();
+            Logger.WriteLog("Parseando fichero binario");
+            if (File.Exists(file))
+            {
+                try
+                {
+                    using (FileStream fs = new FileStream(file, FileMode.Open))
+                    using (BinaryReader brr = new BinaryReader(fs))
+                    {
+                        Logger.WriteLog("Fichero existente y abierto");
+                        while (fs.Length != fs.Position) // This will throw an exception for non-seekable streams (stream.CanSeek == false), but filestreams are seekable so it's OK here
+                        {
+                            Piezometria p = new();
+                            p.IdSimulacion = simulacionId;
+
+                            int KSTP = brr.ReadInt32();
+                            int KPER = brr.ReadInt32();
+                            var PERTIM = brr.ReadSingle();
+                            var TOTIM = brr.ReadSingle();
+                            char[] auxDESC = brr.ReadChars(16);
+                            string DESC = new(auxDESC);
+                            int NCOL = brr.ReadInt32();
+                            int NROW = brr.ReadInt32();
+                            int ILAY = brr.ReadInt32();
+
+                            p.Layer = ILAY;
+                            p.StressPeriod = KPER;
+                            p.Rows = NROW;
+                            p.Columns = NCOL;
+
+                            List<float> values = new();
+                            for (int i = 0; i < NROW * NCOL; i++)
+                            {
+                                values.Add(brr.ReadSingle());
+                            }
+
+
+                            int c = 1;
+                            string original = "";
+                            string convertida = "";
+                            foreach (float v in values)
+                            {
+                                if (c < NCOL)
+                                {
+                                    original += v + "   ";
+
+                                    //Check for range + color conversion
+                                    //convertida += Constants.piezometry_conversion[v.ToString()] + ",";
+                                }
+                                else if (c == NCOL)
+                                {
+                                    //Add \n to the string
+                                    original += "\n";
+                                    //convertida += "\n";
+                                    c = 0;
+                                }
+                                c++;
+                            }
+                            p.Original = original;
+                            p.Convertida = convertida;
+
+                            piezometria.Add(p);
+                            
+                        }
+                    }
+                }catch(Exception ex)
+                {
+                    Logger.WriteLog(ex.Message);
+                    Logger.WriteLog(ex.InnerException.Message);
+                }
+            }
+            return piezometria;
+        }
+
+        public void GetGeolocalizationFromFile(string file,out string worldX,out string worldY)
+        {
+
+            string text = File.ReadAllText(file);
+
+            List<string> data = text.Split("\r\n").ToList();
+            //string geolocationData = data[2];
+            string geolocation_line = data.Find(x=> x.Contains("<Georeference"));
+
+            string[] geolocation_data = geolocation_line.Split(" ");
+            string[] world_origin_x = geolocation_data[1].Split("=");
+            string[] world_origin_y = geolocation_data[2].Split("=");
+
+            
+            worldX = world_origin_x[1].Replace("\"",string.Empty);
+            worldY = world_origin_y[1].Replace("\"",string.Empty);
+        }
+
+        public WellData[] parseWellCSV(string file)
+        {
+            List<WellData> wellsData = new();
+            WellData wellData = null;
+            using (TextFieldParser csvParser = new TextFieldParser(file))
+            {
+                csvParser.CommentTokens = new string[] { "#" };
+                csvParser.SetDelimiters(new string[] { "," });
+                csvParser.HasFieldsEnclosedInQuotes = true;
+
+                // Skip the row with the column names
+                csvParser.ReadLine();
+                string wellName = "";
+                string[] aux = Array.Empty<string>();
+                TimeSerieInterno tsInterno;
+                int pumpPeriods = 0;
+                while (!csvParser.EndOfData)
+                {
+                    // Read current line fields, pointer moves to the next line.
+                    string[] fields = csvParser.ReadFields();
+                    if (wellName != fields[0])
+                    {
+
+                        if (wellName == "")
+                        {
+                            aux = new string[fields.Length];
+                        }
+                        else
+                        {
+
+                            wellData.PumpPeriods = pumpPeriods;
+                            wellsData.Add(wellData);
+
+                            tsInterno = new();
+                            tsInterno.Hora = aux[11];
+                            tsInterno.Valor = aux[12];
+                            wellData.Rates.Add(tsInterno);
+                            pumpPeriods = 0;
+                        }
+
+                        wellData = new();
+                        wellData.WellName = fields[0];
+                        wellData.X = fields[1];
+                        wellData.Y = fields[2];
+                        wellData.Top = fields[5];
+                        wellData.Bot = fields[6];
+                        wellData.ZMin = fields[4];
+                        wellData.ZMax = fields[3];
+                        wellData.ScreenIntervals = 1;
+                        //wellData.ZMin = "";
+                        //wellData.ZMax = "";
+                        wellData.ActiveFlag = false;
+                        
+                        wellName = fields[0];
+                        
+                    }
+
+                    tsInterno = new ();
+                    tsInterno.Hora = fields[10];
+                    tsInterno.Valor = fields[12];
+
+                    wellData.Rates.Add(tsInterno);
+                    fields.CopyTo(aux, 0);
+                    pumpPeriods++;
+                }
+
+                wellData.PumpPeriods = pumpPeriods;
+
+                tsInterno = new();
+                tsInterno.Hora = aux[11];
+                tsInterno.Valor = aux[12];
+                wellData.Rates.Add(tsInterno);
+                wellsData.Add(wellData);
+            }
+
+            return wellsData.ToArray();
+        }
+
+        public RechargeData[] parseRechargeCSV(string file)
+        {
+            List<RechargeData> rechargeDatas = new();
+            RechargeData rechargeData = new();
+            TimeSerieInterno ts;
+            string[] aux = Array.Empty<string>();
+            using (TextFieldParser csvParser = new TextFieldParser(file))
+            {
+                csvParser.CommentTokens = new string[] { "#" };
+                csvParser.SetDelimiters(new string[] { "," });
+                csvParser.HasFieldsEnclosedInQuotes = true;
+
+                // Skip the row with the column names
+                csvParser.ReadLine();
+
+                while (!csvParser.EndOfData)
+                {
+                    // Read current line fields, pointer moves to the next line.
+                    string[] fields = csvParser.ReadFields();
+
+                    if(rechargeData.Nombre == null)
+                    {
+                        rechargeData.Nombre = fields[0];
+                        aux = new string[fields.Length];
+                    }
+
+                    ts = new();
+                    ts.Valor = fields[3];
+                    ts.Hora = fields[1];
+                    //ts.HoraEnd = fields[2];
+                    rechargeData.Rates.Add(ts);
+                    fields.CopyTo(aux, 0);
+                }
+
+                ts = new();
+                ts.Valor = aux[3];
+                ts.Hora = aux[2];
+                //ts.HoraEnd = fields[2];
+                rechargeData.Rates.Add(ts);
+                rechargeDatas.Add(rechargeData);
+            }
+
+
+            return rechargeDatas.ToArray();
+        }
+
+        public PiezometerData[] parsePiezometerCSV(string file)
+        {
+            List<PiezometerData> piezometerDatas = new();
+            PiezometerData piezometerData = null;
+            TimeSerieInterno ts;
+            string[] aux = Array.Empty<string>();
+            string piezometerName = "";
+            using (TextFieldParser csvParser = new TextFieldParser(file))
+            {
+                csvParser.CommentTokens = new string[] { "#" };
+                csvParser.SetDelimiters(new string[] { "," });
+                csvParser.HasFieldsEnclosedInQuotes = true;
+
+                // Skip the row with the column names
+                csvParser.ReadLine();
+
+                while (!csvParser.EndOfData)
+                {
+                    // Read current line fields, pointer moves to the next line.
+                    string[] fields = csvParser.ReadFields();
+
+                    if (piezometerName != fields[0])
+                    {
+                        if(piezometerName == "")
+                        {
+                            aux = new string[fields.Length];
+                        }else
+                        {
+
+                        }
+
+                        piezometerData = new();
+                        piezometerData.Name = fields[0];
+                        piezometerData.X = fields[1];
+                        piezometerData.Y = fields[2];
+                        piezometerData.Z = fields[3];
+                        piezometerData.Prof = fields[4];
+                        piezometerData.Screen_top = fields[5];
+                        piezometerData.Screen_bot = fields[6];
+                    }
+
+                    ts = new();
+                    ts.DateIn = fields[8];
+                    ts.Hora = fields[9];
+                    ts.Valor = fields[10];
+                    
+                    piezometerData.Rates.Add(ts);
+                    //fields.CopyTo(aux, 0);
+                }
+            }
+
+
+            return piezometerDatas.ToArray();
+        }
+    }
+}

WorkerService1/WebApplication3/Clases/PiezometerData.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using WebApplication3.Models;
+
+namespace WebApplication3.Clases
+{
+    public class PiezometerData
+    {
+        public string Name { get; set; }
+        public string X { get; set; }
+        public string Y { get; set; }
+        public string Z { get; set; }
+        public string Prof { get; set; }
+        public string Screen_top { get; set; }
+        public string Screen_bot { get; set; }
+        public List<TimeSerieInterno> Rates { get; set; }
+
+
+        public Piezometer ToPiezometer()
+        {
+            Piezometer piezometer = new();
+            piezometer.Name = this.Name;
+            piezometer.X = this.X;
+            piezometer.Y = this.Y;
+            piezometer.Z = this.Z;
+            piezometer.Prof = this.Prof;
+            piezometer.ScreenTop = this.Screen_top;
+            piezometer.ScreenBot = this.Screen_bot;
+
+            return piezometer;
+        }
+    }
+}

WorkerService1/WebApplication3/Clases/Proceso.cs

@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Diagnostics;
+using System.Net.Http;
+
+namespace WebApplication3.Clases
+{
+    class Proceso
+    {
+        private Process proceso;
+        private static readonly Proceso _instancia = new Proceso();
+        private bool _detected;
+        private bool _started;
+        private HttpClient client = new HttpClient();
+
+
+        private Proceso()
+        {
+            proceso = new Process();
+            //_proceso.StartInfo.WorkingDirectory = "C:\\Users\\Admin\\Downloads\\00_Aquifer_Supervision_0 3\\00_Aquifer_Supervision_0\\TRASLADADO SIN EJECUTAR\\";
+            //_proceso.StartInfo.FileName = "mf2005.exe";
+            //_proceso.StartInfo.Arguments = "AA.modflow.in";
+            _detected = false;
+            _started = false;
+        }
+
+        public static Proceso GetInstance() => _instancia;
+
+        public void setParametersModflow(string workingDirectory, string arguments)
+        {
+            proceso.StartInfo.WorkingDirectory = workingDirectory;
+            proceso.StartInfo.FileName = @"C:\Users\Admin\Downloads\MF2005.1_12\MF2005.1_12\bin\mf2005.exe";
+            proceso.StartInfo.Arguments = arguments;
+            proceso.StartInfo.UseShellExecute = true;
+
+        }
+
+        public void setParametersZoneBudget(string workingDirectory)
+        {
+            proceso.StartInfo.WorkingDirectory = workingDirectory;
+            proceso.StartInfo.FileName = @"C:\WRDAPP\Zonbud.3_01\Bin\zonbud.exe";
+            proceso.StartInfo.Arguments = "";
+            proceso.StartInfo.RedirectStandardInput = true;
+
+        }
+
+        public void setParametersPython(string workingDirectory,string headFile, int rows, int cols, int isolines)
+        {
+            proceso.StartInfo.WorkingDirectory = workingDirectory;
+            //proceso.StartInfo.FileName = @"C:\Users\Admin\AppData\Local\Programs\Python\Python39\python.exe";
+            proceso.StartInfo.FileName = "python";
+            var script = @"C:\Users\Admin\Desktop\test.py";
+            proceso.StartInfo.Arguments = script+" "+headFile+" "+rows+" "+cols+" "+isolines;
+            proceso.StartInfo.UseShellExecute = false;
+        }
+        public int GetPid()
+        {
+            return proceso.Id;
+        }
+
+        public bool HasExited()
+        {
+            return proceso.HasExited;
+        }
+
+        public void Kill()
+        {
+            proceso.Kill();
+        }
+
+
+        public void Start()
+        {
+            proceso.Start();
+            _started = true;
+        }
+
+        public void ExecuteZonebudget(string[] prompts)
+        {
+            proceso.StandardInput.WriteLine(prompts[0]);
+            proceso.StandardInput.WriteLine(prompts[1]);
+            proceso.StandardInput.WriteLine(prompts[2]);
+            proceso.StandardInput.WriteLine(prompts[3]);
+            proceso.StandardInput.WriteLine(prompts[4]);
+            proceso.WaitForExit();
+        }
+
+        public void ResetProcess()
+        {
+            proceso.StartInfo.WorkingDirectory = "";
+            proceso.StartInfo.FileName = "";
+            proceso.StartInfo.Arguments = "";
+            proceso.StartInfo.RedirectStandardInput = false;
+            proceso.StartInfo.UseShellExecute = false;
+            _detected = false;
+            _started = false;
+        }
+
+        public void WaitForExit()
+        {
+            proceso.WaitForExit();
+        }
+
+        public bool Started
+        {
+            get
+            {
+                return _started;
+            }
+            set
+            {
+                _started = value;
+            }
+        }
+
+        public bool Detected
+        {
+            get
+            {
+                return _detected;
+            }
+            set
+            {
+                _detected = value;
+            }
+        }
+        
+    }
+}

WorkerService1/WebApplication3/Clases/QueueWorker.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using WebApplication3.Clases;
+using System.IO;
+using WebApplication3.Controllers;
+using WebApplication3.Models;
+
+namespace WebApplication3.Clases
+{
+    public class QueueWorker : BackgroundService
+    {
+        private readonly ILogger<QueueWorker> _logger;
+        private ServicioController servicioController;
+        private SimulacionController simulacionController; 
+        private ServiceQueueController serviceQueueController;
+
+        public QueueWorker(ILogger<QueueWorker> logger)
+        {
+            _logger = logger;
+
+            var aquiferContext = new AquiferContext();
+            servicioController = new ServicioController(aquiferContext);
+            simulacionController = new SimulacionController(aquiferContext);
+            serviceQueueController = new ServiceQueueController(aquiferContext);
+        }
+
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                _logger.LogInformation("HEY QUEUE WORKER HERE", DateTimeOffset.Now);
+
+                var serviceRunning = await serviceQueueController.ServiceRunning();
+                _logger.LogInformation(serviceRunning.ToString(), DateTimeOffset.Now);
+
+                if (serviceRunning == false)
+                {
+                    _logger.LogInformation("NOTHING RUNNING", DateTimeOffset.Now);
+                    var nextInQueue = serviceQueueController.GetNextInQueue();
+                    if (nextInQueue != null)
+                    {
+                        _logger.LogInformation("RUNNING A SIM", DateTimeOffset.Now);
+                        _logger.LogInformation(nextInQueue.Id.ToString(), DateTimeOffset.Now);
+                        //Actualizamos el estado del item del servicio/simulacion a ejecutar
+                        //await serviceQueueController.SetCorriendo(nextInQueue.Id);
+                        //Se ejecuta la simulacion
+                        await simulacionController.SimulaAsync(nextInQueue);
+                        ////Se actualiza el estado del item ya que ha terminado su ejecucion
+                        //await serviceQueueController.SetTerminado(nextInQueue.Id);
+                    }
+                }
+                await Task.Delay(TimeSpan.FromMinutes(2), stoppingToken);
+            }
+        }
+
+        public void LogInfo(string msg)
+        {
+            _logger.LogInformation(msg);
+        }
+    }
+}

WorkerService1/WebApplication3/Clases/Rate.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace WebApplication3.Clases
+{
+    public class Rate
+    {
+        public decimal StartTime { get; set; }
+        public decimal Value { get; set; }
+    }
+}

WorkerService1/WebApplication3/Clases/RechargeData.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using WebApplication3.Models;
+
+namespace WebApplication3.Clases
+{
+    public class RechargeData
+    {
+        public RechargeData()
+        {
+            Rates = new List<TimeSerieInterno>();
+        }
+        public string Nombre { get; set; }
+        public List<TimeSerieInterno> Rates { get; set; }
+
+        public Recarga ToRecarga(uint acuifero)
+        {
+            Recarga recarga = new Recarga();
+
+            recarga.IdAcuifero = acuifero;
+            recarga.Nombre = this.Nombre;
+
+            return recarga;
+        }
+    }
+}

WorkerService1/WebApplication3/Clases/TimeSerie.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace WebApplication3.Clases
+{
+    public class TimeSerie
+    {
+        public string Hora { get; set; }
+        public string Valor { get; set; }
+    }
+}

WorkerService1/WebApplication3/Clases/TimeSerieInterno.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace WebApplication3.Clases
+{
+    public class TimeSerieInterno
+    {
+        public string Hora { get; set; }
+        public string HoraEnd { get; set; }
+        public string Valor { get; set; }
+        public string ValorEnd { get; set; }
+        public string DateIn { get; set; }
+        public string DateEnd { get; set; }
+        public string Info { get; set; }
+    }
+}

WorkerService1/WebApplication3/Clases/Utilities.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace WebApplication3.Clases
+{
+    public static class Utilities
+    {
+        public static bool String2Png(string data)
+        {
+            Logger.WriteLog("im in");
+            bool result = true;
+            List<string> rows = data.Split("\r\n",StringSplitOptions.RemoveEmptyEntries).ToList<string>();
+            Logger.WriteLog("rows has a lenght of" + rows.Count);
+            List<string> cols = rows[0].Split(" ",StringSplitOptions.RemoveEmptyEntries).ToList<string>();
+            Logger.WriteLog("cols has a length of " + cols.Count);
+            int width = cols.Count;
+            int height = rows.Count;
+            int[,] integers = new int[height, width];
+            int stride = width * 4;
+
+            string[,] array2Db = new string[height, width];
+            for(int i= 0; i < height; i++)
+            {
+                string[] values = rows[i].Split(" ",StringSplitOptions.RemoveEmptyEntries);
+                for(int j= 0; j< width; j++)
+                {
+                    string hexColor = Constants._recharge_geometry_colors[values[j]];
+                    array2Db[i, j] = hexColor;
+                }
+            }
+
+            // Fill array with random values
+            Random random = new Random();
+            for (int x = 0; x < height; ++x)
+            {
+                for (int y = 0; y < width; ++y)
+                {
+                    var color = System.Drawing.ColorTranslator.FromHtml(array2Db[x, y]);
+                    byte[] bgra = new byte[] { color.B, color.G, color.R, color.A };
+                    integers[x, y] = BitConverter.ToInt32(bgra, 0);
+                }
+            }
+
+            Bitmap b;
+            unsafe
+            {
+                fixed (int* intPtr = &integers[0, 0])
+                {
+                    b = new Bitmap(width, height, stride, PixelFormat.Format32bppRgb, new IntPtr(intPtr));
+                }
+            }
+
+
+            using (b)
+            {
+                b.Save(@"C:\Users\Admin\Desktop\AAAA\green.png", ImageFormat.Png);
+            }
+            return result;
+        }
+    }
+}

WorkerService1/WebApplication3/Clases/WellData.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using WebApplication3.Models;
+
+namespace WebApplication3.Clases
+{
+    //public struct TextRates
+    //{
+    //    string init;
+    //    string finish;
+    //    string rate;
+    //}
+    public class WellData
+    {
+        public WellData()
+        {
+            Rates = new List<TimeSerieInterno>();
+            //StringRates = new List<TextRates>();
+        }
+
+        public bool ActiveFlag { get; set; }
+        public string WellName { get; set; }
+        public string X { get; set; }
+        public string Y { get; set; }
+        public string ZMin { get; set; }
+        public string ZMax { get; set; }
+        public int ScreenIntervals { get; set; }
+        public string Bot { get; set; }
+        public string Top { get; set; }
+        public int PumpPeriods { get; set; }
+        public List<TimeSerieInterno> Rates { get; set; }
+        
+
+
+        public Pozo ToPozo(uint acuifero)
+        {
+            Pozo p = new Pozo();
+
+            p.IdAquifero = acuifero;
+            p.IdSimulacion = null;
+            p.Longitud = this.X;
+            p.Latitud = this.Y;
+            //p.Maximo = float.Parse(this.ZMax);
+            p.Maximo = "0";
+            //p.Minimo = float.Parse(this.ZMin);
+            p.Minimo = "0";
+            p.Nombre = this.WellName;
+            return p;
+        }
+
+        public WellData Copy()
+        {
+            WellData wellData = new WellData();
+            wellData.ActiveFlag = this.ActiveFlag;
+            wellData.Bot = this.Bot;
+            wellData.PumpPeriods = this.PumpPeriods;
+            wellData.Rates = this.Rates;
+            return wellData;
+        }
+    }
+}

WorkerService1/WebApplication3/Clases/Worker.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using WebApplication3.Clases;
+using System.IO;
+using WebApplication3.Controllers;
+using WebApplication3.Models;
+
+namespace WebApplication3.Clases
+{
+    public class Worker : BackgroundService
+    {
+        private readonly ILogger<Worker> _logger;
+        private ServicioController servicioController;
+        private ServiceQueueController serviceQueueController;
+
+        public Worker(ILogger<Worker> logger)
+        {
+            _logger = logger;
+
+            var aquiferContext = new AquiferContext();
+            servicioController = new ServicioController(aquiferContext);
+            serviceQueueController = new ServiceQueueController(aquiferContext);
+        }
+
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            
+            Proceso proceso = Proceso.GetInstance();
+
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                
+                try
+                {
+                    //logger.LogInformation("Process is started: "+proceso.Started+" and has exited "+proceso.HasExited()+" at: "+ DateTimeOffset.Now);
+                    //_logger.LogInformation("STATE OF PID: "+proceso.GetPid().ToString()+"is "+proceso.HasExited());
+                    if (proceso.Started && proceso.HasExited())
+                    {
+                        proceso.Started = false;
+                        proceso.Detected = true;
+
+                        int terminado = await servicioController.setTerminado(proceso.GetPid());
+                        
+                        if( terminado > 0)
+                        {
+                            _logger.LogInformation("Process " + proceso.GetPid() + " has terminated", DateTimeOffset.Now);
+                        }
+
+                    }
+                } catch (Exception ex)
+                {
+                    _logger.LogInformation(ex.Message, DateTimeOffset.Now);
+                }
+                await Task.Delay(1000, stoppingToken);
+            }
+        }
+
+        public void LogInfo(string msg)
+        {
+            _logger.LogInformation(msg);
+        }
+    }
+}

WorkerService1/WebApplication3/Clases/ZoneBalance.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using WebApplication3.Models;
+
+namespace WebApplication3.Clases
+{
+    public class ZoneBalance
+    {
+        public uint Id { get; set; }
+        public string Zone { get; set; }
+        public int StressPeriod { get; set; }
+        public ZoneData In { get; set; }
+        public ZoneData Out { get; set; }
+        public string TotalInOut { get; set; }
+        public string PercentDiscrepancy { get; set; }
+
+        /* 0-> Balance normal con conexion a otras zonas
+         * 1-> Balance acumulativo de la Zona 0
+         * 2-> Balance del periodo de stress concreto de la Zona 0
+        */
+        public int Type { get; set; }
+
+        public ZoneBalance()
+        {
+            In = new ZoneData();
+            Out = new ZoneData();
+        }
+
+        public ZoneBalance(BalanceHidrico bh)
+        {
+            Zone = bh.Zona;
+            StressPeriod = (int)bh.StressPeriod;
+            TotalInOut = bh.TotalZona;
+            Id = bh.Id;
+            //PercentDiscrepancy = bh.PercentDiscrepancy;
+        }
+
+        public void SetInOutData(ZoneData dataIn, ZoneData dataOut)
+        {
+            In = dataIn;
+            Out = dataOut;
+        }
+
+        public BalanceHidrico ToBalanceHidrico(uint? simulacionId)
+        {
+            BalanceHidrico bh = new BalanceHidrico();
+            bh.StressPeriod = this.StressPeriod;
+            bh.TotalZona = this.TotalInOut;
+            bh.Zona = this.Zone;
+            bh.IdSimulacion = simulacionId;
+            return bh;
+        }
+    }
+}

WorkerService1/WebApplication3/Clases/ZoneConnection.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using WebApplication3.Models;
+
+namespace WebApplication3.Clases
+{
+    public class ZoneConnection
+    {
+        public uint Id { get; set; }
+        public string From { get; set; }
+        public string To { get; set; }
+        public string Value { get; set; }
+
+        public ZoneConnection()
+        {
+
+        }
+        public ZoneConnection(ConexionZonasIn connectionIn)
+        {
+            Id = connectionIn.Id;
+            From = connectionIn.From;
+            To = connectionIn.To;
+            Value = connectionIn.Value;
+        }
+
+        public ZoneConnection(ConexionZonasOut connectionOut)
+        {
+            Id = connectionOut.Id;
+            From = connectionOut.From;
+            To = connectionOut.To;
+            Value = connectionOut.Value;
+        }
+
+        public ConexionZonasIn ToConexionIn(uint? idBalanceIn)
+        {
+            ConexionZonasIn conexionIn = new ConexionZonasIn();
+            conexionIn.From = this.From;
+            conexionIn.To = this.To;
+            conexionIn.Value = this.Value;
+            conexionIn.IdDatosBalanceIn = idBalanceIn;
+
+            return conexionIn;
+        }
+
+        public ConexionZonasOut ToConexionOut(uint? idBalanceOut)
+        {
+            ConexionZonasOut conexionOut = new ConexionZonasOut();
+            conexionOut.From = this.From;
+            conexionOut.To = this.To;
+            conexionOut.Value = this.Value;
+            conexionOut.IdDatosBalanceOut = idBalanceOut;
+
+            return conexionOut;
+        }
+
+    }
+}

WorkerService1/WebApplication3/Clases/ZoneData.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using WebApplication3.Models;
+
+namespace WebApplication3.Clases
+{
+    public class ZoneData
+    {
+        public uint Id { get; set; }
+        public string Storage { get; set; }
+        public string ConstantHead { get; set; }
+        public string Drains { get; set; }
+        public string Recharge { get; set; }
+        public string Total { get; set; }
+
+        public List<ZoneConnection> ZoneConnections { get; set; }
+
+        public ZoneData()
+        {
+            ZoneConnections = new List<ZoneConnection>();
+        }
+
+        public ZoneData(List<ZoneConnection> connections)
+        {
+            ZoneConnections = connections;
+        }
+
+        public ZoneData(DatosBalanceIn dataIn)
+        {
+            Id = dataIn.Id;
+            Storage = dataIn.Storage;
+            ConstantHead = dataIn.ConstantHead;
+            Drains = dataIn.Drains;
+            Recharge = dataIn.Recharge;
+            Total = dataIn.Total;
+            ZoneConnections = new List<ZoneConnection>();
+        }
+
+        public ZoneData(DatosBalanceOut dataIn)
+        {
+            Id = dataIn.Id;
+            Storage = dataIn.Storage;
+            ConstantHead = dataIn.ConstantHead;
+            Drains = dataIn.Drains;
+            Recharge = dataIn.Recharge;
+            Total = dataIn.Total;
+            ZoneConnections = new List<ZoneConnection>();
+        }
+
+        public DatosBalanceIn ToDatosBalanceIn(uint? idBalance)
+        {
+            DatosBalanceIn datosIn = new DatosBalanceIn();
+            datosIn.Storage = this.Storage;
+            datosIn.ConstantHead = this.ConstantHead;
+            datosIn.Drains = this.Drains;
+            datosIn.Recharge = this.Recharge;
+            datosIn.Total = this.Total;
+            datosIn.IdBalance = idBalance;
+
+            return datosIn;
+        }
+
+        public DatosBalanceOut ToDatosBalanceOut(uint? idBalance)
+        {
+            DatosBalanceOut datosOut = new DatosBalanceOut();
+            datosOut.Storage = this.Storage;
+            datosOut.ConstantHead = this.ConstantHead;
+            datosOut.Drains = this.Drains;
+            datosOut.Recharge = this.Recharge;
+            datosOut.Total = this.Total;
+            datosOut.IdBalance = idBalance;
+
+            return datosOut;
+        }
+
+    }
+}

WorkerService1/WebApplication3/Controllers/AcuiferoController.cs

@@ -0,0 +1,283 @@
+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);
+        }
+    }
+}

WorkerService1/WebApplication3/Controllers/BalanceHidricoController.cs

@@ -0,0 +1,290 @@
+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]
+        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);
+        }
+    }
+}

WorkerService1/WebApplication3/Controllers/PiezometerController.cs

@@ -0,0 +1,156 @@
+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 PiezometerController : ControllerBase
+    {
+        private readonly AquiferContext _context;
+        private TsPiezometerController tsPiezometerController;
+        
+        
+        public PiezometerController(AquiferContext context)
+        {
+            _context = context;
+            tsPiezometerController = new TsPiezometerController(context);
+            
+        }
+
+        // GET: api/Piezometer
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<Piezometer>>> GetPiezmeters()
+        {
+            return await _context.Piezometers.ToListAsync();
+        }
+
+        // GET: api/Piezometer/5
+        [HttpGet("{id}")]
+        public async Task<ActionResult<Piezometer>> GetPiezometer(uint id)
+        {            
+            var piezometer = await _context.Piezometers.FindAsync(id);
+            
+            if (piezometer == null)
+            {
+                return NotFound();
+            }
+            
+            return piezometer;
+        }
+
+        [HttpPost("Import")]
+        public async Task<ActionResult<bool>> ImportPiezometersFromCSV(DatosPostSimulacion data)
+        {
+            Parser parser = new();
+            string file = Constants.PathExtract + data.Fichero.Nombre;
+            bool result = true;
+
+            //Saving the file into hard drive
+            try
+            {
+                byte[] tempBytes = Convert.FromBase64String(data.Fichero.Base64);
+                System.IO.File.WriteAllBytes(file, tempBytes);
+
+            }
+            catch (Exception ex)
+            {
+                return Problem(ex.Message);
+            }
+
+            //parsing the information from the file we've just saved
+            PiezometerData[] piezometers = parser.parsePiezometerCSV(file);
+
+            try
+            {
+
+
+                foreach (PiezometerData p in piezometers)
+                {
+                    Piezometer piezometer = p.ToPiezometer();
+                    await this.PostPiezometer(piezometer);
+
+                    foreach (TimeSerieInterno tsi in p.Rates)
+                    {
+                        TsPiezometer tsp = new();
+                        tsp.PiezometerId = piezometer.Id;
+                        tsp.Date = tsi.DateIn;
+                        tsp.Day = tsi.Hora;
+                        tsp.Quote = tsi.Valor;
+
+                        await tsPiezometerController.PostTsPiezometer(tsp);
+                    }
+                }
+            }
+            catch(Exception ex)
+            {
+                Logger.WriteLog("Error while importing piezometers");
+                Logger.WriteLog(ex.Message);
+                Logger.WriteLog(ex.InnerException.Message);
+            }
+
+            return result;
+        }
+
+        // POST: api/Piezometer
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        [NonAction]
+        public async Task<ActionResult<Piezometer>> PostPiezometer(Piezometer piezometer)
+        {
+            _context.Piezometers.Add(piezometer);
+            try
+            {
+                Logger.WriteLog("Guardar cambios async");
+                await _context.SaveChangesAsync();
+
+            }
+            catch (DbUpdateException ex)
+            {
+                if (PiezometerExists(piezometer.Id))
+                {
+                    return Conflict();
+                }
+                else
+                {
+                    Logger.WriteLog("FALLO AL GUARDAR PIEZOMETRO");
+                    Logger.WriteLog(ex.Message);
+                    Logger.WriteLog(ex.InnerException.Message);
+                    throw;
+                }
+            }
+
+
+            return CreatedAtAction("GetPiezometria", new { id = piezometer.Id }, piezometer);
+        }
+
+        // DELETE: api/Pozo/5
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeletePiezometer(uint id)
+        {
+            var piezometer = await _context.Piezometers.FindAsync(id);
+            if (piezometer == null)
+            {
+                return NotFound();
+            }
+            
+            _context.Piezometers.Remove(piezometer);
+            await _context.SaveChangesAsync();
+
+            return NoContent();
+        }
+
+        private bool PiezometerExists(uint id)
+        {
+            return _context.Piezometers.Any(e => e.Id == id);
+        }
+
+        
+    }
+}

WorkerService1/WebApplication3/Controllers/PiezometriaController.cs

@@ -0,0 +1,151 @@
+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 PiezometriaController : ControllerBase
+    {
+        private readonly AquiferContext _context;
+        private TsPozoController _tsPozoController;
+        
+        
+        public PiezometriaController(AquiferContext context)
+        {
+            _context = context;
+            _tsPozoController = new TsPozoController(context);
+            
+        }
+
+        // GET: api/Pozo
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<Piezometria>>> GetPozos()
+        {
+            return await _context.Piezometria.ToListAsync();
+        }
+
+        // GET: api/Pozo/5
+        [HttpGet("{id}")]
+        public async Task<ActionResult<Piezometria>> GetPozo(uint id)
+        {            
+            var piezometria = await _context.Piezometria.FindAsync(id);
+            
+            if (piezometria == null)
+            {
+                return NotFound();
+            }
+            
+            return piezometria;
+        }
+
+        // PUT: api/Pozo/5
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        //[HttpPut("{id}")]
+        //public async Task<IActionResult> PutPozo(uint id, [FromBody] DatosPozoRecarga datos)
+        //{
+        //    Pozo pozo = _context.Pozos.Find(id);
+
+        //    if (id != pozo.Id)
+        //    {
+        //        return BadRequest();
+        //    }
+
+        //    pozo.IdAquifero = (datos.Acuifero != null && pozo.IdAquifero != datos.Acuifero) ? datos.Acuifero : pozo.IdAquifero;
+        //    pozo.IdSimulacion = (datos.Simulacion != null && pozo.IdSimulacion != datos.Simulacion) ? datos.Simulacion : pozo.IdSimulacion;
+        //    pozo.Latitud = (datos.Latitud != null && pozo.Latitud != datos.Latitud) ? datos.Latitud : pozo.Latitud;
+        //    pozo.Longitud = (datos.Longitud != null && pozo.Longitud != datos.Longitud) ? datos.Longitud : pozo.Longitud;
+        //    pozo.Maximo = (datos.Maximo != null && pozo.Maximo != datos.Maximo) ? datos.Maximo : pozo.Maximo;
+        //    pozo.Nombre = (datos.Nombre != null && pozo.Nombre != datos.Nombre) ? datos.Nombre : pozo.Nombre;
+
+        //    _context.Entry(pozo).State = EntityState.Modified;
+
+        //    try
+        //    {
+        //        await _context.SaveChangesAsync();
+        //    }
+        //    catch (DbUpdateConcurrencyException)
+        //    {
+        //        if (!PiezometriaExists(id))
+        //        {
+        //            return NotFound();
+        //        }
+        //        else
+        //        {
+        //            throw;
+        //        }
+        //    }
+
+        //    return CreatedAtAction("GetPozo", new { id = pozo.Id }, pozo);
+        //}
+
+        // POST: api/Pozo
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        [HttpPost]
+        public async Task<ActionResult<Piezometria>> PostPiezometria(Piezometria piezometria)
+        {
+            Logger.WriteLog("Se procede a guardar piezometria");
+            _context.Piezometria.Add(piezometria);
+            try
+            {
+                Logger.WriteLog("Guardar cambios async");
+                await _context.SaveChangesAsync();
+
+            }
+            catch (DbUpdateException ex)
+            {
+                if (PiezometriaExists(piezometria.Id))
+                {
+                    return Conflict();
+                }
+                else
+                {
+                    Logger.WriteLog("FALLO AL GUARDAR PIEZOMETRIA");
+                    Logger.WriteLog(ex.Message);
+                    Logger.WriteLog(ex.InnerException.Message);
+                    throw;
+                }
+            }
+
+
+            return CreatedAtAction("GetPiezometria", new { id = piezometria.Id }, piezometria);
+        }
+
+        // DELETE: api/Pozo/5
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeletePiezometria(uint id)
+        {
+            var piezometria = await _context.Piezometria.FindAsync(id);
+            if (piezometria == null)
+            {
+                return NotFound();
+            }
+            
+            _context.Piezometria.Remove(piezometria);
+            await _context.SaveChangesAsync();
+
+            return NoContent();
+        }
+
+        private bool PiezometriaExists(uint id)
+        {
+            return _context.Piezometria.Any(e => e.Id == id);
+        }
+
+        [NonAction]
+        public void getDimensions(uint idSimulacion, out int rows, out int cols)
+        {
+            Piezometria piezometria = _context.Piezometria.Where(x => x.IdSimulacion == idSimulacion).FirstOrDefault();
+            rows = piezometria.Rows;
+            cols = piezometria.Columns;
+        }
+
+    }
+}

WorkerService1/WebApplication3/Controllers/PozoController.cs

@@ -0,0 +1,364 @@
+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 PozoController : ControllerBase
+    {
+        private readonly AquiferContext _context;
+        private TsPozoController _tsPozoController;
+        
+        
+        public PozoController(AquiferContext context)
+        {
+            _context = context;
+            _tsPozoController = new TsPozoController(context);
+            
+        }
+
+        // GET: api/Pozo
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<Pozo>>> GetPozos()
+        {
+            return await _context.Pozos.ToListAsync();
+        }
+
+        // GET: api/Pozo/5
+        [HttpGet("{id}")]
+        public async Task<ActionResult<DatosPozoRecarga>> GetPozo(uint id)
+        {            
+            var pozo = await _context.Pozos.FindAsync(id);
+            
+            if (pozo == null)
+            {
+                return NotFound();
+            }
+
+            DatosPozoRecarga datosPozo = new DatosPozoRecarga();
+            datosPozo.Id = pozo.Id;
+            datosPozo.Nombre = pozo.Nombre;
+            datosPozo.Latitud = pozo.Latitud;
+            datosPozo.Longitud = pozo.Longitud;
+            datosPozo.Maximo = pozo.Maximo;
+            datosPozo.Minimo = pozo.Minimo;
+            datosPozo.Simulacion = pozo.IdSimulacion;
+            datosPozo.Ts = _tsPozoController.GetTsPozo(pozo.Id);
+            
+
+            return datosPozo;
+        }
+
+        // PUT: api/Pozo/5
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        [HttpPut("{id}")]
+        public async Task<IActionResult> PutPozo(uint id, [FromBody] DatosPozoRecarga datos)
+        {
+            Pozo pozo = _context.Pozos.Find(id);
+
+            if (id != pozo.Id)
+            {
+                return BadRequest();
+            }
+
+            pozo.IdAquifero = (datos.Acuifero != null && pozo.IdAquifero != datos.Acuifero) ? datos.Acuifero : pozo.IdAquifero;
+            pozo.IdSimulacion = (datos.Simulacion != null && pozo.IdSimulacion != datos.Simulacion) ? datos.Simulacion : pozo.IdSimulacion;
+            pozo.Latitud = (datos.Latitud != null && pozo.Latitud != datos.Latitud) ? datos.Latitud : pozo.Latitud;
+            pozo.Longitud = (datos.Longitud != null && pozo.Longitud != datos.Longitud) ? datos.Longitud : pozo.Longitud;
+            pozo.Maximo = (datos.Maximo != null && pozo.Maximo != datos.Maximo) ? datos.Maximo : pozo.Maximo;
+            pozo.Nombre = (datos.Nombre != null && pozo.Nombre != datos.Nombre) ? datos.Nombre : pozo.Nombre;
+
+            _context.Entry(pozo).State = EntityState.Modified;
+
+            try
+            {
+                await _context.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!PozoExists(id))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return CreatedAtAction("GetPozo", new { id = pozo.Id }, pozo);
+        }
+
+        // POST: api/Pozo
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        [HttpPost]
+        public async Task<ActionResult<Pozo>> PostPozo([FromBody] DatosPozoRecarga datos)
+        {
+            Pozo pozo = new Pozo();
+            
+
+            pozo.IdAquifero = datos.Acuifero;
+            pozo.IdSimulacion = datos.Simulacion;
+            pozo.Latitud = datos.Latitud;
+            pozo.Longitud = datos.Longitud;
+            pozo.Maximo = datos.Maximo;
+            pozo.Minimo = datos.Minimo;
+            pozo.Nombre = datos.Nombre;
+
+            _context.Pozos.Add(pozo);
+            try
+            {
+                await _context.SaveChangesAsync();
+
+                foreach (TimeSerie ts in datos.Ts)
+                {
+                    TsPozo tsPozo = new TsPozo();
+                    tsPozo.IdPozo = pozo.Id;
+                    tsPozo.MarcaTiempo = ts.Hora;
+                    tsPozo.Valor = ts.Valor;
+
+                    await _tsPozoController.PostTsPozo(tsPozo);
+                }
+
+            }
+            catch (DbUpdateException)
+            {
+                if (PozoExists(pozo.Id))
+                {
+                    return Conflict();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+
+            return CreatedAtAction("GetPozo", new { id = pozo.Id }, pozo);
+        }
+
+        // DELETE: api/Pozo/5
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeletePozo(uint id)
+        {
+            var pozo = await _context.Pozos.FindAsync(id);
+            if (pozo == null)
+            {
+                return NotFound();
+            }
+            await _tsPozoController.DeleteTsPozoFromPozo(id);
+            _context.Pozos.Remove(pozo);
+            await _context.SaveChangesAsync();
+
+            return NoContent();
+        }
+
+        private bool PozoExists(uint id)
+        {
+            return _context.Pozos.Any(e => e.Id == id);
+        }
+
+        //api/Pozo/parsea/1
+        [HttpPost("Parsea/{acuifero}")]
+        public async Task<ActionResult<IEnumerable<Pozo>>> ParseoFicheroPostman(uint acuifero)
+        {
+            
+            Parser wellParser = new Parser();
+            string file = @"C:\Users\Admin\Desktop\ASD\infoPozos.VMW";
+            WellData[] wells =  wellParser.ParseWellData(file);
+
+            foreach(WellData w in wells)
+            {
+                Pozo pozo = w.ToPozo(acuifero);
+                _context.Pozos.Add(pozo);
+
+                try
+                {
+                    await _context.SaveChangesAsync();
+
+                    foreach (TimeSerieInterno ts in w.Rates)
+                    {
+                        TsPozo tsPozo = new TsPozo();
+                        tsPozo.IdPozo = pozo.Id;
+                        tsPozo.MarcaTiempo = ts.Hora;
+                        tsPozo.Valor = ts.Valor;
+
+                        await _tsPozoController.PostTsPozo(tsPozo);
+                    }
+
+                }
+                catch (DbUpdateException)
+                {
+                    if (PozoExists(pozo.Id))
+                    {
+                        return Conflict();
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+            }
+
+            return await _context.Pozos.ToListAsync();
+        }
+
+        [NonAction]
+        public async Task<ActionResult<IEnumerable<Pozo>>> ParseoFichero(uint acuifero, string file)
+        {
+            var s = acuifero;
+            Parser wellParser = new Parser();
+            //string file = @"C:\Users\Admin\Desktop\ASD\infoPozos.VMW";
+            WellData[] wells = wellParser.ParseWellData(file);
+
+            foreach (WellData w in wells)
+            {
+                Pozo pozo = w.ToPozo(acuifero);
+                _context.Pozos.Add(pozo);
+
+                try
+                {
+                    await _context.SaveChangesAsync();
+
+                    foreach (TimeSerieInterno ts in w.Rates)
+                    {
+                        TsPozo tsPozo = new TsPozo();
+                        tsPozo.IdPozo = pozo.Id;
+                        tsPozo.MarcaTiempo = ts.Hora;
+                        tsPozo.Valor = ts.Valor;
+                        tsPozo.InfoComplementaria = ts.Info;
+
+                        await _tsPozoController.PostTsPozo(tsPozo);
+                    }
+
+                }
+                catch (DbUpdateException)
+                {
+                    if (PozoExists(pozo.Id))
+                    {
+                        return Conflict();
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+            }
+
+            return await _context.Pozos.ToListAsync();
+        }
+
+        [NonAction]
+        public async Task<ActionResult<IEnumerable<Pozo>>> PostMultipleWells(uint aquiferId,WellData[] wellDatas)
+        {
+            foreach (WellData w in wellDatas)
+            {
+                Pozo pozo = w.ToPozo(aquiferId);
+                _context.Pozos.Add(pozo);
+
+                try
+                {
+                    await _context.SaveChangesAsync();
+
+                    foreach (TimeSerieInterno ts in w.Rates)
+                    {
+                        TsPozo tsPozo = new TsPozo();
+                        tsPozo.IdPozo = pozo.Id;
+                        tsPozo.MarcaTiempo = ts.Hora;
+                        tsPozo.Valor = ts.Valor;
+                        tsPozo.InfoComplementaria = ts.Info;
+
+                        await _tsPozoController.PostTsPozo(tsPozo);
+                    }
+
+                }
+                catch (DbUpdateException)
+                {
+                    if (PozoExists(pozo.Id))
+                    {
+                        return Conflict();
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+            }
+
+            return await _context.Pozos.ToListAsync();
+        }
+
+        [NonAction]
+        public Pozo[] GetPozosAcuifero(uint acuiferoId)
+        {
+            return _context.Pozos.Where(x => x.IdAquifero == acuiferoId).ToArray<Pozo>();
+        }
+
+        [NonAction]
+        public Pozo[] GetPozosAcuiferoSimulacionInicial(uint acuiferoId)
+        {
+            return _context.Pozos.Where(x => x.IdAquifero == acuiferoId && x.IdSimulacion == null).ToArray<Pozo>();
+        }
+
+        [NonAction]
+        public async void SetPozosSimulacion(uint? acuiferoId, uint? simulacionId)
+        {
+            //Obtenemos los pozos del acuifero
+            Pozo[] pozos = _context.Pozos.Where(x => x.IdAquifero == acuiferoId).ToArray<Pozo>();
+
+            foreach(Pozo p in pozos)
+            {
+                Pozo pozo = p.Copy(simulacionId);
+
+                _context.Pozos.Add(pozo);
+            }
+            await _context.SaveChangesAsync();
+        }
+
+        [NonAction]
+        public List<Pozo> GetPozosSimulacion(uint? simulacionId)
+        {
+            List <Pozo> pozos = _context.Pozos.Where(x => x.IdSimulacion == simulacionId).ToList<Pozo>();
+
+            return pozos;
+        }
+
+        [NonAction]
+        public List<TsPozo> GetTsPozoFromPozo(uint? pozo)
+        {
+            List<TsPozo> tsPozos = _context.TsPozos.Where(x => x.IdPozo == pozo).ToList<TsPozo>();
+
+            return tsPozos;
+        }
+
+        [NonAction]
+        public async Task<bool> DeletePozoFromSim(uint? idSimulacion)
+        {
+            List<Pozo> pozos = _context.Pozos.Where(x => x.IdSimulacion == idSimulacion).ToList();
+            bool error = false;
+            try
+            {
+                foreach(Pozo p in pozos)
+                {
+                    await DeletePozo(p.Id);
+                }
+            } catch(Exception ex)
+            {
+                error = true;
+                Logger.WriteLog("Fail at deleting well from a simulation (simulationID: " + idSimulacion+")");
+                Logger.WriteLog(ex.Message);
+                Logger.WriteLog(ex.InnerException.Message);
+            }
+
+            return error;
+        }
+    }
+}

WorkerService1/WebApplication3/Controllers/RecargasController.cs

@@ -0,0 +1,256 @@
+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 RecargasController : ControllerBase
+    {
+        private readonly AquiferContext _context;
+        private TsRecargaController tsRecargaController;
+        //private AcuiferoController aquiferController;
+
+        public RecargasController(AquiferContext context)
+        {
+            _context = context;
+            tsRecargaController = new TsRecargaController(context);
+            //aquiferController = new AcuiferoController(context);
+        }
+
+        // GET: api/Recargas
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<Recarga>>> GetRecargas()
+        {
+            return await _context.Recargas.ToListAsync();
+        }
+
+        // GET: api/Recargas/5
+        [HttpGet("{id}")]
+        public async Task<ActionResult<DatosPozoRecarga>> GetRecarga(uint id)
+        {
+            var recarga = await _context.Recargas.FindAsync(id);
+
+            if (recarga == null)
+            {
+                return NotFound();
+            }
+
+            DatosPozoRecarga datosRecarga = new DatosPozoRecarga();
+            datosRecarga.Id = recarga.Id;
+            datosRecarga.Nombre = recarga.Nombre;
+            datosRecarga.Latitud = recarga.Latitud;
+            datosRecarga.Longitud = recarga.Longitud;
+            datosRecarga.Simulacion = recarga.IdSimulacion;
+            datosRecarga.Ts = tsRecargaController.GetTsRecarga(id);
+
+
+            return datosRecarga;
+
+        }
+
+        // PUT: api/Recargas/5
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        [HttpPut("{id}")]
+        public async Task<IActionResult> PutRecarga(uint id, [FromBody] DatosPozoRecarga datos)
+        {
+            Recarga recarga = _context.Recargas.Find(id);
+
+            if (id != recarga.Id)
+            {
+                return BadRequest();
+            }
+
+            
+            recarga.IdSimulacion = (datos.Simulacion != null && recarga.IdSimulacion != datos.Simulacion) ? datos.Simulacion : recarga.IdSimulacion;
+            recarga.Latitud = (datos.Latitud != null && recarga.Latitud != datos.Latitud) ? datos.Latitud : recarga.Latitud;
+            recarga.Longitud = (datos.Longitud != null && recarga.Longitud != datos.Longitud) ? datos.Longitud : recarga.Longitud;
+            recarga.Nombre = (datos.Nombre != null && recarga.Nombre != datos.Nombre) ? datos.Nombre : recarga.Nombre;
+            
+
+            //Para editar los datos de la TimeSerie haria falta un identificador más
+
+            _context.Entry(recarga).State = EntityState.Modified;
+
+            try
+            {
+                await _context.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!RecargaExists((uint)id))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return CreatedAtAction("GetRecarga", new { id = recarga.Id }, recarga);
+        }
+
+        // POST: api/Recargas
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        [HttpPost]
+        public async Task<ActionResult<Recarga>> PostRecarga([FromBody] DatosPozoRecarga datos)
+        {
+            Recarga recarga = new Recarga();
+            recarga.IdSimulacion = datos.Simulacion;
+            recarga.Nombre = datos.Nombre;
+            recarga.Latitud = datos.Latitud;
+            recarga.Longitud = datos.Longitud;
+            recarga.IdAcuifero = datos.Acuifero;
+
+            _context.Recargas.Add(recarga);
+            try
+            {
+                await _context.SaveChangesAsync();
+
+                foreach(TimeSerie ts in datos.Ts)
+                {
+                    TsRecarga tsRecarga = new TsRecarga();
+                    tsRecarga.IdRecarga = recarga.Id;
+                    tsRecarga.MarcaTiempo = ts.Hora;
+                    tsRecarga.Valor = ts.Valor;
+
+                    await tsRecargaController.PostTsRecarga(tsRecarga);
+                }
+            }
+            catch (DbUpdateException)
+            {
+                if (RecargaExists(recarga.Id))
+                { 
+                    return Conflict();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return CreatedAtAction("GetRecarga", new { id = recarga.Id }, recarga);
+        }
+
+        // DELETE: api/Recargas/5
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeleteRecarga(uint id)
+        {
+            var recarga = await _context.Recargas.FindAsync(id);
+            if (recarga == null)
+            {
+                return NotFound();
+            }
+
+            _context.Recargas.Remove(recarga);
+            await _context.SaveChangesAsync();
+
+            return NoContent();
+        }
+
+        private bool RecargaExists(uint id)
+        {
+            return _context.Recargas.Any(e => e.Id == id);
+        }
+
+        [NonAction]
+        public async void SetRecargasSimulacion(uint? acuiferoId, uint? simulacionId)
+        {
+            Recarga[] recargas = _context.Recargas.Where(x => x.IdAcuifero == acuiferoId).ToArray<Recarga>();
+
+            foreach (Recarga r in recargas)
+            {
+                Recarga recarga = r.Copy(simulacionId);
+                _context.Recargas.Add(recarga);
+
+            }
+            await _context.SaveChangesAsync();
+        }
+
+        [NonAction]
+        public List<Recarga> GetRecargasSimulacion(uint? simulacionId)
+        {
+            List<Recarga> recargas = _context.Recargas.Where(x => x.IdSimulacion == simulacionId).ToList<Recarga>();
+
+            return recargas;
+        }
+
+        [NonAction]
+        public Recarga[] GetRecargasAcuifero(uint acuiferoId)
+        {
+            return _context.Recargas.Where(x => x.IdAcuifero == acuiferoId).ToArray<Recarga>();
+        }
+
+        [NonAction]
+        public Recarga[] GetRecargasAcuiferoSimulacionInicial(uint acuiferoId)
+        {
+            return _context.Recargas.Where(x => x.IdAcuifero == acuiferoId && x.IdSimulacion == null).ToArray<Recarga>();
+        }
+
+        [NonAction]
+        public List<TsRecarga> GetTsRecargaFromRecaga(uint? recarga)
+        {
+            List<TsRecarga> tsRecarga = _context.TsRecargas.Where(x => x.IdRecarga == recarga).ToList<TsRecarga>();
+
+            return tsRecarga;
+        }
+
+        [NonAction]
+        public async Task<ActionResult<IEnumerable<Recarga>>> ParseoFichero(uint aquifer, string file)
+        {
+            Parser parser = new Parser();
+            //string file = @"C:\Users\Admin\Desktop\ASD\infoPozos.VMW";
+            RechargeData[] recharges = parser.ParseRechargeData(file, out string recharge_geometry);
+            //await aquiferController.SetRechargeGeometry(aquifer, recharge_geometry);
+            return await PostMultipleRecharges(aquifer,recharges);
+        }
+
+        [NonAction]
+        public async Task<ActionResult<IEnumerable<Recarga>>> PostMultipleRecharges(uint aquifer, RechargeData[] recharges)
+        {
+            foreach (RechargeData r in recharges)
+            {
+                Recarga recarga = r.ToRecarga(aquifer);
+                _context.Recargas.Add(recarga);
+
+                try
+                {
+                    await _context.SaveChangesAsync();
+
+                    foreach (TimeSerieInterno ts in r.Rates)
+                    {
+
+                        TsRecarga tsRecarga = new(); 
+                        tsRecarga.IdRecarga = recarga.Id;
+                        tsRecarga.MarcaTiempo = ts.Hora;
+                        tsRecarga.Valor = ts.Valor;
+
+                        await tsRecargaController.PostTsRecarga(tsRecarga);
+                    }
+
+                }
+                catch (DbUpdateException)
+                {
+                    if (RecargaExists(recarga.Id))
+                    {
+                        return Conflict();
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+            }
+
+            return await _context.Recargas.ToListAsync();
+        }
+    }
+}

WorkerService1/WebApplication3/Controllers/ServiceQueueController.cs

@@ -0,0 +1,173 @@
+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/queue")]
+    [ApiController]
+    public class ServiceQueueController : ControllerBase
+    {
+        private readonly AquiferContext _context;
+        //private TsPozoController tsPozoController;
+        
+        
+        public ServiceQueueController(AquiferContext context)
+        {
+            _context = context;
+            //tsPozoController = new TsPozoController(context);
+            
+        }
+
+        // GET: api/Pozo
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<ServiceQueue>>> GetQueue()
+        {
+            return await _context.ServiceQueue.ToListAsync();
+        }
+
+        // GET: api/Pozo/5
+        [HttpGet("{id}")]
+        public async Task<ActionResult<ServiceQueue>> GetQueueItem(uint id)
+        {            
+            var queueItem = await _context.ServiceQueue.FindAsync(id);
+            
+            if (queueItem == null)
+            {
+                return NotFound();
+            }
+            
+            return queueItem;
+        }
+
+        [HttpGet("Running")]
+        public async Task<bool> ServiceRunning()
+        {
+            var queueItem = await _context.ServiceQueue.AnyAsync(x => x.Corriendo != 0);
+                
+            return queueItem;
+        }
+        
+        [HttpGet("Inqueue")]
+        public async Task<bool> AnyInQueue()
+        {
+            return await _context.ServiceQueue.AnyAsync(x => x.Terminado == 0 && x.Corriendo == 0 && x.Error == 0);
+        }
+
+        [HttpGet("Next")]
+        public ServiceQueue GetNextInQueue()
+        {
+            return _context.ServiceQueue.Where(x => x.Terminado == 0 && x.Corriendo == 0 && x.Error == 0).OrderBy(x=> x.Id).FirstOrDefault();
+        }
+
+        [HttpPost("Corriendo/{id}")]
+        public async Task<int> SetCorriendo(uint id)
+        {
+            var serviceQueueItem = await _context.ServiceQueue.FindAsync(id);
+
+            serviceQueueItem.Corriendo = 1;
+            serviceQueueItem.Inicio = DateTime.Now.ToString();
+
+            _context.Entry(serviceQueueItem).State = EntityState.Modified;
+
+            int result = 0;
+            try
+            {
+                result = await _context.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+
+            }
+
+            return result;
+        }
+
+        [NonAction]
+        public async Task<ActionResult<ServiceQueue>> SetTerminado(uint id)
+        {
+            var serviceQueueItem = await _context.ServiceQueue.FindAsync(id);
+
+            serviceQueueItem.Corriendo = 0;
+            serviceQueueItem.Terminado = 1;
+            serviceQueueItem.Fin = DateTime.Now.ToString();
+
+            _context.Entry(serviceQueueItem).State = EntityState.Modified;
+
+            try
+            {
+                await _context.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!ServiceQueueExists(id))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return CreatedAtAction("GetQueueItem", new { id = serviceQueueItem.Id }, serviceQueueItem);
+        }
+
+
+        // POST: api/ServiceQueue
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        [HttpPost]
+        public async Task<ActionResult<ServiceQueue>> PostServiceQueue(ServiceQueue serviceQueue)
+        {
+
+            _context.ServiceQueue.Add(serviceQueue);
+            try
+            {
+                await _context.SaveChangesAsync();
+
+            }
+            catch (DbUpdateException)
+            {
+                if (ServiceQueueExists(serviceQueue.Id))
+                {
+                    return Conflict();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+
+            return CreatedAtAction("GetQueueItem", new { id = serviceQueue.Id }, serviceQueue);
+        }
+
+        // DELETE: api/Pozo/5
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeleteServiceQueue(uint id)
+        {
+            var serviceQueueItem = await _context.ServiceQueue.FindAsync(id);
+            if (serviceQueueItem == null)
+            {
+                return NotFound();
+            }
+            
+            _context.ServiceQueue.Remove(serviceQueueItem);
+            await _context.SaveChangesAsync();
+
+            return NoContent();
+        }
+
+        private bool ServiceQueueExists(uint id)
+        {
+            return _context.ServiceQueue.Any(e => e.Id == id);
+        }
+
+    }
+}

WorkerService1/WebApplication3/Controllers/ServicioController.cs

@@ -0,0 +1,312 @@
+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/servicio")]
+    [ApiController]
+    public class ServicioController : ControllerBase
+    {
+        private readonly AquiferContext _context;
+
+        public ServicioController(AquiferContext context)
+        {
+            _context = context;
+        }
+
+        // GET: api/Servicio
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<Servicio>>> GetServicios()
+        {
+            return await _context.Servicios.ToListAsync();
+        }
+
+        // GET: api/Servicio/5
+        [HttpGet("{id}")]
+        public async Task<ActionResult<Servicio>> GetServicio(uint id)
+        {
+            var servicio = await _context.Servicios.FindAsync(id);
+
+            if (servicio == null)
+            {
+                return NotFound();
+            }
+
+            return servicio;
+        }
+
+        // PUT: api/Servicio/5
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        [HttpPut("{id}")]
+        public async Task<IActionResult> PutServicio(uint id, Servicio servicio)
+        {
+            if (id != servicio.Id)
+            {
+                return BadRequest();
+            }
+
+            _context.Entry(servicio).State = EntityState.Modified;
+
+            try
+            {
+                await _context.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!ServicioExists(id))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return NoContent();
+        }
+
+        // POST: api/Servicio
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        [HttpPost]
+        public async Task<ActionResult<Servicio>> PostServicio(Servicio servicio)
+        {
+            servicio.Id = GetLastId()+1;
+            servicio.Terminado = 0;
+            _context.Servicios.Add(servicio);
+            try
+            {
+                await _context.SaveChangesAsync();
+
+            }
+            catch (DbUpdateException ex)
+            {
+                Logger.WriteLog(ex.InnerException.Message);
+            }
+
+            return CreatedAtAction("GetServicio", new { id = servicio.Id }, servicio);
+        }
+
+        // DELETE: api/Servicio/5
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeleteServicio(uint id)
+        {
+            var servicio = await _context.Servicios.FindAsync(id);
+            if (servicio == null)
+            {
+                return NotFound();
+            }
+
+            _context.Servicios.Remove(servicio);
+            await _context.SaveChangesAsync();
+
+            return NoContent();
+        }
+
+        private bool ServicioExists(uint id)
+        {
+            return _context.Servicios.Any(e => e.Id == id);
+        }
+
+        // GET: api/Servicio/simula
+        [HttpGet("simularest")]
+        public Task<ActionResult<Servicio>> SimulaRest()
+        {
+            string respuesta = "";
+
+            Proceso proceso = Proceso.GetInstance();
+            proceso.setParametersModflow(@"C:\Users\Admin\Desktop\TestExtract\simulaicionsimulacion_test", "AA.modflow.in");
+            try
+            {
+                if (!proceso.Started)
+                {
+                    proceso.Start();
+                    respuesta = "Id: " + proceso.GetPid();
+                    Servicio s = new Servicio();
+                    s.Id = GetLastId() + 1;
+                    s.Pid = (uint)proceso.GetPid();
+                    s.Terminado = 0;
+                    return PostServicio(s);
+                }
+            }
+            catch (Exception ex)
+            {
+                respuesta = ex.Message;
+                throw;
+            }
+
+
+            return null;
+
+        }
+
+        [NonAction]
+        public async Task<ActionResult<Servicio>> SimulaModflow(string workingDirectory, string arguments)
+        {
+            string respuesta = "";
+
+            Proceso proceso = Proceso.GetInstance();
+            Logger logger = Logger.GetInstance();
+            proceso.ResetProcess();
+            proceso.setParametersModflow(workingDirectory, arguments);
+
+            try
+            {
+                if (!proceso.Started)
+                {
+                    proceso.Start();
+                    respuesta = "Id: " + proceso.GetPid();
+                    Servicio s = new Servicio();
+                    s.Id = GetLastId() + 1;
+                    s.Pid = (uint)proceso.GetPid();
+                    s.Terminado = 0;
+                    s.Inicio = DateTime.Now.ToString();
+                    s.Tipo = "MODFLOW";
+                    Logger.WriteLog("MODFLOW " + s.Pid);
+                    var postServicio = await PostServicio(s);
+                    proceso.WaitForExit();
+                    return postServicio;
+                }
+            }
+            catch (Exception ex)
+            {
+                respuesta = ex.Message;
+                throw;
+            }
+
+
+            return null;
+
+        }
+
+        [NonAction]
+        public async Task<ActionResult<Servicio>> SimulaZoneBudget(string workingDirectory, string budgetFile, string zoneFile)
+        {
+            string respuesta = "";
+            Logger logger = Logger.GetInstance();
+            Logger.WriteLog("working directory: " + workingDirectory + " | budgetFile: " + budgetFile + " | zoneFile: " + zoneFile);
+            Proceso proceso = Proceso.GetInstance();
+            proceso.ResetProcess();
+            proceso.setParametersZoneBudget(workingDirectory);
+
+            try
+            {
+                if (!proceso.Started)
+                {
+                    proceso.Start();
+                    respuesta = "Id: " + proceso.GetPid();
+                    Servicio s = new Servicio();
+                    s.Id = GetLastId() + 1;
+                    s.Pid = (uint)proceso.GetPid();
+                    s.Terminado = 0;
+                    s.Inicio = DateTime.Now.ToString();
+                    s.Tipo = "ZONEBUDGET";
+                    Logger.WriteLog("ZONEBUDGET "+s.Pid);
+                    var postServicio = await PostServicio(s);
+
+                    string[] prompts = { "outputZoneBudget.zblst", budgetFile, "test", zoneFile, "A" };
+
+                    proceso.ExecuteZonebudget(prompts);
+
+                    return postServicio;
+                }
+            }
+            catch (Exception ex)
+            {
+                respuesta = ex.Message;
+                throw;
+            }
+
+            return null;
+        }
+
+        [NonAction]
+        public async Task<ActionResult<Servicio>> GetIsolinesWithPython(string workingDirectory,string headFile, int rows, int cols)
+        {
+            Logger logger = Logger.GetInstance();
+            Proceso proceso = Proceso.GetInstance();
+            int isolines = 30;
+            proceso.ResetProcess();
+            proceso.setParametersPython(workingDirectory,headFile,rows,cols,isolines);
+            proceso.Start();
+            Servicio s = new Servicio();
+            s.Id = GetLastId() + 1;
+            s.Pid = (uint)proceso.GetPid();
+            s.Terminado = 0;
+            s.Inicio = DateTime.Now.ToString();
+            s.Tipo = "PYTHON";
+            var postServicio = await PostServicio (s); ;
+            proceso.WaitForExit();
+            return postServicio;
+        }
+
+        // GET: api/Servicio/stopped
+        [HttpGet("stopped")]
+        public bool HasStopped()
+        {
+            Proceso proceso = Proceso.GetInstance();
+            return proceso.HasExited();
+        }
+
+        // GET: api/Servicio/detected
+        [HttpGet("detected")]
+        public bool HasDetected()
+        {
+            Proceso proceso = Proceso.GetInstance();
+            return proceso.Detected;
+        }
+
+        [HttpGet("lastid")]
+        public uint GetLastId()
+        {
+            if(_context.Servicios.Count() == 0)
+            {
+                return 0;
+            }
+
+            Servicio last = _context.Servicios.OrderByDescending(s => s.Id).First();
+
+            if (last != null)
+            {
+                return last.Id;
+            }
+            else
+            {
+                return 0;
+            }
+        }
+
+        [NonAction]
+        public async Task<int> setTerminado(int pid)
+        {
+
+            Servicio servicio = _context.Servicios.FromSqlRaw("SELECT * FROM servicio WHERE pid = {0} ORDER BY id DESC", pid).First();
+
+            servicio.Terminado = 1;
+            servicio.Fin = DateTime.Now.ToString();
+            _context.Entry(servicio).State = EntityState.Modified;
+            int result = 0;
+            try
+            {
+                result = await _context.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                
+            }
+
+            Logger.WriteLog("TERMINADO " + pid);
+
+            return result;
+
+        }
+    }
+}

WorkerService1/WebApplication3/Controllers/SimulacionController.cs

@@ -0,0 +1,533 @@
+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;
+using System.IO.Compression;
+using System.Threading;
+using Newtonsoft.Json;
+
+namespace WebApplication3.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class SimulacionController : ControllerBase
+    {
+        
+        private readonly AquiferContext _context;
+        private PozoController pozoController;
+        private RecargasController recargasController;
+        private AcuiferoController acuiferoController;
+        private ServicioController serviceController;
+        private BalanceHidricoController balanceHidricoController;
+        private PiezometriaController piezometriaController;
+        private ServiceQueueController serviceQueueController;
+
+        public SimulacionController(AquiferContext context)
+        {
+            _context = context;
+            pozoController = new PozoController(context);
+            recargasController = new RecargasController(context);
+            acuiferoController = new AcuiferoController(context);
+            serviceController = new ServicioController(context);
+            balanceHidricoController = new BalanceHidricoController(context);
+            piezometriaController= new PiezometriaController(context);
+            serviceQueueController = new ServiceQueueController(context);
+        }
+
+        // GET: api/Simulacion
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<Simulacion>>> GetSimulaciones()
+        {
+            return await _context.Simulaciones.ToListAsync();
+        }
+
+        // GET: api/Simulacion/5
+        [HttpGet("{id}")]
+        public async Task<ActionResult<Simulacion>> GetSimulacion(uint id)
+        {
+            var simulacion = await _context.Simulaciones.FindAsync(id);
+
+            if (simulacion == null)
+            {
+                return NotFound();
+            }
+
+            return simulacion;
+        }
+
+        // POST: api/Simulacion
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        [HttpPost]
+        public async Task<ActionResult<Simulacion>> PostSimulacion(Simulacion simulacion)
+        {
+            _context.Simulaciones.Add(simulacion);
+            await _context.SaveChangesAsync();
+
+            //prepacion de los valores por defecto para la simulación
+            pozoController.SetPozosSimulacion(simulacion.IdAcuifero,simulacion.Id);
+            recargasController.SetRecargasSimulacion(simulacion.IdAcuifero, simulacion.Id);
+
+            return CreatedAtAction("GetSimulacion", new { id = simulacion.Id }, simulacion);
+        }
+
+        [HttpPost("Simula/{simulacionId}")]
+        public async Task<bool> QueueSim(uint simulacionId)
+        {
+            Simulacion simulacion = _context.Simulaciones.Find(simulacionId);
+
+            ServiceQueue serviceQueue = new ServiceQueue();
+            serviceQueue.IdSimulacion = simulacionId;
+            serviceQueue.IdAcuifero = simulacion.IdAcuifero;
+
+            await serviceQueueController.PostServiceQueue(serviceQueue);
+            
+            return true;
+        }
+
+        [HttpPut("UpdateSimWellData")]
+        public async Task<ActionResult<bool>> UpdateSimWellsFromCsv(uint simulationId, [FromBody] DatosPostSimulacion data)
+        {
+            bool result = true;
+            Parser parser = new();
+            Simulacion sim = _context.Simulaciones.Find(simulationId);
+            string file = Constants.PathExtract + data.Fichero.Nombre;
+
+            //1. Se eliminan los pozos con sus respectivas time series de la bbdd ya que se va a sobreescribir la informacion
+            await pozoController.DeletePozoFromSim(simulationId);
+            //2. Guardamos el fichero que nos viene en el body en formato base64
+            try
+            {
+                byte[] tempBytes = Convert.FromBase64String(data.Fichero.Base64);
+                System.IO.File.WriteAllBytes( file, tempBytes);
+
+            }
+            catch (Exception ex)
+            {
+                return Problem(ex.Message);
+            }
+
+            WellData[] wellDatas = parser.parseWellCSV(file);
+
+            await pozoController.PostMultipleWells((uint)sim.IdAcuifero,wellDatas);
+
+            return result;
+        }
+
+        [HttpPut]
+        public async Task<ActionResult<bool>> UpdateSimRechargesFromCsv(uint simulationId, [FromBody] DatosPostSimulacion data)
+        {
+            bool result = true;
+            Parser parser = new();
+            Simulacion sim = _context.Simulaciones.Find(simulationId);
+            string file = Constants.PathExtract + data.Fichero.Nombre;
+
+            //1. Se eliminan los pozos con sus respectivas time series de la bbdd ya que se va a sobreescribir la informacion
+            await pozoController.DeletePozoFromSim(simulationId);
+            //2. Guardamos el fichero que nos viene en el body en formato base64
+            try
+            {
+                byte[] tempBytes = Convert.FromBase64String(data.Fichero.Base64);
+                System.IO.File.WriteAllBytes(file, tempBytes);
+
+            }
+            catch (Exception ex)
+            {
+                return Problem(ex.Message);
+            }
+
+            RechargeData[] rechargeDatas = parser.parseRechargeCSV(file);
+
+            
+            await recargasController.PostMultipleRecharges((uint)sim.IdAcuifero, rechargeDatas);
+
+            return result;
+        }
+
+        // PUT: api/Simulacion/5
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754s
+        [HttpPut("{id}")]
+        public async Task<IActionResult> PutSimulacion(uint id, [FromBody] DatosPostSimulacion datos)
+        {
+            Simulacion simulacion = _context.Simulaciones.Find(id);
+
+            if (id != simulacion.Id)
+            {
+                return BadRequest();
+            }
+
+
+            simulacion.Nombre = (datos.Nombre != null && datos.Nombre != simulacion.Nombre) ? datos.Nombre : simulacion.Nombre;
+
+            _context.Entry(simulacion).State = EntityState.Modified;
+
+            try
+            {
+                await _context.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!SimulacionExists(id))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return CreatedAtAction("GetSimulacion", new { id = simulacion.Id }, simulacion);
+        }
+
+        // DELETE: api/Simulacion/5
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeleteSimulacion(uint id)
+        {
+            var simulacion = await _context.Simulaciones.FindAsync(id);
+            if (simulacion == null)
+            {
+                return NotFound();
+            }
+
+            _context.Simulaciones.Remove(simulacion);
+            await _context.SaveChangesAsync();
+
+            return NoContent();
+        }
+
+        [NonAction]
+        public async Task<bool> SimulaAsync(ServiceQueue serviceQueue)
+        {
+            Logger logger = Logger.GetInstance();
+            await serviceQueueController.SetCorriendo(serviceQueue.Id);
+
+            uint simulacionId = (uint)serviceQueue.IdSimulacion;
+            Simulacion simulacion = _context.Simulaciones.Find(simulacionId);
+
+            //Obtenemos el nombre de fichero original del acuifero
+            string zip = acuiferoController.GetFicheroZip((uint)simulacion.IdAcuifero);
+            Logger.WriteLog("estoy simulando");
+            if (zip != string.Empty)
+            {
+                Parser parser = new Parser();
+                string zip_name = "simulaicion" + simulacion.Nombre;
+                string zip_copy = zip_name + ".zip";
+                System.IO.File.Copy(Constants.PathZip + zip, Constants.PathZip + zip_copy, true);
+
+                string workingDirectory = Constants.PathExtract + zip_name + "\\";
+                //Descomprimimos copia para escribir en fichero
+                Directory.CreateDirectory(workingDirectory);
+                ZipFile.ExtractToDirectory(Constants.PathZip + zip_copy, workingDirectory, true);
+
+                //Obtenemos fichero de pozo y recargas
+                List<string> files = Directory.GetFiles(workingDirectory).ToList<string>();
+
+                string pozoFile = files.Find(x => x.Contains(".VMW"));
+                string recargaFile = files.Find(x => x.Contains(".VMP"));
+                string inFile = files.Find(x => x.Contains(".MODFLOW.IN") || x.Contains(".modflow.in"));
+                string zoneFile = files.Find(x => x.Contains(".ZBI") || x.Contains(".zbi"));
+
+                //3- Parseamos pozos
+                if (System.IO.File.Exists(pozoFile))
+                {
+                    List<WellData> infoPozosFichero = parser.ParseWellData(pozoFile).ToList<WellData>();
+                    List<Pozo> pozos = pozoController.GetPozosSimulacion(simulacionId);
+                    List<string> lines = new List<string>();
+
+                    //Por ahora asumimos que el fichero tiene la misma cantidad de pozos que en bbdd para esta simulacion
+                    string[] maxDefault = infoPozosFichero[0].ZMax.Split(" ");
+
+
+                    lines.Add(pozos.Count.ToString());
+                    foreach (Pozo p in pozos)
+                    {
+                        List<TsPozo> timeSeriesPozo = pozoController.GetTsPozoFromPozo(p.Id);
+                        lines.Add("0"); //Activo o inactivo
+                        lines.Add(p.Nombre);
+                        lines.Add(p.Latitud.ToString());
+                        lines.Add(p.Longitud.ToString());
+                        lines.Add(p.Minimo.ToString());
+                        maxDefault[0] = p.Maximo.ToString();
+                        string aux = String.Join(' ', maxDefault);
+                        lines.Add(aux); //Maximo
+                        lines.Add(infoPozosFichero[0].ScreenIntervals.ToString()); //screen intervals
+                        lines.Add(infoPozosFichero[0].Top);
+                        lines.Add(infoPozosFichero[0].Bot);
+                        lines.Add(timeSeriesPozo.Count.ToString());
+
+                        for (int i = 0; i < timeSeriesPozo.Count - 1; i++)
+                        {
+                            lines.Add(timeSeriesPozo[i].MarcaTiempo);
+                            lines.Add(timeSeriesPozo[i + 1].MarcaTiempo);
+                            lines.Add(timeSeriesPozo[i].Valor.ToString() + " " + timeSeriesPozo[i].InfoComplementaria);
+                        }
+                    }
+
+                    //System.IO.File.WriteAllLines(@"C:\Users\Admin\Desktop\Test.VMW", lines);
+                    System.IO.File.WriteAllLines(pozoFile, lines);
+
+                }
+
+
+                //4- Parseamos recargas
+                if (System.IO.File.Exists(recargaFile))
+                {
+                    List<Recarga> recargas = recargasController.GetRecargasSimulacion(simulacionId);
+
+                    string text = System.IO.File.ReadAllText(recargaFile);
+                    string[] data = text.Split("\r\n\r\n");
+
+                    int layers = int.Parse(data[0][0].ToString());
+                    int blankLinePerBlock = layers + 1;
+                    int rechargeBlockInex = blankLinePerBlock * 2;
+
+
+                    List<string> lines = new List<string>();
+
+                    //Hasta el bloque de recargas vamos poniendo el texto que le precede
+                    for (int i = 0; i < rechargeBlockInex; i++)
+                    {
+                        lines.AddRange(data[i].Split("\r\n").ToList());
+                        lines.Add("");
+                    }
+
+                    //Bloque recargas
+                    lines.Add(recargas.Count.ToString());
+
+                    int index = 1;
+                    foreach (Recarga r in recargas)
+                    {
+                        List<TsRecarga> tsRecarga = recargasController.GetTsRecargaFromRecaga(r.Id);
+                        lines.Add(index + " 1 Index 1");
+                        lines.Add("1 rchr entries");
+                        lines.Add(index + " " + tsRecarga[0].Valor + "               " + tsRecarga[0].MarcaTiempo + "               " + tsRecarga[1].MarcaTiempo + " " + tsRecarga[0].InfoComplementaria);
+
+                    }
+                    lines.Add("");
+
+                    //Hasta el final
+                    for (int i = rechargeBlockInex + 1; i < data.Length; i++)
+                    {
+                        lines.AddRange(data[i].Split("\r\n").ToList());
+                        //controlamos que en la ultima iteracion no introduzca un \r\n
+                        if (i < data.Length - 1)
+                        {
+                            lines.Add("");
+                        }
+                    }
+
+                    //System.IO.File.WriteAllLines(@"C:\Users\Admin\Desktop\TestRec.VMP", lines);
+                    System.IO.File.WriteAllLines(recargaFile, lines);
+
+
+                }
+
+                //5.Ejecutamos el modelo
+                //Primeramente, para ejecutar el modelo, hay que modificar el contenido del fichero con extension .in para que no de error al ejecutarse el modelo
+                if (System.IO.File.Exists(inFile))
+                {
+                    List<string> inFileLines = parser.ParseInFile(inFile);
+                    System.IO.File.WriteAllLines(inFile, inFileLines);
+                }
+                string inFileName = inFile.Split("\\").ToList().Last();
+
+                Logger.WriteLog("ejecuto modflow");
+                await serviceController.SimulaModflow(workingDirectory, inFileName);
+                Thread.Sleep(5000);
+                Logger.WriteLog("fin modflow");
+
+                //6.Ejecucion Zonebudget
+                //Seguidamente miramos el fichero de resultado de zonas (si existe)
+                if (zoneFile != null && System.IO.File.Exists(zoneFile))
+                {
+                    files = Directory.GetFiles(workingDirectory).ToList<string>();
+                    string budgetFile = files.Find(x => x.Contains(".BGT"));
+                    Logger.WriteLog("budgetFile" + budgetFile);
+
+                    await serviceController.SimulaZoneBudget(workingDirectory, budgetFile, zoneFile);
+                    Thread.Sleep(5000);
+                    Logger.WriteLog("fin zonebudget");
+
+                }
+
+
+                //7. Parseo de salidas
+                files = Directory.GetFiles(workingDirectory).ToList<string>();
+
+                string zoneResultsFile = files.Find(x => x.Contains(".zblst"));
+                string modelResultsFile = files.Find(x => x.Contains(".LST"));
+                string piezometryFile = files.Find(x => x.Contains(".HDS"));
+
+                //Parseo del fichero de balance hidrico por zonas
+
+                if (System.IO.File.Exists(zoneResultsFile))
+                {
+                    Logger.WriteLog("inicio balance zonas");
+                    ZoneBalance[] zoneBalance = parser.ParseZonesBalance(zoneResultsFile);
+
+                    //Se inserta el balance hidrico en bbdd
+                    foreach (ZoneBalance zone in zoneBalance)
+                    {
+                        //Obtenemos la respuestas de la creacion con el objeto
+                        var resultBalance = await balanceHidricoController.PostBalance(zone.ToBalanceHidrico(simulacionId));
+
+                        uint balanceId = resultBalance.Value;
+
+                        var dataIn = await balanceHidricoController.PostBalanceIn(zone.In.ToDatosBalanceIn(balanceId));
+
+                        uint balanceDataInId = dataIn.Value;
+
+                        List<ConexionZonasIn> conexionZonasIns = new List<ConexionZonasIn>();
+
+                        zone.In.ZoneConnections.ForEach(x => conexionZonasIns.Add(x.ToConexionIn(balanceDataInId)));
+
+                        await balanceHidricoController.PostMultipleConnectionIn(conexionZonasIns.ToArray());
+
+                        var dataOut = await balanceHidricoController.PostBalanceOut(zone.Out.ToDatosBalanceOut(balanceId));
+                        uint balanceDataOutId = dataOut.Value;
+
+                        List<ConexionZonasOut> conexionZonasOuts = new List<ConexionZonasOut>();
+
+                        zone.Out.ZoneConnections.ForEach(x => conexionZonasOuts.Add(x.ToConexionOut(balanceDataOutId)));
+
+                        await balanceHidricoController.PostMultipleConnectionOut(conexionZonasOuts.ToArray());
+                    }
+                    Logger.WriteLog("fin balance hidrico zonas");
+                }
+
+                //Parseo del fichero de resultados sobre el modelo entero
+                if (System.IO.File.Exists(modelResultsFile))
+                {
+                    Logger.WriteLog("inicio balance modelo entero");
+                    ZoneBalance[] modelBalance = parser.ParseWholeModelBalance(modelResultsFile);
+
+                    //insertamos en bbdd
+                    foreach (ZoneBalance zone in modelBalance)
+                    {
+                        var result = await balanceHidricoController.PostBalance(zone.ToBalanceHidrico(simulacionId));
+                        uint balanceId = result.Value;
+
+                        await balanceHidricoController.PostBalanceIn(zone.In.ToDatosBalanceIn(balanceId));
+                        await balanceHidricoController.PostBalanceOut(zone.Out.ToDatosBalanceOut(balanceId));
+                    }
+                    Logger.WriteLog("fin balance modelo entero");
+                }
+
+                //Parseo del fichero HDS para obtener el mapa de piezometria
+                if (System.IO.File.Exists(piezometryFile))
+                {
+                    Logger.WriteLog("inicio piezometria");
+                    List<Piezometria> piezometrias = parser.ParseBinaryFile(piezometryFile, simulacionId);
+
+                    foreach (Piezometria p in piezometrias)
+                    {
+                        await piezometriaController.PostPiezometria(p);
+                    }
+                    Logger.WriteLog("fin piezometria");
+                }
+                piezometriaController.getDimensions(simulacionId, out int rows, out int cols);
+
+                await serviceController.GetIsolinesWithPython(workingDirectory, piezometryFile, rows, cols);
+                Thread.Sleep(5000);
+
+                Byte[] bytes = System.IO.File.ReadAllBytes(workingDirectory + "test.png");
+                String base64Image = Convert.ToBase64String(bytes);
+
+
+                await SetIsolinesImage(simulacionId, base64Image);
+
+
+                await serviceQueueController.SetTerminado(serviceQueue.Id);
+                Logger.WriteLog("terminado");
+            }
+            return true;
+        }
+
+
+        [HttpGet("Geojson")]
+        public GeoJson GetGeoJson()
+        {
+            string allText = System.IO.File.ReadAllText(@"C:\Users\Admin\Desktop\AAAA\test_aa.geojson");
+            allText = allText.Replace("[[[","[[");
+            allText = allText.Replace("]]]", "]]");
+            GeoJson jsonObject = JsonConvert.DeserializeObject<GeoJson>(allText);
+            return jsonObject;
+        }
+        private bool SimulacionExists(uint id)
+        {
+            return _context.Simulaciones.Any(e => e.Id == id);
+        }
+
+        private async Task<IActionResult> SetIsolinesImage(uint simulacionId, string imageBase64)
+        {
+            var simulacion = _context.Simulaciones.Find(simulacionId);
+
+            if (simulacionId != simulacion.Id)
+            {
+                return BadRequest();
+            }
+
+
+            simulacion.IsolineImage = imageBase64;
+
+            _context.Entry(simulacion).State = EntityState.Modified;
+
+            try
+            {
+                await _context.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!SimulacionExists(simulacionId))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return CreatedAtAction("GetSimulacion", new { id = simulacion.Id }, simulacion);
+        }
+
+        /*
+         * TEST ENDPOINTS
+         */
+        [HttpPost("Simula/Python/{simulacionId}")]
+        public async Task<bool> SimIsolinesWithPython(uint simulacionId)
+        {
+            string workingDirectory = @"C:\Users\Admin\Desktop\TestExtract\simulaicionsimulacion_test\";
+            string headFile = @"C:\Users\Admin\Desktop\TestExtract\simulaicionsimulacion_test\EJEMPLO_SOTIEL.HDS";
+
+            int rows, cols;
+            piezometriaController.getDimensions(simulacionId, out rows, out cols);
+            await serviceController.GetIsolinesWithPython(workingDirectory, headFile, rows, cols);
+            Thread.Sleep(3000);
+            return true;
+        }
+
+        [HttpGet("Piezometria")]
+        public async Task<ActionResult<IEnumerable<Simulacion>>> SimPiezometria()
+        {
+            Logger.WriteLog("inicio piezometria");
+            Parser parser = new Parser();
+            string piezometryFile = @"C:\Users\Admin\Desktop\TestExtract\simulaicionsimulacion_test\EJEMPLO_SOTIEL.HDS";
+            List<Piezometria> piezometrias = parser.ParseBinaryFile(piezometryFile, 4);
+            Logger.WriteLog("Fin parseo fichero binario");
+            Logger.WriteLog("Hay " + piezometrias.Count + " elementos de piezometria");
+            foreach (Piezometria p in piezometrias)
+            {
+                await piezometriaController.PostPiezometria(p);
+            }
+            Logger.WriteLog("fin piezometria");
+            return await GetSimulaciones();
+        }
+    }
+}

WorkerService1/WebApplication3/Controllers/TsPiezometerController.cs

@@ -0,0 +1,136 @@
+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 TsPiezometerController: ControllerBase
+    {
+        private readonly AquiferContext _context;
+
+        public TsPiezometerController(AquiferContext context)
+        {
+            _context = context;
+        }
+
+        // GET: api/TsPiezometer
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<TsPiezometer>>> GetTsPiezometers()
+        {
+            return await _context.TsPiezometers.ToListAsync();
+        }
+
+        // GET: api/TsPiezometer/5
+        [HttpGet("{id}")]
+        //public async Task<ActionResult<TsPozo>> GetTsPozo(uint id)
+        public TimeSerie[] GetTsPiezometer(uint id)
+        {
+
+            //var tsPozo = await _context.TsPozos.FindAsync(id);
+            var tsPiezometers = _context.TsPiezometers.Where(x => x.PiezometerId == id);
+
+            List<TimeSerie> timeSeries = new List<TimeSerie>();
+            TimeSerie timeSerie = null;
+
+            if (tsPiezometers == null)
+            {
+                return null;
+            }
+
+            foreach(TsPiezometer tsp in tsPiezometers)
+            {
+                timeSerie = new TimeSerie();
+                timeSerie.Hora = tsp.Day;
+                timeSerie.Valor = tsp.Quote;
+                timeSeries.Add(timeSerie);
+            }
+
+            return timeSeries.ToArray();
+        }
+
+        // PUT: api/TsPiezometer/5
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        [HttpPut("{id}")]
+        public async Task<IActionResult> PutTsPiezometer(uint id, TsPozo tsPozo)
+        {
+            if (id != tsPozo.Id)
+            {
+                return BadRequest();
+            }
+
+            _context.Entry(tsPozo).State = EntityState.Modified;
+
+            try
+            {
+                await _context.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!TsPiezometerExists(id))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return NoContent();
+        }
+
+        // POST: api/TsPiezometer
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        [HttpPost]
+        public async Task<ActionResult<TsPozo>> PostTsPiezometer(TsPiezometer tsPiezometer)
+        {
+            _context.TsPiezometers.Add(tsPiezometer);
+            try
+            {
+                await _context.SaveChangesAsync();
+            }
+            catch (DbUpdateException)
+            {
+                if (TsPiezometerExists(tsPiezometer.Id))
+                {
+                    return Conflict();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return CreatedAtAction("GetTsPozo", new { id = tsPiezometer.Id }, tsPiezometer);
+        }
+
+        // DELETE: api/TsPozo/5
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeleteTsPozo(int id)
+        {
+            var tsPozo = await _context.TsPozos.FindAsync(id);
+            if (tsPozo == null)
+            {
+                return NotFound();
+            }
+
+            _context.TsPozos.Remove(tsPozo);
+            await _context.SaveChangesAsync();
+
+            return NoContent();
+        }
+
+        private bool TsPiezometerExists(uint id)
+        {
+            return _context.TsPozos.Any(e => e.Id == id);
+        }
+    }
+}

WorkerService1/WebApplication3/Controllers/TsPozoController.cs

@@ -0,0 +1,155 @@
+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 TsPozoController : ControllerBase
+    {
+        private readonly AquiferContext _context;
+
+        public TsPozoController(AquiferContext context)
+        {
+            _context = context;
+        }
+
+        // GET: api/TsPozo
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<TsPozo>>> GetTsPozos()
+        {
+            return await _context.TsPozos.ToListAsync();
+        }
+
+        // GET: api/TsPozo/5
+        [HttpGet("{id}")]
+        //public async Task<ActionResult<TsPozo>> GetTsPozo(uint id)
+        public TimeSerie[] GetTsPozo(uint id)
+        {
+
+            //var tsPozo = await _context.TsPozos.FindAsync(id);
+            var tsPozos = _context.TsPozos.Where(x => x.IdPozo == id);
+
+            List<TimeSerie> timeSeries = new List<TimeSerie>();
+            TimeSerie _timeSerie = null;
+
+            if (tsPozos == null)
+            {
+                return null;
+            }
+
+            foreach(TsPozo tsp in tsPozos)
+            {
+                _timeSerie = new TimeSerie();
+                _timeSerie.Hora = tsp.MarcaTiempo;
+                _timeSerie.Valor = tsp.Valor;
+                timeSeries.Add(_timeSerie);
+            }
+
+            return timeSeries.ToArray();
+        }
+
+        // PUT: api/TsPozo/5
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        [HttpPut("{id}")]
+        public async Task<IActionResult> PutTsPozo(uint id, TsPozo tsPozo)
+        {
+            if (id != tsPozo.Id)
+            {
+                return BadRequest();
+            }
+
+            _context.Entry(tsPozo).State = EntityState.Modified;
+
+            try
+            {
+                await _context.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!TsPozoExists(id))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return NoContent();
+        }
+
+        // POST: api/TsPozo
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        [HttpPost]
+        public async Task<ActionResult<TsPozo>> PostTsPozo(TsPozo tsPozo)
+        {
+            _context.TsPozos.Add(tsPozo);
+            try
+            {
+                await _context.SaveChangesAsync();
+            }
+            catch (DbUpdateException)
+            {
+                if (TsPozoExists(tsPozo.Id))
+                {
+                    return Conflict();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return CreatedAtAction("GetTsPozo", new { id = tsPozo.Id }, tsPozo);
+        }
+
+        // DELETE: api/TsPozo/5
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeleteTsPozo(int id)
+        {
+            var tsPozo = await _context.TsPozos.FindAsync(id);
+            if (tsPozo == null)
+            {
+                return NotFound();
+            }
+
+            _context.TsPozos.Remove(tsPozo);
+            await _context.SaveChangesAsync();
+
+            return NoContent();
+        }
+
+        private bool TsPozoExists(uint id)
+        {
+            return _context.TsPozos.Any(e => e.Id == id);
+        }
+
+        [NonAction]
+        public async Task<IActionResult> DeleteTsPozoFromPozo(uint id)
+        {
+            List<TsPozo> tsPozos = _context.TsPozos.Where(x => x.IdPozo == id).ToList<TsPozo>();
+
+            if (tsPozos == null)
+            {
+                return NotFound();
+            }
+
+            tsPozos.ForEach( x =>
+                _context.TsPozos.Remove(x)
+            );
+            
+            await _context.SaveChangesAsync();
+
+            return NoContent();
+        }
+    }
+}

WorkerService1/WebApplication3/Controllers/TsRecargaController.cs

@@ -0,0 +1,120 @@
+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.Clases;
+using WebApplication3.Models;
+
+namespace WebApplication3.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class TsRecargaController : ControllerBase
+    {
+        private readonly AquiferContext _context;
+
+        public TsRecargaController(AquiferContext context)
+        {
+            _context = context;
+        }
+
+        // GET: api/TsRecarga
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<TsRecarga>>> GetTsRecargas()
+        {
+            return await _context.TsRecargas.ToListAsync();
+        }
+
+        // GET: api/TsRecarga/5
+        [HttpGet("{id}")]
+        public TimeSerie[] GetTsRecarga(uint id)
+        {
+            //var tsPozo = await _context.TsPozos.FindAsync(id);
+            var tsRecargas = _context.TsRecargas.Where(x => x.IdRecarga == id);
+
+            List<TimeSerie> timeSeries = new List<TimeSerie>();
+            TimeSerie _timeSerie = null;
+
+            if (tsRecargas == null)
+            {
+                return null;
+            }
+
+            foreach (TsRecarga tsr in tsRecargas)
+            {
+                _timeSerie = new TimeSerie();
+                _timeSerie.Hora = tsr.MarcaTiempo;
+                _timeSerie.Valor = tsr.Valor;
+                timeSeries.Add(_timeSerie);
+            }
+
+            return timeSeries.ToArray();
+        }
+
+        // PUT: api/TsRecarga/5
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        [HttpPut("{id}")]
+        public async Task<IActionResult> PutTsRecarga(int id, TsRecarga tsRecarga)
+        {
+            if (id != tsRecarga.Id)
+            {
+                return BadRequest();
+            }
+
+            _context.Entry(tsRecarga).State = EntityState.Modified;
+
+            try
+            {
+                await _context.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!TsRecargaExists(id))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return NoContent();
+        }
+
+        // POST: api/TsRecarga
+        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
+        [HttpPost]
+        public async Task<ActionResult<TsRecarga>> PostTsRecarga(TsRecarga tsRecarga)
+        {
+            _context.TsRecargas.Add(tsRecarga);
+            await _context.SaveChangesAsync();
+
+            return CreatedAtAction("GetTsRecarga", new { id = tsRecarga.Id }, tsRecarga);
+        }
+
+        // DELETE: api/TsRecarga/5
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeleteTsRecarga(int id)
+        {
+            var tsRecarga = await _context.TsRecargas.FindAsync(id);
+            if (tsRecarga == null)
+            {
+                return NotFound();
+            }
+
+            _context.TsRecargas.Remove(tsRecarga);
+            await _context.SaveChangesAsync();
+
+            return NoContent();
+        }
+
+        private bool TsRecargaExists(int id)
+        {
+            return _context.TsRecargas.Any(e => e.Id == id);
+        }
+    }
+}

WorkerService1/WebApplication3/Models/Acuifero.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class Acuifero
+    {
+        public uint Id { get; set; }
+        public string Nombre { get; set; }
+        public string Fichero { get; set; }
+        public string WorldOriginX { get; set; }
+        public string WorldOriginY { get; set; }
+        public string RechargeGeometry { get; set; }
+    }
+}

WorkerService1/WebApplication3/Models/AquiferContext.cs

@@ -0,0 +1,545 @@
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.Extensions.Configuration;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class AquiferContext : DbContext
+    {
+        public AquiferContext()
+        {
+        }
+
+        public AquiferContext(DbContextOptions<AquiferContext> options)
+            : base(options)
+        {
+        }
+
+        public virtual DbSet<Acuifero> Acuiferos { get; set; }
+        public virtual DbSet<Pozo> Pozos { get; set; }
+        public virtual DbSet<Recarga> Recargas { get; set; }
+        public virtual DbSet<Servicio> Servicios { get; set; }
+        public virtual DbSet<Simulacion> Simulaciones { get; set; }
+        public virtual DbSet<TsPozo> TsPozos { get; set; }
+        public virtual DbSet<TsRecarga> TsRecargas { get; set; }
+        public virtual DbSet<BalanceHidrico> BalancesHidricos { get; set; }
+        public virtual DbSet<DatosBalanceIn> DatosBalanceIns { get; set; }
+        public virtual DbSet<DatosBalanceOut> DatosBalanceOuts { get; set; }
+        public virtual DbSet<ConexionZonasIn> ConexionZonasIns { get; set; }
+        public virtual DbSet<ConexionZonasOut> ConexionZonasOuts { get; set; }
+        public virtual DbSet<Piezometria> Piezometria { get; set; }
+        public virtual DbSet<Piezometer> Piezometers { get; set; }
+        public virtual DbSet<TsPiezometer> TsPiezometers { get; set; }
+        public virtual DbSet<ServiceQueue> ServiceQueue { get; set; }
+
+
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+        {
+            if (!optionsBuilder.IsConfigured)
+            {
+                IConfigurationRoot configuration = new ConfigurationBuilder()
+                                    .SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
+                                    .AddJsonFile("appsettings.json")
+                                    .Build();
+
+                optionsBuilder.UseMySql(configuration.GetConnectionString("AquiferDatabase"), Microsoft.EntityFrameworkCore.ServerVersion.Parse("5.7.24-mysql"));
+            }
+        }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.HasCharSet("latin1")
+                .UseCollation("latin1_spanish_ci");
+
+            modelBuilder.Entity<Acuifero>(entity =>
+            {
+                entity.ToTable("acuifero");
+
+                entity.Property(e => e.Id)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id");
+
+                entity.Property(e => e.Fichero)
+                    .HasMaxLength(255)
+                    .HasColumnName("fichero");
+
+                entity.Property(e => e.Nombre)
+                    .IsRequired()
+                    .HasMaxLength(50)
+                    .HasColumnName("nombre")
+                    .HasDefaultValueSql("''");
+
+                entity.Property(e => e.WorldOriginX).HasColumnName("world_origin_x");
+                entity.Property(e => e.WorldOriginY).HasColumnName("world_origin_y");
+                entity.Property(e => e.RechargeGeometry).HasColumnName("recharge_geometry");
+
+
+
+                entity.HasKey(e => e.Id)
+                .HasName("id");
+            });
+
+            modelBuilder.Entity<Pozo>(entity =>
+            {
+                entity.ToTable("pozo");
+
+                entity.Property(e => e.Id)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id");
+
+                entity.Property(e => e.IdAquifero)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id_aquifero");
+
+                entity.Property(e => e.IdSimulacion)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id_simulacion");
+
+                entity.Property(e => e.Latitud).HasColumnName("latitud");
+
+                entity.Property(e => e.Longitud).HasColumnName("longitud");
+
+                entity.Property(e => e.Maximo).HasColumnName("maximo");
+
+                entity.Property(e => e.Minimo).HasColumnName("minimo");
+
+                entity.Property(e => e.Nombre)
+                    .HasMaxLength(50)
+                    .HasColumnName("nombre");
+
+                entity.Property(e => e.X)
+                    .HasMaxLength(50)
+                    .HasColumnName("x");   
+
+                entity.Property(e => e.Y)
+                    .HasMaxLength(50)
+                    .HasColumnName("y");
+
+                entity.Property(e => e.Z)
+                    .HasMaxLength(50)
+                    .HasColumnName("z");
+
+                entity.Property(e => e.Prof)
+                    .HasMaxLength(50)
+                    .HasColumnName("prof");
+
+                entity.Property(e => e.ScreenTop)
+                    .HasMaxLength(50)
+                    .HasColumnName("screen_top");
+
+                entity.Property(e => e.ScreenBot)
+                    .HasMaxLength(50)
+                    .HasColumnName("screen_bot");
+
+                entity.HasKey(e => e.Id)
+                .HasName("id");
+            });
+
+            modelBuilder.Entity<Recarga>(entity =>
+            {
+                entity.ToTable("recarga");
+
+                entity.Property(e => e.Id)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id");
+
+                entity.Property(e => e.IdSimulacion)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id_simulacion");
+
+                entity.Property(e => e.IdAcuifero)
+                .HasColumnType("int(10) unsigned")
+                .HasColumnName("id_acuifero");
+
+                entity.Property(e => e.Nombre)
+                    .HasMaxLength(50)
+                    .HasColumnName("nombre");
+
+                entity.Property(e => e.Latitud).HasColumnName("latitud");
+
+                entity.Property(e => e.Longitud).HasColumnName("longitud");
+
+                entity.HasKey(e => e.Id)
+                .HasName("id");
+            });
+
+            modelBuilder.Entity<Servicio>(entity =>
+            {
+                entity.ToTable("servicio");
+
+                entity.Property(e => e.Id)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id");
+
+                entity.Property(e => e.Pid)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("pid");
+
+                entity.Property(e => e.Terminado)
+                    .HasColumnType("tinyint(1) unsigned")
+                    .HasColumnName("terminado");
+
+                entity.Property(e => e.Inicio).HasColumnName("inicio");
+
+                entity.Property(e => e.Fin).HasColumnName("fin");
+
+                entity.Property(e => e.Tipo).HasColumnName("tipo");
+
+                entity.HasKey(e => e.Id)
+                .HasName("id");
+            });
+
+            modelBuilder.Entity<ServiceQueue>(entity =>
+            {
+                entity.ToTable("service_queue");
+
+                entity.Property(e => e.Id)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id");
+
+                entity.Property(e => e.IdSimulacion)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id_simulacion");
+
+                entity.Property(e => e.IdAcuifero)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id_acuifero");
+
+                entity.Property(e => e.Terminado)
+                    .HasColumnType("tinyint(1) unsigned")
+                    .HasColumnName("terminado");
+
+                entity.Property(e => e.Error)
+                    .HasColumnType("tinyint(1) unsigned")
+                    .HasColumnName("error");
+
+                entity.Property(e => e.Corriendo)
+                    .HasColumnType("tinyint(1) unsigned")
+                    .HasColumnName("corriendo");
+
+                entity.Property(e => e.Inicio).HasColumnName("inicio");
+
+                entity.Property(e => e.Fin).HasColumnName("fin");
+
+
+                entity.HasKey(e => e.Id)
+                .HasName("id");
+            });
+
+
+            modelBuilder.Entity<Simulacion>(entity =>
+            {
+                entity.ToTable("simulacion");
+
+                entity.Property(e => e.Id)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id");
+
+                entity.Property(e => e.IdAcuifero)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id_acuifero");
+
+                entity.Property(e => e.Nombre)
+                    .HasMaxLength(255)
+                    .HasColumnName("nombre");
+                
+                entity.Property(e => e.IsolineImage)
+                    .HasMaxLength(255)
+                    .HasColumnName("isoline_image");
+
+                entity.HasKey(e => e.Id)
+                .HasName("id");
+            });
+
+            modelBuilder.Entity<TsPozo>(entity =>
+            {
+                entity.ToTable("ts_pozo");
+
+                entity.Property(e => e.Id)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id");
+
+                entity.Property(e => e.IdPozo)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id_pozo");
+
+                entity.Property(e => e.MarcaTiempo)
+                    .HasMaxLength(50)
+                    .HasColumnName("marca_tiempo");
+
+                entity.Property(e => e.MarcaTiempoEnd)
+                    .HasMaxLength(50)
+                    .HasColumnName("marca_tiempo_end");
+
+                entity.Property(e => e.InfoComplementaria)
+                    .HasMaxLength(255)
+                    .HasColumnName("info_complementaria");
+
+                entity.Property(e => e.Valor).HasColumnName("valor");
+
+                
+                entity.Property(e => e.DateIn).HasColumnName("date_in");
+                entity.Property(e => e.DateEnd).HasColumnName("date_end");
+
+                entity.HasKey(e => e.Id)
+                .HasName("id");
+            });
+
+            modelBuilder.Entity<TsRecarga>(entity =>
+            {
+                entity.ToTable("ts_recarga");
+
+                entity.Property(e => e.Id)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id");
+
+                entity.Property(e => e.IdRecarga)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id_recarga");
+
+                entity.Property(e => e.MarcaTiempo)
+                    .HasMaxLength(50)
+                    .HasColumnName("marca_tiempo");
+
+                entity.Property(e => e.MarcaTiempoEnd)
+                    .HasMaxLength(50)
+                    .HasColumnName("marca_tiempo_end");
+
+                entity.Property(e => e.InfoComplementaria)
+                    .HasMaxLength(255)
+                    .HasColumnName("info_complementaria");
+
+                entity.Property(e => e.Valor).HasColumnName("valor");
+
+
+                entity.HasKey(e => e.Id)
+                .HasName("id");
+            });
+
+            modelBuilder.Entity<BalanceHidrico>(entity =>
+            {
+                entity.ToTable("balance_hidrico");
+
+                entity.Property(e => e.Id)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id");
+
+                entity.Property(e => e.IdSimulacion)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id_simulacion");
+
+                entity.Property(e => e.StressPeriod).HasColumnName("stress_period");
+
+                entity.Property(e => e.Zona).HasColumnName("zona");
+
+                entity.Property(e => e.TotalZona).HasColumnName("total_zona");
+
+                entity.HasKey(e => e.Id)
+                .HasName("id");
+            });
+
+            modelBuilder.Entity<DatosBalanceIn>(entity =>
+            {
+                entity.ToTable("datos_balance_in");
+
+                entity.Property(e => e.Id)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id");
+
+                entity.Property(e => e.IdBalance)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id_balance_hidrico");
+
+                entity.Property(e => e.Storage).HasColumnName("storage");
+
+                entity.Property(e => e.Recharge).HasColumnName("recharge");
+
+                entity.Property(e => e.Drains).HasColumnName("drains");
+
+                entity.Property(e => e.ConstantHead).HasColumnName("constant_head");
+
+
+                entity.Property(e => e.Total).HasColumnName("total");
+
+                entity.HasKey(e => e.Id)
+                .HasName("id");
+            });
+
+            modelBuilder.Entity<DatosBalanceOut>(entity =>
+            {
+                entity.ToTable("datos_balance_out");
+
+                entity.Property(e => e.Id)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id");
+
+                entity.Property(e => e.IdBalance)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id_balance_hidrico");
+
+                entity.Property(e => e.Storage).HasColumnName("storage");
+
+                entity.Property(e => e.Recharge).HasColumnName("recharge");
+
+                entity.Property(e => e.Drains).HasColumnName("drains");
+
+                entity.Property(e => e.ConstantHead).HasColumnName("constant_head");
+
+
+                entity.Property(e => e.Total).HasColumnName("total");
+
+                entity.HasKey(e => e.Id)
+                .HasName("id");
+            });
+
+            modelBuilder.Entity<ConexionZonasIn>(entity =>
+            {
+                entity.ToTable("conexion_zonas_in");
+
+                entity.Property(e => e.Id)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id");
+
+                entity.Property(e => e.IdDatosBalanceIn)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id_balance_in");
+
+                entity.Property(e => e.From).HasColumnName("from");
+
+                entity.Property(e => e.To).HasColumnName("to");
+
+                entity.Property(e => e.Value).HasColumnName("value");
+
+                entity.HasKey(e => e.Id)
+                .HasName("id");
+            });
+
+            modelBuilder.Entity<ConexionZonasOut>(entity =>
+            {
+                entity.ToTable("conexion_zonas_out");
+
+                entity.Property(e => e.Id)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id");
+
+                entity.Property(e => e.IdDatosBalanceOut)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id_balance_out");
+
+                entity.Property(e => e.From).HasColumnName("from");
+
+                entity.Property(e => e.To).HasColumnName("to");
+
+                entity.Property(e => e.Value).HasColumnName("value");
+
+                entity.HasKey(e => e.Id)
+                .HasName("id");
+            });
+
+            modelBuilder.Entity<Piezometria>(entity =>
+            {
+                entity.ToTable("piezometria");
+
+                entity.Property(e => e.Id)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id");
+
+                entity.Property(e => e.IdSimulacion)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id_simulacion");
+
+                entity.Property(e => e.StressPeriod).HasColumnName("stress_period");
+
+                entity.Property(e => e.Layer).HasColumnName("layer");
+
+                entity.Property(e => e.Columns).HasColumnName("columns");
+                
+                entity.Property(e => e.Rows).HasColumnName("rows");
+
+                entity.Property(e => e.Original).HasColumnName("original");
+                
+                entity.Property(e => e.Convertida).HasColumnName("convertida");
+
+                entity.HasKey(e => e.Id)
+                .HasName("id");
+            });
+
+            modelBuilder.Entity<Piezometer>(entity =>
+            {
+                entity.ToTable("piezometer");
+
+                entity.Property(e => e.Id)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id");
+
+                entity.Property(e => e.Name)
+                    .HasMaxLength(50)
+                    .HasColumnName("nombre");
+
+                entity.Property(e => e.X)
+                    .HasMaxLength(50)
+                    .HasColumnName("x");
+
+                entity.Property(e => e.Y)
+                    .HasMaxLength(50)
+                    .HasColumnName("y");
+
+                entity.Property(e => e.Z)
+                    .HasMaxLength(50)
+                    .HasColumnName("z");
+
+                entity.Property(e => e.Prof)
+                    .HasMaxLength(50)
+                    .HasColumnName("prof");
+
+                entity.Property(e => e.ScreenTop)
+                    .HasMaxLength(50)
+                    .HasColumnName("screen_top");
+
+                entity.Property(e => e.ScreenBot)
+                    .HasMaxLength(50)
+                    .HasColumnName("screen_bot");
+
+
+                entity.HasKey(e => e.Id)
+                .HasName("id");
+            });
+
+            modelBuilder.Entity<TsPiezometer>(entity =>
+            {
+                entity.ToTable("ts_piezometer");
+
+                entity.Property(e => e.Id)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("id");
+
+                entity.Property(e => e.PiezometerId)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("piezometer_id");
+
+                entity.Property(e => e.Date)
+                    .HasMaxLength(50)
+                    .HasColumnName("date");
+
+                entity.Property(e => e.Day)
+                    .HasMaxLength(50)
+                    .HasColumnName("day");
+
+                entity.Property(e => e.Quote)
+                    .HasMaxLength(50)
+                    .HasColumnName("quote");
+
+
+                entity.HasKey(e => e.Id)
+                .HasName("id");
+            });
+
+            OnModelCreatingPartial(modelBuilder);
+        }
+
+        partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
+    }
+}

WorkerService1/WebApplication3/Models/BalanceHidrico.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using WebApplication3.Clases;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class BalanceHidrico
+    {
+        public uint Id { get; set; }
+        public uint? IdSimulacion { get; set; }
+        public string TotalZona { get; set; }
+        public string Zona { get; set; }
+        public int? StressPeriod { get; set; }
+    }
+}

WorkerService1/WebApplication3/Models/ConexionZonasIn.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using WebApplication3.Clases;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class ConexionZonasIn
+    {
+        public uint Id { get; set; }
+        public uint? IdDatosBalanceIn { get; set; }
+        public string From { get; set; }
+        public string To { get; set; }
+        public string Value { get; set; }
+
+    }
+}

WorkerService1/WebApplication3/Models/ConexionZonasOut.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using WebApplication3.Clases;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class ConexionZonasOut
+    {
+        public uint Id { get; set; }
+        public uint? IdDatosBalanceOut { get; set; }
+        public string From { get; set; }
+        public string To { get; set; }
+        public string Value { get; set; }
+
+    }
+}

WorkerService1/WebApplication3/Models/DatosBalanceIn.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using WebApplication3.Clases;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class DatosBalanceIn
+    {
+        public uint Id { get; set; }
+        public uint? IdBalance { get; set; }
+        public string Storage { get; set; }
+        public string ConstantHead { get; set; }
+        public string Drains { get; set; }
+        public string Recharge { get; set; }
+        public string Total { get; set; }
+
+    }
+}

WorkerService1/WebApplication3/Models/DatosBalanceOut.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using WebApplication3.Clases;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class DatosBalanceOut
+    {
+        public uint Id { get; set; }
+        public uint? IdBalance { get; set; }
+        public string Storage { get; set; }
+        public string ConstantHead { get; set; }
+        public string Drains { get; set; }
+        public string Recharge { get; set; }
+        public string Total { get; set; }
+
+    }
+}

WorkerService1/WebApplication3/Models/Piezometria.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class Piezometria
+    {
+        public uint Id { get; set; }
+        public uint? IdSimulacion { get; set; }
+        public int StressPeriod{ get; set; }
+        public int Layer { get; set; }
+        public int Columns { get; set; }
+        public int Rows { get; set; }
+        public string Original { get; set; }
+        public string Convertida { get; set; }
+        
+
+    }
+}

WorkerService1/WebApplication3/Models/Piezometro.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using WebApplication3.Clases;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class Piezometer
+    {
+        public uint Id { get; set; }
+        public string Name { get; set; }
+        public string X { get; set; }
+        public string Y { get; set; }
+        public string Z { get; set; }
+        public string Prof { get; set; }
+        public string ScreenTop { get; set; }
+        public string ScreenBot { get; set; }
+    }
+}

WorkerService1/WebApplication3/Models/Pozo.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using WebApplication3.Clases;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class Pozo
+    {
+        public uint Id { get; set; }
+        public string Nombre { get; set; }
+        public uint? IdAquifero { get; set; }
+        public string Minimo { get; set; }
+        public string  Maximo { get; set; }
+        public string Latitud { get; set; }
+        public string Longitud { get; set; }
+        public uint? IdSimulacion { get; set; }
+        public string X { get; set; }
+        public string Y { get; set; }
+        public string Z { get; set; }
+        public string Prof { get; set; }
+        public string ScreenTop { get; set; }
+        public string ScreenBot { get; set; }
+
+        public Pozo Copy(uint? idSimulacion)
+        {
+            Pozo pozo = new Pozo();
+            pozo.IdAquifero = this.IdAquifero;
+            pozo.IdSimulacion = idSimulacion;
+            pozo.Latitud = this.Latitud;
+            pozo.Longitud = this.Longitud;
+            pozo.Maximo = this.Maximo;
+            pozo.Minimo = this.Minimo;
+            pozo.Nombre = this.Nombre;
+            return pozo;
+        }
+    }
+}

WorkerService1/WebApplication3/Models/Recarga.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class Recarga
+    {
+        public uint Id { get; set; }
+        public string Nombre { get; set; }
+        public uint? IdSimulacion { get; set; }
+        public string Latitud { get; set; }
+        public string Longitud { get; set; }
+        public uint? IdAcuifero { get; set; }
+
+        public Recarga Copy(uint? simulacionId)
+        {
+            Recarga recarga = new Recarga();
+            recarga.Nombre = this.Nombre;
+            recarga.Latitud = this.Latitud;
+            recarga.Longitud = this.Longitud;
+            recarga.IdSimulacion = simulacionId;
+            recarga.IdAcuifero = this.IdAcuifero;
+
+            return recarga;
+        }
+    }
+}

WorkerService1/WebApplication3/Models/ServiceQueue.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class ServiceQueue
+    {
+        public uint Id { get; set; }
+        public uint? IdSimulacion { get; set; }
+        public uint? IdAcuifero { get; set; }
+        public string Inicio { get; set; }
+        public string Fin { get; set; }
+        public byte Terminado { get; set; }
+        public byte Error { get; set; }
+        public byte Corriendo { get; set; }
+
+    }
+}

WorkerService1/WebApplication3/Models/Servicio.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class Servicio
+    {
+        public uint Id { get; set; }
+        public uint? Pid { get; set; }
+        public byte Terminado { get; set; }
+        public string Inicio { get; set; }
+        public string Fin { get; set; }
+        public string Tipo { get; set; }
+        
+    }
+}

WorkerService1/WebApplication3/Models/Simulacion.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class Simulacion
+    {
+        public uint Id { get; set; }
+        public uint? IdAcuifero { get; set; }
+        public string Nombre { get; set; }
+        public string IsolineImage { get; set; }
+    }
+}

WorkerService1/WebApplication3/Models/TSPiezometer.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class TsPiezometer
+    {
+        public uint Id { get; set; }
+        public uint? PiezometerId { get; set; }
+        public string Date { get; set; }
+        public string Day { get; set; }
+        public string Quote { get; set; }
+    }
+}

WorkerService1/WebApplication3/Models/TSPozo.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class TsPozo
+    {
+        public uint Id { get; set; }
+        public uint? IdPozo { get; set; }
+        public string MarcaTiempo { get; set; }
+        public string Valor { get; set; }
+        public string InfoComplementaria { get; set; }
+        public string DateIn { get; set; }
+        public string DateEnd { get; set; }
+        public string MarcaTiempoEnd { get; set; }
+
+        public TsPozo Copy(uint? pozoId)
+        {
+            TsPozo tsPozo = new TsPozo();
+            tsPozo.IdPozo = pozoId;
+            tsPozo.Valor = this.Valor;
+            tsPozo.MarcaTiempo = this.MarcaTiempo;
+            tsPozo.InfoComplementaria = this.InfoComplementaria;
+
+            return tsPozo;
+        }
+
+    }
+}

WorkerService1/WebApplication3/Models/TSRecarga.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+
+#nullable disable
+
+namespace WebApplication3.Models
+{
+    public partial class TsRecarga
+    {
+        public uint Id { get; set; }
+        public uint? IdRecarga { get; set; }
+        public string MarcaTiempo { get; set; }
+        public string Valor { get; set; }
+        public string MarcaTiempoEnd { get; set; }
+        public string InfoComplementaria { get; set; }
+    }
+}

WorkerService1/WebApplication3/Program.cs

@@ -0,0 +1,47 @@
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using WebApplication3.Clases;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace WebApplication3
+{
+    public class Program
+    {
+        public static void Main( string[] args )
+        {
+            Proceso proceso = Proceso.GetInstance();
+            CreateHostBuilder( args ).Build().Run();
+        }
+
+        public static IHostBuilder CreateHostBuilder( string[] args ) =>
+            Host.CreateDefaultBuilder( args )
+                .ConfigureLogging(logging =>
+                {
+                    logging.ClearProviders();
+                    logging.AddConsole();
+                    logging.AddEventLog();
+                })
+                .ConfigureServices((hostBuilderContext, services) =>
+                {
+                    services.AddLogging();
+                    services.AddHostedService<Worker>();
+                    services.AddHostedService<QueueWorker>();
+                })
+                .ConfigureWebHostDefaults( webBuilder =>
+                {
+                    webBuilder.UseStartup<Startup>();
+
+                } ).ConfigureWebHost( config =>
+                {
+                    config.UseUrls( "http://*:5050" );
+
+                } ).UseWindowsService();
+
+    }
+}

WorkerService1/WebApplication3/Startup.cs

@@ -0,0 +1,68 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.HttpsPolicy;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Microsoft.OpenApi.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using WebApplication3.Models;
+
+
+namespace WebApplication3
+{
+    public class Startup
+    {
+        public Startup( IConfiguration configuration )
+        {
+            Configuration = configuration;
+        }
+
+        public IConfiguration Configuration
+        {
+            get;
+        }
+
+        // This method gets called by the runtime. Use this method to add services to the container.
+        public void ConfigureServices( IServiceCollection services )
+        {
+            services.AddDbContext<AquiferContext>(opt =>
+                       opt.UseMySql(Configuration.GetConnectionString("AquiferDatabase"), Microsoft.EntityFrameworkCore.ServerVersion.Parse("5.7.24-mysql"))
+            );
+
+            services.AddControllers();
+            services.AddSwaggerGen( c =>
+             {
+                 c.SwaggerDoc( "v1", new OpenApiInfo { Title = "WebApplication3", Version = "v1" } );
+             } );
+        }
+
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+        public void Configure( IApplicationBuilder app, IWebHostEnvironment env )
+        {
+            if( env.IsDevelopment() )
+            {
+                app.UseDeveloperExceptionPage();
+            }
+            app.UseSwagger();
+            app.UseSwaggerUI( c => c.SwaggerEndpoint( "/swagger/v1/swagger.json", "WebApplication3 v1" ) );
+
+            app.UseHttpsRedirection();
+
+            app.UseRouting();
+
+            app.UseAuthorization();
+
+            app.UseEndpoints( endpoints =>
+             {
+                 endpoints.MapControllers();
+             } );
+        }
+    }
+}

WorkerService1/WebApplication3/WebApplication3.csproj

@@ -0,0 +1,95 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net5.0</TargetFramework>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="5.0.6" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="5.0.6" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="5.0.6">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.Extensions.Hosting.WindowsServices" Version="5.0.1" />
+    <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="5.0.2" />
+    <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="5.0.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.1.4" />
+    <PackageReference Include="System.Drawing.Common" Version="6.0.0" />
+    <PackageReference Include="System.Net.Http" Version="4.3.4" />
+  </ItemGroup>
+
+	<ItemGroup>
+		<Compile Update="Acuifero.cs">
+			<CopyToOutputDirectory>Never</CopyToOutputDirectory>
+		</Compile>
+	</ItemGroup>
+	<ItemGroup>
+		<Compile Update="aquiferContext.cs">
+			<CopyToOutputDirectory>Never</CopyToOutputDirectory>
+		</Compile>
+	</ItemGroup>
+	<ItemGroup>
+		<Compile Update="Pozo.cs">
+			<CopyToOutputDirectory>Never</CopyToOutputDirectory>
+		</Compile>
+	</ItemGroup>
+	    <ItemGroup>
+	    <Compile Update="Recarga.cs">
+		    <CopyToOutputDirectory>Never</CopyToOutputDirectory>
+	    </Compile>
+    </ItemGroup>
+	<ItemGroup>
+		<Compile Update="Servicio.cs">
+			<CopyToOutputDirectory>Never</CopyToOutputDirectory>
+		</Compile>
+	</ItemGroup>
+    <ItemGroup>
+	    <Compile Update="ServicioController.cs">
+		    <CopyToOutputDirectory>Never</CopyToOutputDirectory>
+	    </Compile>
+    </ItemGroup>
+
+	<ItemGroup>
+		<Compile Update="AcuiferoController.cs">
+			<CopyToOutputDirectory>Never</CopyToOutputDirectory>
+		</Compile>
+	</ItemGroup>
+	<ItemGroup>
+		<Compile Update="PozoController.cs">
+			<CopyToOutputDirectory>Never</CopyToOutputDirectory>
+		</Compile>
+	</ItemGroup>
+	<ItemGroup>
+		<Compile Update="RecargasController.cs">
+			<CopyToOutputDirectory>Never</CopyToOutputDirectory>
+		</Compile>
+	</ItemGroup>
+	<ItemGroup>
+		<Compile Update="Proceso.cs">
+			<CopyToOutputDirectory>Never</CopyToOutputDirectory>
+		</Compile>
+	</ItemGroup>
+	<ItemGroup>
+		<Compile Update="Worker.cs">
+			<CopyToOutputDirectory>Never</CopyToOutputDirectory>
+		</Compile>
+	</ItemGroup>
+	<ItemGroup>
+    <None Update="install_service.bat">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="uninstall_service.bat">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+</Project>

WorkerService1/WebApplication3/appsettings.Development.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  }
+}

WorkerService1/WebApplication3/appsettings.json

@@ -0,0 +1,19 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    },
+    "EventLog": {
+      "LogLevel": {
+        "Default": "Information",
+        "Microsoft.Hosting.Lifetime": "Information"
+      }
+    }
+  },
+  "AllowedHosts": "*",
+  "ConnectionStrings": {
+    "AquiferDatabase": "Server=localhost;UserId=root;Password=;Database=aquifer"
+  }
+}

WorkerService1/WebApplication3/install_service.bat

@@ -0,0 +1 @@
+sc create APIasWIN binPath="C:\Users\Admin\Desktop\WorkerService1\WebApplication3\bin\Release\net5.0\WebApplication3.exe"

WorkerService1/WebApplication3/uninstall_service.bat

@@ -0,0 +1 @@
+SC DELETE APIasWIN

WorkerService1/WorkerService1.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.31321.278
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WebApplication3", "WebApplication3\WebApplication3.csproj", "{A7670D78-7D36-4BB9-B213-94FF50B2CBBF}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{A7670D78-7D36-4BB9-B213-94FF50B2CBBF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A7670D78-7D36-4BB9-B213-94FF50B2CBBF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A7670D78-7D36-4BB9-B213-94FF50B2CBBF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A7670D78-7D36-4BB9-B213-94FF50B2CBBF}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {DC477209-B590-4B80-9B20-AFE209ECD286}
+	EndGlobalSection
+EndGlobal