AquiferSupervision/WorkerService1/WebApplication3/Controllers/ServicioController.cs

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


namespace WebApplication3.Controllers
{
    [Route("api/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;

        }
    }
}