Stable version 2.0

WorkerService1/WebApplication3/Clases/Constants.cs

 {
     public static class Constants
     {
-        public const string PathZip = @"C:\Users\Admin\Desktop\";
-        public const string PathExtract = @"C:\Users\Admin\Desktop\TestExtract\";
+        //public const string PathZip = @"C:\Users\Admin\Desktop\";
+        public const string PathZip = @"C:\Users\Admin\Documents\modflow_models\";
+        //public const string PathExtract = @"C:\Users\Admin\Desktop\TestExtract\";
+        public const string PathExtract = @"C:\Users\Admin\Documents\modflow_models\temp\";
         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()
         {
             { "7", "#660099" },
             { "8", "#266A2E" }
         };
+        public const string SVGFileName = "vector_image.svg";
+        public const string PNGFileName = "color_map.png";
+        public const string GeoJsonFileName = "vector_image.geojson";
     }
 }

WorkerService1/WebApplication3/Clases/DatosPostAcuifero.cs

 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
     {
         public string Nombre { get; set; }
         public Fichero Fichero { get; set; }
+        
     }
 }

WorkerService1/WebApplication3/Clases/Fichero.cs

     {
         public string Nombre { get; set; }
         public string Base64 { get; set; }
+        public byte[] Test { get; set; }
     }
 }

WorkerService1/WebApplication3/Clases/Parser.cs

                                 //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++)
+                                List<string> linesAux = new();
                                 for (int i = 0; i < wellData.ScreenIntervals * 2; i++)
                                 {
-                                    file.ReadLine();
+                                    linesAux.Add(file.ReadLine());
                                     cont++;
                                 }
+                                wellData.Bot = linesAux[0];
+                                wellData.Top = linesAux[1];
 
                                 break;
                             default:
                         else
                         {
                             TimeSerieInterno ts = new TimeSerieInterno();
-                            string aux = "";
+                            //string aux = "";
                             //Rate rate = new Rate();
                             ts.Hora = ln;
                             //rate.StartTime = float.Parse(ln.Replace('.', ','));
 
                             ln = file.ReadLine();
+                            ts.HoraEnd = ln;
                             cont++;
                             
-                            if(cont == finalBloque - 1)
-                            {
-                                aux = ln;
-                            }
+                            //if(cont == finalBloque - 1)
+                            //{
+                            //    aux = ln;
+                            //}
 
                             ln = file.ReadLine();
                             cont++;
                             //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);
-                            }
+                            //if(aux != "")
+                            //{
+                            //    ts = new TimeSerieInterno();
+                            //    ts.Hora = aux;
+                            //    ts.Valor = value;
+                            //    ts.Info = ln.Replace(exploded[0] + ' ', "");
+                            //    wellData.Rates.Add(ts);
+                            //}
                         }
                     }
 
                 Console.WriteLine(data[rechargeBlockInex]);
                 string[] explode = data[rechargeBlockInex].Split("\r\n");
 
-                for(int i = 3; i < explode.Length; i++)
+                for (int i = 1; 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 != values[0])
                     {
-                        if(rechargeProperty != "")
+                        if (rechargeProperty != "")
                         {
                             recharges.Add(rechargeData);
                         }
                         rechargeData = new RechargeData();
                         rechargeData.Nombre = "Recarga_" + values[0];
                         rechargeProperty = values[0];
+                        //Al hacer el cambio
+                        i += 2;
+                        values = explode[i].Split(" ", StringSplitOptions.RemoveEmptyEntries);
                     }
 
                     timeSerie = new TimeSerieInterno();
                     timeSerie.Hora = values[2];
+                    timeSerie.HoraEnd = values[3];
                     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);
-                    }
+                    ////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];
 
 
             aux.RemoveAll(x => x.Contains("WHS") || x.Contains("NDC") || x.Contains("CLB") || x == "");
 
+            List<string> units = new();
+            foreach (string row in aux)
+            {
+                if (!aux.Contains("LIST"))
+                {
+                    string[] rowSplit = row.Split(" ", StringSplitOptions.RemoveEmptyEntries);
+
+                    units.Add(rowSplit[1]);
+                }
+            }
+
             foreach (string row in aux)
             {
                 string[] rowSplit = row.Split(" ", StringSplitOptions.RemoveEmptyEntries);
 
                 if (rowSplit[0] == "LIST" && int.Parse(rowSplit[1]) < 10)
                 {
-                    rowSplit[1] = "12";
+                    if (!units.Contains("11"))
+                    {
+                        rowSplit[1] = "11";
+                    } 
+                    else if (!units.Contains("12"))
+                    {
+                        rowSplit[1] = "12";
+                    }
+                    else if (!units.Contains("13"))
+                    {
+                        rowSplit[1] = "13";
+                    }
+                    else if (!units.Contains("14"))
+                    {
+                        rowSplit[1] = "14";
+                    }
                 }
 
                 //Se tiene que parsear la 3a parte del string porque contiene la ruta absoluta del ordenador donde se han originado los ficheros
 
         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);
 
                 current.Type = 2;
 
 
-                List<string> data_aux = data[i].Split("\r\n").ToList();
-                string[] split = data_aux[2].Split("STRESS PERIOD");
+                List<string> data_aux = data[i].Split("\r\n", StringSplitOptions.RemoveEmptyEntries).ToList();
+                string[] split = data_aux[2].Split("STRESS PERIOD", StringSplitOptions.RemoveEmptyEntries);
 
 
                 #region IN
-                split = data_aux[10].Split("STORAGE =", StringSplitOptions.RemoveEmptyEntries);
+                split = data_aux[8].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);
+                split = data_aux[9].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();
+                if (data_aux[10].Contains("DRAINS"))
+                {
+                    split = data_aux[10].Split("DRAINS =", StringSplitOptions.RemoveEmptyEntries);
+                    cummulative.In.Drains = split[1].Trim();
+                    current.In.Drains = split[2].Trim();
+                }
+                else
+                {
+                    split = data_aux[10].Split("WELLS =", StringSplitOptions.RemoveEmptyEntries);
+                    cummulative.In.Wells = split[1].Trim();
+                    current.In.Wells = split[2].Trim();
+                }
 
-                split = data_aux[13].Split("RECHARGE =", StringSplitOptions.RemoveEmptyEntries);
+                split = data_aux[11].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);
+                split = data_aux[13].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);
+                split = data_aux[16].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);
+                split = data_aux[17].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();
+                if (data_aux[18].Contains("DRAINS"))
+                {
+                    split = data_aux[18].Split("DRAINS =", StringSplitOptions.RemoveEmptyEntries);
+                    cummulative.Out.Drains = split[1].Trim();
+                    current.Out.Drains = split[2].Trim();
+                }
+                else
+                {
+                    split = data_aux[18].Split("WELLS =", StringSplitOptions.RemoveEmptyEntries);
+                    cummulative.Out.Wells = split[1].Trim();
+                    current.Out.Wells = split[2].Trim();
+                }
 
-                split = data_aux[22].Split("RECHARGE =", StringSplitOptions.RemoveEmptyEntries);
+                split = data_aux[19].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);
+                split = data_aux[21].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);
+                split = data_aux[22].Split("IN - OUT =", StringSplitOptions.RemoveEmptyEntries);
                 cummulative.TotalInOut = split[1].Trim();
                 current.TotalInOut = split[2].Trim();
 
-                split = data_aux[28].Split("PERCENT DISCREPANCY =", StringSplitOptions.RemoveEmptyEntries);
+                split = data_aux[23].Split("PERCENT DISCREPANCY =", StringSplitOptions.RemoveEmptyEntries);
                 cummulative.PercentDiscrepancy = split[1].Trim();
                 current.PercentDiscrepancy = split[2].Trim();
 
                             piezometria.Add(p);
                             
                         }
+
+                        Logger.WriteLog("Ya se ha leido el fichero");
                     }
                 }catch(Exception ex)
                 {
 
             string text = File.ReadAllText(file);
 
-            List<string> data = text.Split("\r\n").ToList();
+            List<string> data = text.Split("\r\n", StringSplitOptions.RemoveEmptyEntries).ToList();
             //string geolocationData = data[2];
-            string geolocation_line = data.Find(x=> x.Contains("<Georeference"));
+            string geolocation_line = data.Find(x => x.Contains("<Georeference"));
+
+            string[] geolocation_data = geolocation_line.Split(" ", StringSplitOptions.RemoveEmptyEntries);
+            string[] world_origin_x = geolocation_data[3].Split("World_Origin_X=", StringSplitOptions.RemoveEmptyEntries);
+            string[] world_origin_y = geolocation_data[4].Split("World_Origin_Y=", StringSplitOptions.RemoveEmptyEntries);
 
-            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);
+            worldX = world_origin_x[0].Replace("\"", string.Empty);
+            worldY = world_origin_y[0].Replace("\"", string.Empty);
         }
 
         public WellData[] parseWellCSV(string file)

WorkerService1/WebApplication3/Clases/Proceso.cs

             proceso.StartInfo.Arguments = script+" "+headFile+" "+rows+" "+cols+" "+isolines;
             proceso.StartInfo.UseShellExecute = false;
         }
+
+        public void SetParametersSVG2Json(string workingDirectory, string fileName)
+        {
+            proceso.StartInfo.WorkingDirectory = workingDirectory;
+            proceso.StartInfo.FileName = "svg2geojson";
+            proceso.StartInfo.Arguments = fileName;
+            proceso.StartInfo.UseShellExecute = false;
+
+        }
         public int GetPid()
         {
             return proceso.Id;

WorkerService1/WebApplication3/Clases/QueueWorker.cs

             _logger = logger;
 
             var aquiferContext = new AquiferContext();
-            servicioController = new ServicioController(aquiferContext);
             simulacionController = new SimulacionController(aquiferContext);
             serviceQueueController = new ServiceQueueController(aquiferContext);
         }

WorkerService1/WebApplication3/Clases/RechargeData.cs

         public string Nombre { get; set; }
         public List<TimeSerieInterno> Rates { get; set; }
 
-        public Recarga ToRecarga(uint acuifero)
+        public Recarga ToRecarga(uint acuifero,uint simId)
         {
             Recarga recarga = new Recarga();
 
             recarga.IdAcuifero = acuifero;
+            recarga.IdSimulacion = simId;
             recarga.Nombre = this.Nombre;
 
             return recarga;

WorkerService1/WebApplication3/Clases/Utilities.cs

 using System.Collections.Generic;
 using System.Drawing;
 using System.Drawing.Imaging;
+using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 
 {
     public static class Utilities
     {
-        public static bool String2Png(string data)
+        public static string 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 fileName = @"C:\Users\Admin\Desktop\AAAA\green.png";
 
             string[,] array2Db = new string[height, width];
             for(int i= 0; i < height; i++)
             }
 
             // Fill array with random values
-            Random random = new Random();
             for (int x = 0; x < height; ++x)
             {
                 for (int y = 0; y < width; ++y)
 
             using (b)
             {
-                b.Save(@"C:\Users\Admin\Desktop\AAAA\green.png", ImageFormat.Png);
+                b.Save(fileName, ImageFormat.Png);
+            }
+            return fileName;
+        }
+
+        public static void BinaryToFile(byte[] ba, string fileName)
+        {
+            using (FileStream fs = new FileStream(fileName, FileMode.Create))
+            {
+                using (BinaryWriter bw = new BinaryWriter(fs))
+                {
+                    bw.Write(ba);
+                }
             }
-            return result;
         }
     }
 }

WorkerService1/WebApplication3/Clases/WellData.cs

         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)
+        public Pozo ToPozo(uint acuifero, uint simId)
         {
             Pozo p = new Pozo();
-
             p.IdAquifero = acuifero;
-            p.IdSimulacion = null;
-            p.Longitud = this.X;
-            p.Latitud = this.Y;
+            p.IdSimulacion = simId;
+            p.X = this.X;
+            p.Y = this.Y;
             //p.Maximo = float.Parse(this.ZMax);
-            p.Maximo = "0";
+            p.Maximo = ZMax;
             //p.Minimo = float.Parse(this.ZMin);
-            p.Minimo = "0";
+            p.Minimo = ZMin;
             p.Nombre = this.WellName;
+            p.Active = (this.ActiveFlag) ? (uint)1 : (uint)0;
             return p;
         }
 

WorkerService1/WebApplication3/Clases/Worker.cs

                         proceso.Started = false;
                         proceso.Detected = true;
 
-                        int terminado = await servicioController.setTerminado(proceso.GetPid());
+                        int terminado = await servicioController.SetTerminado(proceso.GetPid());
                         
                         if( terminado > 0)
                         {

WorkerService1/WebApplication3/Clases/ZoneData.cs

         public string Storage { get; set; }
         public string ConstantHead { get; set; }
         public string Drains { get; set; }
+        public string Wells { get; set; }
         public string Recharge { get; set; }
         public string Total { get; set; }
 
             Storage = dataIn.Storage;
             ConstantHead = dataIn.ConstantHead;
             Drains = dataIn.Drains;
+            Wells = dataIn.Wells;
             Recharge = dataIn.Recharge;
             Total = dataIn.Total;
             ZoneConnections = new List<ZoneConnection>();
         }
 
-        public ZoneData(DatosBalanceOut dataIn)
+        public ZoneData(DatosBalanceOut dataOut)
         {
-            Id = dataIn.Id;
-            Storage = dataIn.Storage;
-            ConstantHead = dataIn.ConstantHead;
-            Drains = dataIn.Drains;
-            Recharge = dataIn.Recharge;
-            Total = dataIn.Total;
+            Id = dataOut.Id;
+            Storage = dataOut.Storage;
+            ConstantHead = dataOut.ConstantHead;
+            Drains = dataOut.Drains;
+            Wells = dataOut.Wells;
+            Recharge = dataOut.Recharge;
+            Total = dataOut.Total;
             ZoneConnections = new List<ZoneConnection>();
         }
 
             datosIn.Storage = this.Storage;
             datosIn.ConstantHead = this.ConstantHead;
             datosIn.Drains = this.Drains;
+            datosIn.Wells = this.Wells;
             datosIn.Recharge = this.Recharge;
             datosIn.Total = this.Total;
             datosIn.IdBalance = idBalance;
             datosOut.Storage = this.Storage;
             datosOut.ConstantHead = this.ConstantHead;
             datosOut.Drains = this.Drains;
+            datosOut.Wells = this.Wells;
             datosOut.Recharge = this.Recharge;
             datosOut.Total = this.Total;
             datosOut.IdBalance = idBalance;

WorkerService1/WebApplication3/Controllers/AcuiferoController.cs

 
         // GET: api/Acuifero/5
         [HttpGet("{id}")]
+        [ProducesResponseType(200)]
+        [ProducesResponseType(404)]
         public async Task<ActionResult<Acuifero>> GetAcuifero(uint id)
         {
             var acuifero = await _context.Acuiferos.FindAsync(id);
             return acuifero;
         }
 
-        [HttpGet("GeoRecharge/{id}")]
-        public async Task<bool> GetRechargeColorMap(uint id)
+        [HttpGet("ColorMap/{id}")]
+        public async Task<ActionResult<string>> GetRechargeColorMap(uint id)
         {
             Acuifero aquifer = await _context.Acuiferos.FindAsync(id);
 
-            return Utilities.String2Png(aquifer.RechargeGeometry);
-
+            return Ok(aquifer.RechargeColorMap);
         }
 
         // PUT: api/Acuifero/5
         // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
         [HttpPut("{id}")]
+        [ProducesResponseType(200)]
+        [ProducesResponseType(400)]
+        [ProducesResponseType(404)]
         public async Task<IActionResult> PutAcuifero(uint id, [FromBody] DatosPostAcuifero datos)
         {
 
                 await _context.SaveChangesAsync();
                 Pozo[] pozos = pozoController.GetPozosAcuiferoSimulacionInicial(acuifero.Id);
                 Recarga[] recargas = recargaController.GetRecargasAcuiferoSimulacionInicial(acuifero.Id);
+                uint simId = GetSimZeroId(acuifero.Id);
 
                 foreach (Pozo p in pozos)
                 {
                 //3- Parseamos pozos
                 if (System.IO.File.Exists(pozoFile))
                 {
-                    await pozoController.ParseoFichero(acuifero.Id, pozoFile);
+                    await pozoController.ParseoFichero(acuifero.Id, pozoFile,simId);
                 }
                 //4- Parseamos recargas
                 if (System.IO.File.Exists(recargaFile))
                 {
-                    await recargaController.ParseoFichero(acuifero.Id, recargaFile);
+                    await recargaController.ParseoFichero(acuifero.Id, recargaFile,simId);
                 }
 
             }
             return CreatedAtAction("GetAcuifero", new { id = acuifero.Id }, acuifero);
         }
 
+        [NonAction]
+        public uint GetSimZeroId(uint aquiferId)
+        {
+            var sim = _context.Simulaciones.Where(x => x.IdAcuifero == aquiferId && x.SimulacionAcuifero == 0).First();
+
+            return sim.Id;
+        }
+
+        [HttpPost("TestBinary")]
+        public bool TestBinario([FromBody] DatosPostAcuifero datos)
+        {
+            string file = Constants.PathZip + "test.zip";
+            Utilities.BinaryToFile(datos.Fichero.Test, file);
+
+            if (System.IO.File.Exists(file)) 
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+
+        }
         // POST: api/Acuifero
         // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
         [HttpPost]
+        [ProducesResponseType(201)]
+        [ProducesResponseType(409)]
         public async Task<ActionResult<Acuifero>> PostAcuifero([FromBody] DatosPostAcuifero datos)
         {
-            Acuifero acuifero = new Acuifero();
+            Acuifero acuifero = new ();
             acuifero.Nombre = datos.Nombre;
-            string pathZip = @"C:\Users\Admin\Desktop\";
-            string pathExtract = @"C:\Users\Admin\Desktop\TestExtract\";
+            //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);
+            //try
+            //{
+            //    byte[] tempBytes = Convert.FromBase64String(datos.Fichero.Base64);
+            //    System.IO.File.WriteAllBytes(Constants.PathZip + datos.Fichero.Nombre, tempBytes);
 
-            }
-            catch (Exception ex)
-            {
-                return Problem(ex.Message);
-            }
+            //}
+            //catch (Exception ex)
+            //{
+            //    return Problem(ex.Message);
+            //}
 
             acuifero.Fichero = datos.Fichero.Nombre;
 
 
                 //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>();
+                ZipFile.ExtractToDirectory(Constants.PathZip + datos.Fichero.Nombre, Constants.PathExtract, true);
+                files = Directory.GetFiles(Constants.PathExtract+datos.Nombre).ToList<string>();
                 //1.2 - Obtencion de coordenadas de origen (en el mundo) del modelo
                 string geoFile = files.Find(x => x.Contains(".vmf"));
+                Logger.WriteLog("geofile " + geoFile);
                 string world_origin_x, world_origin_y;
 
                 parser.GetGeolocalizationFromFile(geoFile, out world_origin_x, out world_origin_y);
                 _context.Acuiferos.Add(acuifero);
                 await _context.SaveChangesAsync();
 
+                Simulacion sim = new ();
+                sim.IdAcuifero = acuifero.Id;
+                sim.Nombre = "Sim_0";
+                sim.SimulacionAcuifero = 0;
+                await PostSimulationZero(sim);
+
                 //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);
+                    await pozoController.ParseoFichero(acuifero.Id, pozoFile,sim.Id);
                 }
                 //4- Parseamos recargas
                 if (System.IO.File.Exists(recargaFile))
                 {
-                    await recargaController.ParseoFichero(acuifero.Id, recargaFile);
+                    await recargaController.ParseoFichero(acuifero.Id, recargaFile, sim.Id);
                 }
             }
             catch (DbUpdateException)
             return CreatedAtAction("GetAcuifero", new { id = acuifero.Id }, acuifero);
         }
 
+        [NonAction]
+        public async Task<ActionResult<Simulacion>> PostSimulationZero(Simulacion simulacion)
+        {
+            _context.Simulaciones.Add(simulacion);
+            await _context.SaveChangesAsync();
+
+            return CreatedAtAction("GetSimulacion", new { id = simulacion.Id }, simulacion);
+        }
+
         // DELETE: api/Acuifero/5
         [HttpDelete("{id}")]
+        [ProducesResponseType(404)]
+        [ProducesResponseType(209)]
         public async Task<IActionResult> DeleteAcuifero(int id)
         {
             var acuifero = await _context.Acuiferos.FindAsync(id);
 
             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

         // POST: api/TsPozo
         // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
         [HttpPost]
+        [ProducesResponseType(200)]
+        [ProducesResponseType(409)]
         public async Task<ActionResult<uint>> PostBalance(BalanceHidrico balance)
         {
             _context.BalancesHidricos.Add(balance);

WorkerService1/WebApplication3/Controllers/PiezometriaController.cs

 
 namespace WebApplication3.Controllers
 {
-    [Route("api/[controller]")]
-    [ApiController]
+    //[Route("api/[controller]")]
+    //[ApiController]
+    [ApiExplorerSettings(IgnoreApi = true)]
     public class PiezometriaController : ControllerBase
     {
         private readonly AquiferContext _context;
 
         // GET: api/Pozo/5
         [HttpGet("{id}")]
+        [ProducesResponseType(200)]
+        [ProducesResponseType(404)]
         public async Task<ActionResult<Piezometria>> GetPozo(uint id)
         {            
             var piezometria = await _context.Piezometria.FindAsync(id);
         // POST: api/Pozo
         // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
         [HttpPost]
+        [ProducesResponseType(200)]
+        [ProducesResponseType(409)]
         public async Task<ActionResult<Piezometria>> PostPiezometria(Piezometria piezometria)
         {
             Logger.WriteLog("Se procede a guardar piezometria");
                     throw;
                 }
             }
-
-
-            return CreatedAtAction("GetPiezometria", new { id = piezometria.Id }, piezometria);
+            
+            return Ok(piezometria);
+            //return CreatedAtAction("GetPiezometria", new { id = piezometria.Id }, piezometria);
         }
 
         // DELETE: api/Pozo/5
         [HttpDelete("{id}")]
+        [ProducesResponseType(404)]
+        [ProducesResponseType(204)]
         public async Task<IActionResult> DeletePiezometria(uint id)
         {
             var piezometria = await _context.Piezometria.FindAsync(id);
         }
 
         [NonAction]
-        public void getDimensions(uint idSimulacion, out int rows, out int cols)
+        public void GetDimensions(uint idSimulacion, out int rows, out int cols)
         {
             Piezometria piezometria = _context.Piezometria.Where(x => x.IdSimulacion == idSimulacion).FirstOrDefault();
             rows = piezometria.Rows;

WorkerService1/WebApplication3/Controllers/PozoController.cs

 
         // GET: api/Pozo
         [HttpGet]
-        public async Task<ActionResult<IEnumerable<Pozo>>> GetPozos()
+        
+        public async Task<ActionResult<IEnumerable<DatosPozoRecarga>>> GetPozos()
         {
-            return await _context.Pozos.ToListAsync();
+            var pozos = await _context.Pozos.ToListAsync();
+            List<DatosPozoRecarga> result = new();
+
+            foreach(Pozo p in pozos)
+            {
+                DatosPozoRecarga datosPozo = new DatosPozoRecarga();
+                datosPozo.Id = p.Id;
+                datosPozo.Nombre = p.Nombre;
+                datosPozo.Latitud = p.Latitud;
+                datosPozo.Longitud = p.Longitud;
+                datosPozo.Maximo = p.Maximo;
+                datosPozo.Minimo = p.Minimo;
+                datosPozo.Simulacion = p.IdSimulacion;
+                datosPozo.Ts = _tsPozoController.GetTsPozo(p.Id);
+                result.Add(datosPozo);
+            }
+
+            return result;
         }
 
         // GET: api/Pozo/5
         [HttpGet("{id}")]
+        [ProducesResponseType(200)]
+        [ProducesResponseType(404)]
         public async Task<ActionResult<DatosPozoRecarga>> GetPozo(uint id)
         {            
             var pozo = await _context.Pozos.FindAsync(id);
             return datosPozo;
         }
 
+        [HttpGet("Simulacion/{id}")]
+        public async Task<ActionResult<IEnumerable<DatosPozoRecarga>>> GetPozosFromSimulation(uint id)
+        {
+            var pozos = await _context.Pozos.Where(x => x.IdSimulacion == id).ToListAsync();
+
+            List<DatosPozoRecarga> result = new();
+
+            foreach (Pozo p in pozos)
+            {
+                DatosPozoRecarga datosPozo = new DatosPozoRecarga();
+                datosPozo.Id = p.Id;
+                datosPozo.Nombre = p.Nombre;
+                datosPozo.Latitud = p.Latitud;
+                datosPozo.Longitud = p.Longitud;
+                datosPozo.Maximo = p.Maximo;
+                datosPozo.Minimo = p.Minimo;
+                datosPozo.Simulacion = p.IdSimulacion;
+                datosPozo.Ts = _tsPozoController.GetTsPozo(p.Id);
+                result.Add(datosPozo);
+            }
+
+            return result;
+
+        }
+
         // PUT: api/Pozo/5
         // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
         [HttpPut("{id}")]
+        [ProducesResponseType(201)]
+        [ProducesResponseType(400)]
+        [ProducesResponseType(404)]
         public async Task<IActionResult> PutPozo(uint id, [FromBody] DatosPozoRecarga datos)
         {
             Pozo pozo = _context.Pozos.Find(id);
         // POST: api/Pozo
         // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
         [HttpPost]
+        [ProducesResponseType(201)]
+        [ProducesResponseType(409)]
         public async Task<ActionResult<Pozo>> PostPozo([FromBody] DatosPozoRecarga datos)
         {
             Pozo pozo = new Pozo();
 
         // DELETE: api/Pozo/5
         [HttpDelete("{id}")]
+        [ProducesResponseType(201)]
+        [ProducesResponseType(404)]
         public async Task<IActionResult> DeletePozo(uint id)
         {
             var pozo = await _context.Pozos.FindAsync(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)
+        public async Task<ActionResult<IEnumerable<Pozo>>> ParseoFichero(uint acuifero, string file,uint simId)
         {
             var s = acuifero;
             Parser wellParser = new Parser();
 
             foreach (WellData w in wells)
             {
-                Pozo pozo = w.ToPozo(acuifero);
+                Pozo pozo = w.ToPozo(acuifero, simId);
                 _context.Pozos.Add(pozo);
 
                 try
                         TsPozo tsPozo = new TsPozo();
                         tsPozo.IdPozo = pozo.Id;
                         tsPozo.MarcaTiempo = ts.Hora;
+                        tsPozo.MarcaTiempoEnd = ts.HoraEnd;
                         tsPozo.Valor = ts.Valor;
                         tsPozo.InfoComplementaria = ts.Info;
 
         }
 
         [NonAction]
-        public async Task<ActionResult<IEnumerable<Pozo>>> PostMultipleWells(uint aquiferId,WellData[] wellDatas)
+        public async Task<ActionResult<IEnumerable<Pozo>>> PostMultipleWells(uint aquiferId,WellData[] wellDatas, uint simulationId)
         {
             foreach (WellData w in wellDatas)
             {
-                Pozo pozo = w.ToPozo(aquiferId);
+                Pozo pozo = w.ToPozo(aquiferId, simulationId);
                 _context.Pozos.Add(pozo);
 
                 try
         public async void SetPozosSimulacion(uint? acuiferoId, uint? simulacionId)
         {
             //Obtenemos los pozos del acuifero
-            Pozo[] pozos = _context.Pozos.Where(x => x.IdAquifero == acuiferoId).ToArray<Pozo>();
+            Pozo[] pozos = _context.Pozos.Where(x => x.IdAquifero == acuiferoId && x.IdSimulacion == null).ToArray<Pozo>();
 
             foreach(Pozo p in pozos)
             {
                 _context.Pozos.Add(pozo);
             }
             await _context.SaveChangesAsync();
+
+
         }
 
         [NonAction]

WorkerService1/WebApplication3/Controllers/RecargasController.cs

 
         // GET: api/Recargas
         [HttpGet]
-        public async Task<ActionResult<IEnumerable<Recarga>>> GetRecargas()
+        public async Task<ActionResult<IEnumerable<DatosPozoRecarga>>> GetRecargas()
         {
-            return await _context.Recargas.ToListAsync();
+            var recargas =  await _context.Recargas.ToListAsync();
+            List<DatosPozoRecarga> result = new();
+
+            foreach(Recarga r in recargas)
+            {
+                DatosPozoRecarga datosRecarga = new();
+                datosRecarga.Id = r.Id;
+                datosRecarga.Nombre = r.Nombre;
+                datosRecarga.Latitud = r.Latitud;
+                datosRecarga.Longitud = r.Longitud;
+                datosRecarga.Simulacion = r.IdSimulacion;
+                datosRecarga.Ts = tsRecargaController.GetTsRecarga(r.Id);
+                result.Add(datosRecarga);
+            }
+
+            return result;
         }
 
         // GET: api/Recargas/5
         [HttpGet("{id}")]
+        [ProducesResponseType(200)]
+        [ProducesResponseType(404)]
         public async Task<ActionResult<DatosPozoRecarga>> GetRecarga(uint id)
         {
             var recarga = await _context.Recargas.FindAsync(id);
         }
 
         // PUT: api/Recargas/5
-        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
         [HttpPut("{id}")]
+        [ProducesResponseType(201)]
+        [ProducesResponseType(400)]
+        [ProducesResponseType(404)]
         public async Task<IActionResult> PutRecarga(uint id, [FromBody] DatosPozoRecarga datos)
         {
             Recarga recarga = _context.Recargas.Find(id);
         }
 
         // POST: api/Recargas
-        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
         [HttpPost]
+        [ProducesResponseType(201)]
+        [ProducesResponseType(409)]
         public async Task<ActionResult<Recarga>> PostRecarga([FromBody] DatosPozoRecarga datos)
         {
             Recarga recarga = new Recarga();
         [NonAction]
         public async void SetRecargasSimulacion(uint? acuiferoId, uint? simulacionId)
         {
-            Recarga[] recargas = _context.Recargas.Where(x => x.IdAcuifero == acuiferoId).ToArray<Recarga>();
+            Recarga[] recargas = _context.Recargas.Where(x => x.IdAcuifero == acuiferoId && x.IdSimulacion == null).ToArray<Recarga>();
 
             foreach (Recarga r in recargas)
             {
         }
 
         [NonAction]
-        public async Task<ActionResult<IEnumerable<Recarga>>> ParseoFichero(uint aquifer, string file)
+        public async Task<ActionResult<IEnumerable<Recarga>>> ParseoFichero(uint aquifer, string file, uint simId)
         {
             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);
+            await SetRechargeGeometry(aquifer, recharge_geometry);
+
+            string fileName = Utilities.String2Png(recharge_geometry);
+
+            Byte[] bytes = System.IO.File.ReadAllBytes(fileName);
+            String base64Image = Convert.ToBase64String(bytes);
+
+            await SetRechargeMapColor(aquifer, base64Image);
+
+            return await PostMultipleRecharges(aquifer,recharges,simId);
+        }
+
+        [NonAction]
+        public async Task<Acuifero> 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 null;
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return aquifer;
+        }
+
+        [NonAction]
+        public async Task<bool> SetRechargeMapColor(uint id, string base64)
+        {
+            Acuifero aquifer = _context.Acuiferos.Find(id);
+
+            aquifer.RechargeColorMap = base64;
+
+            _context.Entry(aquifer).State = EntityState.Modified;
+
+            try
+            {
+                await _context.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!AcuiferoExists(id))
+                {
+                    return false;
+                }
+                else
+                {
+                    throw;
+                }
+            }
+            return true;
+        }
+
+        private bool AcuiferoExists(uint id)
+        {
+            return _context.Acuiferos.Any(e => e.Id == id);
         }
 
         [NonAction]
-        public async Task<ActionResult<IEnumerable<Recarga>>> PostMultipleRecharges(uint aquifer, RechargeData[] recharges)
+        public async Task<ActionResult<IEnumerable<Recarga>>> PostMultipleRecharges(uint aquifer, RechargeData[] recharges, uint simId)
         {
             foreach (RechargeData r in recharges)
             {
-                Recarga recarga = r.ToRecarga(aquifer);
+                Recarga recarga = r.ToRecarga(aquifer,simId);
                 _context.Recargas.Add(recarga);
 
                 try
                         TsRecarga tsRecarga = new(); 
                         tsRecarga.IdRecarga = recarga.Id;
                         tsRecarga.MarcaTiempo = ts.Hora;
+                        tsRecarga.MarcaTiempoEnd = ts.HoraEnd;
                         tsRecarga.Valor = ts.Valor;
 
                         await tsRecargaController.PostTsRecarga(tsRecarga);

WorkerService1/WebApplication3/Controllers/ServiceQueueController.cs

 
 namespace WebApplication3.Controllers
 {
-    [Route("api/queue")]
-    [ApiController]
+    //[Route("api/queue")]
+    //[ApiController]
+    [ApiExplorerSettings(IgnoreApi = true)]
     public class ServiceQueueController : ControllerBase
     {
         private readonly AquiferContext _context;

WorkerService1/WebApplication3/Controllers/ServicioController.cs

 
 namespace WebApplication3.Controllers
 {
-    [Route("api/servicio")]
-    [ApiController]
+    //[Route("api/servicio")]
+    //[ApiController]
+    [ApiExplorerSettings(IgnoreApi = true)]
     public class ServicioController : ControllerBase
     {
         private readonly AquiferContext _context;
         }
 
         // 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;
-
-        }
+        //[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);
 
                 {
                     proceso.Start();
                     respuesta = "Id: " + proceso.GetPid();
-                    Servicio s = new Servicio();
+                    Servicio s = new ();
                     s.Id = GetLastId() + 1;
                     s.Pid = (uint)proceso.GetPid();
                     s.Terminado = 0;
         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.Start();
                     respuesta = "Id: " + proceso.GetPid();
-                    Servicio s = new Servicio();
+                    Servicio s = new ();
                     s.Id = GetLastId() + 1;
                     s.Pid = (uint)proceso.GetPid();
                     s.Terminado = 0;
         [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();
+            Servicio s = new ();
             s.Id = GetLastId() + 1;
             s.Pid = (uint)proceso.GetPid();
             s.Terminado = 0;
             return postServicio;
         }
 
+        [NonAction]
+        public async Task<ActionResult<Servicio>> GetGeoJsonFromSVG(string workingDirectory, string headFile)
+        {
+            Proceso proceso = Proceso.GetInstance();
+            proceso.ResetProcess();
+            proceso.SetParametersSVG2Json(workingDirectory, headFile);
+            proceso.Start();
+            Servicio s = new ();
+            s.Id = GetLastId() + 1;
+            s.Pid = (uint)proceso.GetPid();
+            s.Terminado = 0;
+            s.Inicio = DateTime.Now.ToString();
+            s.Tipo = "SVG2GEOJSON";
+            var postServicio = await PostServicio(s); ;
+            proceso.WaitForExit();
+            return postServicio;
+        }
+
         // GET: api/Servicio/stopped
         [HttpGet("stopped")]
         public bool HasStopped()
         [HttpGet("lastid")]
         public uint GetLastId()
         {
-            if(_context.Servicios.Count() == 0)
+            if(!_context.Servicios.Any())
             {
                 return 0;
             }
         }
 
         [NonAction]
-        public async Task<int> setTerminado(int pid)
+        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 servicio = _context.Servicios.Where(x => x.Pid == pid).OrderByDescending(x => x.Id).First(); ;
+            //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();
             {
                 result = await _context.SaveChangesAsync();
             }
-            catch (DbUpdateConcurrencyException)
+            catch (DbUpdateConcurrencyException ex)
             {
-                
+                Logger.WriteLog(ex.Message);
+                Logger.WriteLog(ex.InnerException.Message);
             }
 
             Logger.WriteLog("TERMINADO " + pid);

WorkerService1/WebApplication3/Controllers/SimulacionController.cs

     {
         
         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;
+        private readonly PozoController pozoController;
+        private readonly RecargasController recargasController;
+        private readonly AcuiferoController acuiferoController;
+        private readonly ServicioController serviceController;
+        private readonly BalanceHidricoController balanceHidricoController;
+        private readonly PiezometriaController piezometriaController;
+        private readonly ServiceQueueController serviceQueueController;
 
         public SimulacionController(AquiferContext context)
         {
 
         // GET: api/Simulacion/5
         [HttpGet("{id}")]
+        [ProducesResponseType(200)]
+        [ProducesResponseType(404)]
         public async Task<ActionResult<Simulacion>> GetSimulacion(uint id)
         {
             var simulacion = await _context.Simulaciones.FindAsync(id);
         // POST: api/Simulacion
         // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754
         [HttpPost]
+        [ProducesResponseType(201)]
         public async Task<ActionResult<Simulacion>> PostSimulacion(Simulacion simulacion)
         {
             _context.Simulaciones.Add(simulacion);
         }
 
         [HttpPost("Simula/{simulacionId}")]
+        [ProducesResponseType(200)]
+
         public async Task<bool> QueueSim(uint simulacionId)
         {
             Simulacion simulacion = _context.Simulaciones.Find(simulacionId);
 
-            ServiceQueue serviceQueue = new ServiceQueue();
+            ServiceQueue serviceQueue = new ();
             serviceQueue.IdSimulacion = simulacionId;
             serviceQueue.IdAcuifero = simulacion.IdAcuifero;
 
             return true;
         }
 
-        [HttpPut("UpdateSimWellData")]
+        [HttpPut("{simulationId}/UpdateSimWellData")]
+        [ProducesResponseType(200)]
+
         public async Task<ActionResult<bool>> UpdateSimWellsFromCsv(uint simulationId, [FromBody] DatosPostSimulacion data)
         {
             bool result = true;
 
             WellData[] wellDatas = parser.parseWellCSV(file);
 
-            await pozoController.PostMultipleWells((uint)sim.IdAcuifero,wellDatas);
+            await pozoController.PostMultipleWells((uint)sim.IdAcuifero,wellDatas, simulationId);
 
             return result;
         }
 
-        [HttpPut]
+        [HttpPut("{simulationId}/UpdateRechargeWellData")]
+        [ProducesResponseType(200)]
+
         public async Task<ActionResult<bool>> UpdateSimRechargesFromCsv(uint simulationId, [FromBody] DatosPostSimulacion data)
         {
             bool result = true;
             RechargeData[] rechargeDatas = parser.parseRechargeCSV(file);
 
             
-            await recargasController.PostMultipleRecharges((uint)sim.IdAcuifero, rechargeDatas);
+            await recargasController.PostMultipleRecharges((uint)sim.IdAcuifero, rechargeDatas,sim.Id);
 
             return result;
         }
 
         // PUT: api/Simulacion/5
-        // To protect from overposting attacks, see https://go.microsoft.com/fwlink/?linkid=2123754s
         [HttpPut("{id}")]
+        [ProducesResponseType(201)]
+        [ProducesResponseType(400)]
+        [ProducesResponseType(404)]
+
         public async Task<IActionResult> PutSimulacion(uint id, [FromBody] DatosPostSimulacion datos)
         {
             Simulacion simulacion = _context.Simulaciones.Find(id);
 
         // DELETE: api/Simulacion/5
         [HttpDelete("{id}")]
+        [ProducesResponseType(209)]
         public async Task<IActionResult> DeleteSimulacion(uint id)
         {
             var simulacion = await _context.Simulaciones.FindAsync(id);
         [NonAction]
         public async Task<bool> SimulaAsync(ServiceQueue serviceQueue)
         {
-            Logger logger = Logger.GetInstance();
             await serviceQueueController.SetCorriendo(serviceQueue.Id);
 
             uint simulacionId = (uint)serviceQueue.IdSimulacion;
             Logger.WriteLog("estoy simulando");
             if (zip != string.Empty)
             {
-                Parser parser = new Parser();
-                string zip_name = "simulaicion" + simulacion.Nombre;
+                Parser parser = new ();
+                string zip_name = "simulacion" + simulacion.Nombre;
                 string zip_copy = zip_name + ".zip";
                 System.IO.File.Copy(Constants.PathZip + zip, Constants.PathZip + zip_copy, true);
 
                 Directory.CreateDirectory(workingDirectory);
                 ZipFile.ExtractToDirectory(Constants.PathZip + zip_copy, workingDirectory, true);
 
+                workingDirectory += zip.Replace(".zip", "\\");
                 //Obtenemos fichero de pozo y recargas
                 List<string> files = Directory.GetFiles(workingDirectory).ToList<string>();
 
                 string inFile = files.Find(x => x.Contains(".MODFLOW.IN") || x.Contains(".modflow.in"));
                 string zoneFile = files.Find(x => x.Contains(".ZBI") || x.Contains(".zbi"));
 
+                Logger.WriteLog("ficheros clave buscados");
+
                 //3- Parseamos pozos
                 if (System.IO.File.Exists(pozoFile))
                 {
+                    Logger.WriteLog("vamos con los pozos");
                     List<WellData> infoPozosFichero = parser.ParseWellData(pozoFile).ToList<WellData>();
                     List<Pozo> pozos = pozoController.GetPozosSimulacion(simulacionId);
-                    List<string> lines = new List<string>();
+                    List<string> lines = new();
+
 
                     //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.X.ToString());
+                        lines.Add(p.Y.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(infoPozosFichero[0].Top);
                         lines.Add(timeSeriesPozo.Count.ToString());
 
-                        for (int i = 0; i < timeSeriesPozo.Count - 1; i++)
+                        for (int i = 0; i < timeSeriesPozo.Count; i++)
                         {
                             lines.Add(timeSeriesPozo[i].MarcaTiempo);
-                            lines.Add(timeSeriesPozo[i + 1].MarcaTiempo);
-                            lines.Add(timeSeriesPozo[i].Valor.ToString() + " " + timeSeriesPozo[i].InfoComplementaria);
+                            lines.Add(timeSeriesPozo[i].MarcaTiempoEnd);
+                            lines.Add(timeSeriesPozo[i].Valor + " " + timeSeriesPozo[i].InfoComplementaria);
                         }
                     }
 
                     //System.IO.File.WriteAllLines(@"C:\Users\Admin\Desktop\Test.VMW", lines);
                     System.IO.File.WriteAllLines(pozoFile, lines);
-
+                    Logger.WriteLog("pozos terminados");
                 }
 
 
                 //4- Parseamos recargas
                 if (System.IO.File.Exists(recargaFile))
                 {
+                    Logger.WriteLog("vamos con recargas");
                     List<Recarga> recargas = recargasController.GetRecargasSimulacion(simulacionId);
 
                     string text = System.IO.File.ReadAllText(recargaFile);
                     int rechargeBlockInex = blankLinePerBlock * 2;
 
 
-                    List<string> lines = new List<string>();
+                    List<string> lines = new();
 
                     //Hasta el bloque de recargas vamos poniendo el texto que le precede
                     for (int i = 0; i < rechargeBlockInex; i++)
                     {
                         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(tsRecarga.Count + " rchr entries");
+                        tsRecarga.ForEach(x =>
+                            lines.Add(index + " " + x.Valor + "               " + x.MarcaTiempo + "               " + x.MarcaTiempoEnd + " " + x.InfoComplementaria)
+                        );
+                        //lines.Add(index + " " + tsRecarga[0].Valor + "               " + tsRecarga[0].MarcaTiempo + "               " + tsRecarga[1].MarcaTiempo + " " + tsRecarga[0].InfoComplementaria);
 
                     }
                     lines.Add("");
                 //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))
                 {
+                    Logger.WriteLog("tratamos el fichero .IN");
                     List<string> inFileLines = parser.ParseInFile(inFile);
                     System.IO.File.WriteAllLines(inFile, inFileLines);
                 }
 
                         uint balanceDataInId = dataIn.Value;
 
-                        List<ConexionZonasIn> conexionZonasIns = new List<ConexionZonasIn>();
+                        List<ConexionZonasIn> conexionZonasIns = new();
 
                         zone.In.ZoneConnections.ForEach(x => conexionZonasIns.Add(x.ToConexionIn(balanceDataInId)));
 
                         var dataOut = await balanceHidricoController.PostBalanceOut(zone.Out.ToDatosBalanceOut(balanceId));
                         uint balanceDataOutId = dataOut.Value;
 
-                        List<ConexionZonasOut> conexionZonasOuts = new List<ConexionZonasOut>();
+                        List<ConexionZonasOut> conexionZonasOuts = new();
 
                         zone.Out.ZoneConnections.ForEach(x => conexionZonasOuts.Add(x.ToConexionOut(balanceDataOutId)));
 
                 {
                     Logger.WriteLog("inicio balance modelo entero");
                     ZoneBalance[] modelBalance = parser.ParseWholeModelBalance(modelResultsFile);
-
+                    Logger.WriteLog("este es el lenght del balance entero " + modelBalance.Length);
                     //insertamos en bbdd
-                    foreach (ZoneBalance zone in modelBalance)
+                    try
                     {
-                        var result = await balanceHidricoController.PostBalance(zone.ToBalanceHidrico(simulacionId));
-                        uint balanceId = result.Value;
+                        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));
+                            await balanceHidricoController.PostBalanceIn(zone.In.ToDatosBalanceIn(balanceId));
+                            await balanceHidricoController.PostBalanceOut(zone.Out.ToDatosBalanceOut(balanceId));
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Logger.WriteLog(ex.Message);
+                        Logger.WriteLog(ex.InnerException.Message);
+                        throw;
                     }
                     Logger.WriteLog("fin balance modelo entero");
                 }
                     }
                     Logger.WriteLog("fin piezometria");
                 }
-                piezometriaController.getDimensions(simulacionId, out int rows, out int cols);
+                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");
+                Logger.WriteLog("ya tengo la imagen de isolineas");
+                Logger.WriteLog(workingDirectory + Constants.SVGFileName);
+                Byte[] bytes = System.IO.File.ReadAllBytes(workingDirectory + Constants.SVGFileName);
                 String base64Image = Convert.ToBase64String(bytes);
 
-
+                Logger.WriteLog("guardo imagen de isolineas");
+                Logger.WriteLog(base64Image);
                 await SetIsolinesImage(simulacionId, base64Image);
-
-
+                Logger.WriteLog("ya esta guardada");
+                /*
+                 * se transforma la imagen vectorial obtenida anteriormente para transformarla en un geojson
+                 */
+                string svgFile = workingDirectory + Constants.SVGFileName;
+                await serviceController.GetGeoJsonFromSVG(workingDirectory, svgFile);
+
+                await SetGeoJson(simulacionId, workingDirectory+Constants.GeoJsonFileName);
+                
                 await serviceQueueController.SetTerminado(serviceQueue.Id);
                 Logger.WriteLog("terminado");
+                try
+                {
+                    System.IO.Directory.Delete(workingDirectory);
+                }catch(Exception ex)
+                {
+                    Logger.WriteLog(ex.Message);
+                    Logger.WriteLog(ex.InnerException.Message);
+                }
             }
             return true;
         }
 
+            
+        [HttpGet("Geojson/{id}")]
+        [ProducesResponseType(200)]
 
-        [HttpGet("Geojson")]
-        public GeoJson GetGeoJson()
+        public async Task<GeoJson> GetGeoJson(uint id)
         {
-            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);
+            Simulacion s = await _context.Simulaciones.FindAsync(id);
+            GeoJson jsonObject = JsonConvert.DeserializeObject<GeoJson>(s.Geojson);
             return jsonObject;
         }
+
+
         private bool SimulacionExists(uint id)
         {
             return _context.Simulaciones.Any(e => e.Id == id);
         }
 
-        private async Task<IActionResult> SetIsolinesImage(uint simulacionId, string imageBase64)
+        private async Task<IActionResult> SetGeoJson(uint simulationId, string geojsonFile)
         {
-            var simulacion = _context.Simulaciones.Find(simulacionId);
+            string allText = System.IO.File.ReadAllText(geojsonFile);
+            allText = allText.Replace("[[[","[[");
+            allText = allText.Replace("]]]", "]]");
 
-            if (simulacionId != simulacion.Id)
+            var simulation = _context.Simulaciones.Find(simulationId);
+
+            if (simulationId!= simulation.Id)
             {
                 return BadRequest();
             }
 
 
-            simulacion.IsolineImage = imageBase64;
+            simulation.Geojson = allText;
 
-            _context.Entry(simulacion).State = EntityState.Modified;
+            _context.Entry(simulation).State = EntityState.Modified;
 
             try
             {
             }
             catch (DbUpdateConcurrencyException)
             {
-                if (!SimulacionExists(simulacionId))
+                if (!SimulacionExists(simulationId))
                 {
                     return NotFound();
                 }
                 }
             }
 
-            return CreatedAtAction("GetSimulacion", new { id = simulacion.Id }, simulacion);
+            return CreatedAtAction("GetSimulacion", new { id = simulation.Id }, simulation);
+
         }
 
-        /*
-         * TEST ENDPOINTS
-         */
-        [HttpPost("Simula/Python/{simulacionId}")]
-        public async Task<bool> SimIsolinesWithPython(uint simulacionId)
+        private async Task<IActionResult> SetIsolinesImage(uint simulacionId, string imageBase64)
         {
-            string workingDirectory = @"C:\Users\Admin\Desktop\TestExtract\simulaicionsimulacion_test\";
-            string headFile = @"C:\Users\Admin\Desktop\TestExtract\simulaicionsimulacion_test\EJEMPLO_SOTIEL.HDS";
+            Simulacion simulacion = _context.Simulaciones.Find(simulacionId);
+            Logger.WriteLog("sim "+simulacion.Id);
+            if (simulacionId != simulacion.Id)
+            {
+                return BadRequest();
+            }
 
-            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)
+            simulacion.IsolineImage = imageBase64;
+            Logger.WriteLog(imageBase64);
+
+            _context.Entry(simulacion).State = EntityState.Modified;
+
+            try
+            {
+                await _context.SaveChangesAsync();
+            }
+            catch (Exception ex)
             {
-                await piezometriaController.PostPiezometria(p);
+                if (!SimulacionExists(simulacionId))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    Logger.WriteLog(ex.Message);
+                    Logger.WriteLog(ex.InnerException.Message);
+                    throw;
+                }
             }
-            Logger.WriteLog("fin piezometria");
-            return await GetSimulaciones();
+            Logger.WriteLog("OKIDOKI ISO SAVED");
+            return CreatedAtAction("GetSimulacion", new { id = simulacion.Id }, simulacion);
         }
     }
 }

WorkerService1/WebApplication3/Controllers/TsPiezometerController.cs

 
 namespace WebApplication3.Controllers
 {
-    [Route("api/[controller]")]
-    [ApiController]
+    //[Route("api/[controller]")]
+    //[ApiController]
+    [ApiExplorerSettings(IgnoreApi = true)]
     public class TsPiezometerController: ControllerBase
     {
         private readonly AquiferContext _context;
             //var tsPozo = await _context.TsPozos.FindAsync(id);
             var tsPiezometers = _context.TsPiezometers.Where(x => x.PiezometerId == id);
 
-            List<TimeSerie> timeSeries = new List<TimeSerie>();
+            List<TimeSerie> timeSeries = new ();
             TimeSerie timeSerie = null;
 
             if (tsPiezometers == null)
 
             foreach(TsPiezometer tsp in tsPiezometers)
             {
-                timeSerie = new TimeSerie();
+                timeSerie = new ();
                 timeSerie.Hora = tsp.Day;
                 timeSerie.Valor = tsp.Quote;
                 timeSeries.Add(timeSerie);

WorkerService1/WebApplication3/Controllers/TsPozoController.cs

 
 namespace WebApplication3.Controllers
 {
-    [Route("api/[controller]")]
-    [ApiController]
+    //[Route("api/[controller]")]
+    //[ApiController]
+    [ApiExplorerSettings(IgnoreApi = true)]
     public class TsPozoController : ControllerBase
     {
         private readonly AquiferContext _context;

WorkerService1/WebApplication3/Controllers/TsRecargaController.cs

 
 namespace WebApplication3.Controllers
 {
-    [Route("api/[controller]")]
-    [ApiController]
+    //[Route("api/[controller]")]
+    //[ApiController]
+    [ApiExplorerSettings(IgnoreApi = true)]
     public class TsRecargaController : ControllerBase
     {
         private readonly AquiferContext _context;

WorkerService1/WebApplication3/Models/Acuifero.cs

         public string WorldOriginX { get; set; }
         public string WorldOriginY { get; set; }
         public string RechargeGeometry { get; set; }
+        public string RechargeColorMap { get; set; }
+
     }
 }

WorkerService1/WebApplication3/Models/AquiferContext.cs

                 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.Property(e => e.RechargeColorMap).HasColumnName("recharge_color_map");
+
 
 
 
                     .HasMaxLength(255)
                     .HasColumnName("isoline_image");
 
+                entity.Property(e => e.Geojson)
+                    .HasMaxLength(255)
+                    .HasColumnName("geojson");
+
+                entity.Property(e => e.SimulacionAcuifero)
+                    .HasColumnType("int(10) unsigned")
+                    .HasColumnName("simulacion_acuifero")
+                    .HasDefaultValueSql("0");
+
                 entity.HasKey(e => e.Id)
                 .HasName("id");
             });
                 entity.Property(e => e.Recharge).HasColumnName("recharge");
 
                 entity.Property(e => e.Drains).HasColumnName("drains");
+                entity.Property(e => e.Wells).HasColumnName("wells");
+
 
                 entity.Property(e => e.ConstantHead).HasColumnName("constant_head");
 
                 entity.Property(e => e.Recharge).HasColumnName("recharge");
 
                 entity.Property(e => e.Drains).HasColumnName("drains");
+                entity.Property(e => e.Wells).HasColumnName("wells");
 
                 entity.Property(e => e.ConstantHead).HasColumnName("constant_head");
 

WorkerService1/WebApplication3/Models/DatosBalanceIn.cs

         public string Storage { get; set; }
         public string ConstantHead { get; set; }
         public string Drains { get; set; }
+        public string Wells { get; set; }
         public string Recharge { get; set; }
         public string Total { get; set; }
 

WorkerService1/WebApplication3/Models/DatosBalanceOut.cs

         public string Storage { get; set; }
         public string ConstantHead { get; set; }
         public string Drains { get; set; }
+        public string Wells { get; set; }
         public string Recharge { get; set; }
         public string Total { get; set; }
 

WorkerService1/WebApplication3/Models/Piezometer.cs

+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

         public string Prof { get; set; }
         public string ScreenTop { get; set; }
         public string ScreenBot { get; set; }
+        public uint Active { get; set; }
 
         public Pozo Copy(uint? idSimulacion)
         {
             pozo.Maximo = this.Maximo;
             pozo.Minimo = this.Minimo;
             pozo.Nombre = this.Nombre;
+            pozo.Active = this.Active;
             return pozo;
         }
     }

WorkerService1/WebApplication3/Models/Simulacion.cs

         public uint? IdAcuifero { get; set; }
         public string Nombre { get; set; }
         public string IsolineImage { get; set; }
+        public string Geojson { get; set; }
+        public uint SimulacionAcuifero { get; set; }
     }
 }

WorkerService1/WebApplication3/Models/TSPozo.cs

             tsPozo.IdPozo = pozoId;
             tsPozo.Valor = this.Valor;
             tsPozo.MarcaTiempo = this.MarcaTiempo;
+            tsPozo.MarcaTiempoEnd = this.MarcaTiempoEnd;
             tsPozo.InfoComplementaria = this.InfoComplementaria;
 
             return tsPozo;