maat/Maat.Data/Controllers/MsSqlController.cs

using Maat.Data.DbModels;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using NLog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Maat.Core.Enums;

namespace Maat.Data.Controllers
{
    public class MsSqlController : IDisposable
    {
        #region Public Constructors

        /// <summary>
        /// Avvio Controller ThreadRun x DB
        /// </summary>
        /// <param name="threadName">nome del thread di esecuzione</param>
        /// <param name="cString">stringa di connessione da impiegare</param>
        public MsSqlController(string threadName, string cString)
        {
            tName = threadName;
            connString = cString;
            Log.Info($"{tName} | Avviata classe MsSqlController");
        }

        #endregion Public Constructors

        #region Public Methods

        public DateTime CalcNextExe(TaskListModel taskRec)
        {
            DateTime dtNext = DateTime.Today;
            try
            {
                // calcolo next exec da tipo...
                switch (taskRec.Freq)
                {
                    case TaskFreqType.ND:
                        dtNext = taskRec.DtLastExec.AddDays(taskRec.Cad);
                        break;

                    case TaskFreqType.Sec:
                        dtNext = taskRec.DtLastExec.AddSeconds(taskRec.Cad);
                        break;

                    case TaskFreqType.Min:
                        dtNext = taskRec.DtLastExec.AddMinutes(taskRec.Cad);
                        break;

                    case TaskFreqType.Hour:
                        dtNext = taskRec.DtLastExec.AddHours(taskRec.Cad);
                        break;

                    case TaskFreqType.Day:
                        dtNext = taskRec.DtLastExec.AddDays(taskRec.Cad);
                        break;

                    case TaskFreqType.Week:
                        dtNext = taskRec.DtLastExec.AddDays(7 * taskRec.Cad);
                        break;

                    case TaskFreqType.Month:
                        dtNext = taskRec.DtLastExec.AddMonths(taskRec.Cad);
                        break;

                    case TaskFreqType.Year:
                        dtNext = taskRec.DtLastExec.AddYears(taskRec.Cad);
                        break;

                    default:
                        dtNext = taskRec.DtLastExec.AddDays(taskRec.Cad);
                        break;
                }
            }
            catch (Exception exc)
            {
                Log.Error($"{tName} | Eccezione in CalcNextExe{Environment.NewLine}{exc}");
            }
            return dtNext;
        }

        public void Dispose()
        {
        }

        /// <summary>
        /// Chiamata esecuzione di un singolo task programmato
        /// </summary>
        /// <param name="TaskId"></param>
        /// <param name="SchedNext">Se true rischedula successiva chiamata</param>
        /// <returns></returns>
        public TaskResultModel ExecuteSqlTask(int TaskId, bool SchedNext)
        {
            TaskResultModel callRes = new TaskResultModel();
            using (var dbCtx = new TaskRunContext(connString))
            {
                // imposto timeout a 5 min
                dbCtx.Database.SetCommandTimeout(TimeSpan.FromMinutes(5));
                try
                {
                    DateTime dtStart = DateTime.Now;
                    // recupero i dati da richiamare...
                    var currRec = dbCtx
                                .DbSetTaskList
                                .Where(x => x.TaskId == TaskId)
                                .FirstOrDefault();
                    if (currRec != null)
                    {
                        // recupero comando
                        string sqlCommand = currRec.Command;
                        string rawParams = currRec.Args;
                        var rawData = dbCtx
                                    .DbSetTaskResult
                                    .FromSqlRaw($"EXEC {sqlCommand} {rawParams}")
                                    .AsNoTracking()
                                    .AsEnumerable()
                                    .FirstOrDefault();
                        callRes = rawData ?? new TaskResultModel();
                        DateTime dtEnd = DateTime.Now;

                        // preparo record esecuzione...
                        TaskExecModel resRec = new TaskExecModel()
                        {
                            TaskId = TaskId,
                            DtStart = dtStart,
                            DtEnd = dtEnd,
                            IsError = callRes.ExecResult < 0,
                            Result = callRes.TextResult
                        };
                        dbCtx
                            .DbSetTaskExe
                            .Add(resRec);

                        // aggiorno record chiamata...
                        currRec.DtLastExec = dtStart;
                        currRec.LastResult = resRec.Result;
                        currRec.LastIsError = resRec.IsError;
                        currRec.LastDuration = dtEnd.Subtract(dtStart).TotalSeconds;
                        // solo se richiesto rischedulazione ricalcola chiamata
                        if (SchedNext)
                        {
                            // calcolo prossima esecuzione...
                            currRec.DtNextExec = CalcNextExe(currRec);
                        }
                        // segno modificato
                        dbCtx.Entry(currRec).State = EntityState.Modified;

                        // salvo modifiche!
                        dbCtx.SaveChanges();
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"{tName} | Eccezione in ExecuteSqlTask{Environment.NewLine}{exc}");
                }
            }
            return callRes;
        }

        /// <summary>
        /// Esegue registrazione di un Task generico (NON SQL)
        /// </summary>
        /// <param name="TaskId"></param>
        /// <param name="SchedNext">Se true rischedula successiva chiamata</param>
        /// <param name="ResRec">Record esecuzione task esterno</param>
        /// <returns></returns>
        public TaskResultModel TaskExecSaveExecuted(int TaskId, bool SchedNext, TaskExecModel ResRec)
        {
            TaskResultModel callRes = new TaskResultModel();
            using (var dbCtx = new TaskRunContext(connString))
            {
                try
                {
                    // recupero i dati da richiamare...
                    var currRec = dbCtx
                                .DbSetTaskList
                                .Where(x => x.TaskId == TaskId)
                                .FirstOrDefault();
                    if (currRec != null)
                    {
                        // registro task ricevuto
                        dbCtx
                            .DbSetTaskExe
                            .Add(ResRec);

                        // aggiorno record chiamata...
                        currRec.DtLastExec = ResRec.DtStart;
                        currRec.LastResult = ResRec.Result;
                        currRec.LastIsError = ResRec.IsError;
                        currRec.LastDuration = ResRec.DtEnd.Subtract(ResRec.DtStart).TotalSeconds;
                        // solo se richiesto rischedulazione ricalcola chiamata
                        if (SchedNext)
                        {
                            // calcolo prossima esecuzione...
                            currRec.DtNextExec = CalcNextExe(currRec);
                        }
                        // segno modificato
                        dbCtx.Entry(currRec).State = EntityState.Modified;

                        // salvo modifiche!
                        dbCtx.SaveChanges();
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in TaskExecSaveExecuted{Environment.NewLine}{exc}");
                }
            }
            return callRes;
        }

        /// <summary>
        /// Ricerca task dato tipo e
        /// </summary>
        /// <param name="TType"></param>
        /// <returns></returns>
        public List<TaskListModel> TaskListGetAll(Task2ExeType TType)
        {
            List<TaskListModel> dbResult = new List<TaskListModel>();
            using (var dbCtx = new TaskRunContext(connString))
            {
                dbResult = dbCtx
                    .DbSetTaskList
                    .Where(x => (TType == Task2ExeType.ND || x.TType == TType))
                    .OrderBy(x => x.Ordinal)
                    .ToList();
            }
            return dbResult;
        }

        #endregion Public Methods

        #region Private Fields

        private static Logger Log = LogManager.GetCurrentClassLogger();
        private string connString = "";
        private string tName = "";

        #endregion Private Fields
    }
}