mapo-core/MP.Data/Repository/Anag/AnagRepository.cs

using Microsoft.Data.SqlClient;
using Microsoft.EntityFrameworkCore;
using MP.Core.DTO;
using MP.Data.DbModels;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Threading.Tasks;

namespace MP.Data.Repository.Anag
{
    public class AnagRepository : BaseRepository, IAnagRepository
    {
        #region Public Constructors

        public AnagRepository(IDbContextFactory<MoonProContext> ctxFactory) : base(ctxFactory)
        {
        }

        #endregion Public Constructors

        #region Public Methods

        /// <inheritdoc />
        public async Task<AnagCountersModel> AnagCountersGetNextAsync(string cntType)
        {
            AnagCountersModel answ = new AnagCountersModel();
            await using var dbCtx = await CreateContextAsync();
            bool outTable = true;
            if (outTable)
            {
                var pCntType = new SqlParameter("@CntType", cntType);
                var pLastNum = new SqlParameter
                {
                    ParameterName = "@LastNum",
                    SqlDbType = SqlDbType.Int,
                    Direction = ParameterDirection.Output
                };

                var dbResult = await dbCtx
                                    .DbSetAnagCount
                                    .FromSqlRaw("EXEC dbo.stp_getNextNumb @CntType, @LastNum OUTPUT", pCntType, pLastNum)
                                    .AsNoTracking()
                                    .FirstOrDefaultAsync();
                if (dbResult != null)
                {
                    answ = dbResult;
                }
            }
            else
            {
                // se si volessero impiegare parametri OUTPUT (qui ne mancherebbe 1 nella stored x CntCode...)
                var pCntType = new SqlParameter("@CntType", cntType);
                var pLastNum = new SqlParameter
                {
                    ParameterName = "@LastNum",
                    SqlDbType = SqlDbType.Int,
                    Direction = ParameterDirection.Output
                };
                var pCntCode = new SqlParameter
                {
                    ParameterName = "@CntCode",
                    SqlDbType = SqlDbType.NVarChar,
                    Direction = ParameterDirection.Output
                };
                var dbResult = await dbCtx
                                    .Database
                                    .ExecuteSqlRawAsync("EXEC dbo.stp_getNextNumb @CntType, @LastNum OUTPUT, @CntCode OUTPUT", pCntType, pLastNum, pCntCode);
                if (dbResult != 0)
                {
                    answ.CntType = cntType;
                    answ.CntCode = $"{pCntCode.Value}";
                    int lNum = 0;
                    int.TryParse($"{pLastNum.Value}", out lNum);
                    answ.LastNum = lNum;
                }
            }
            return answ;
        }

        /// <inheritdoc />
        public async Task<List<vSelEventiBCodeModel>> AnagEventiGeneralAsync(string TableName = "EvList", string FieldName = "Common")
        {
            await using var dbCtx = await CreateContextAsync();
            var pTableName = new SqlParameter("@TableName", TableName);
            var pFieldName = new SqlParameter("@FieldName", FieldName);
            var dbResult = await dbCtx
                          .DbSetVSEB
                          .FromSqlRaw("exec dbo.stp_vseb_getGenerallyAvailable @TableName, @FieldName", pTableName, pFieldName)
                          .AsNoTracking()
                          .ToListAsync();
            return dbResult ?? new();
        }

        /// <inheritdoc />
        public async Task<List<AnagGruppiModel>> AnagGruppiAziendeAsync()
        {
            return await AnagGruppiGetTipoAsync("AZIENDA");
        }

        /// <inheritdoc />
        public async Task<bool> AnagGruppiDeleteAsync(AnagGruppiModel updRec)
        {
            await using var dbCtx = await CreateContextAsync();
            var dbRec = await dbCtx
                                .DbSetAnagGruppi
                                .AsNoTracking()
                                .Where(x => x.CodGruppo == updRec.CodGruppo)
                                .FirstOrDefaultAsync();
            if (dbRec != null)
            {
                dbCtx.DbSetAnagGruppi.Remove(dbRec);
            }
            var numRes = await dbCtx.SaveChangesAsync();
            return numRes != 0;
        }

        /// <inheritdoc />
        public async Task<List<AnagGruppiModel>> AnagGruppiFaseAsync()
        {
            return await AnagGruppiGetTipoAsync("FASE");
        }

        /// <inheritdoc />
        public async Task<List<AnagGruppiModel>> AnagGruppiGetTipoAsync(string tipoGruppo)
        {
            await using var dbCtx = await CreateContextAsync();
            return await dbCtx
                            .DbSetAnagGruppi
                            .Where(x => x.TipoGruppo == tipoGruppo)
                            .AsNoTracking()
                            .OrderBy(x => x.CodGruppo)
                            .ToListAsync();
        }

        /// <inheritdoc />
        public async Task<List<RepartiDTO>> AnagGruppiRepartoDtoAsync()
        {
            await using var dbCtx = await CreateContextAsync();
            var listReparti = await AnagGruppiGetTipoAsync("REPARTO");

            var listMacc = await dbCtx
                                .DbSetGrp2Macc
                                .AsNoTracking()
                                .ToListAsync();
            var listOpr = await dbCtx
                                .DbSetGrp2Oper
                                .AsNoTracking()
                                .ToListAsync();

            return listReparti
                        .Select(x => new RepartiDTO()
                        {
                            CodGruppo = x.CodGruppo,
                            TipoGruppo = x.TipoGruppo,
                            DescrGruppo = x.DescrGruppo,
                            SelEnabled = x.SelEnabled,
                            CountMacc = listMacc.Where(y => y.CodGruppo == x.CodGruppo).Select(y => y.IdxMacchina).Distinct().Count(),
                            CountOpr = listOpr.Where(y => y.CodGruppo == x.CodGruppo).Select(y => y.MatrOpr).Distinct().Count()
                        })
                        .ToList();
        }

        /// <inheritdoc />
        public async Task<bool> AnagGruppiUpsertAsync(AnagGruppiModel updRec)
        {
            await using var dbCtx = await CreateContextAsync();
            var dbRec = await dbCtx
                                .DbSetAnagGruppi
                                .AsNoTracking()
                                .Where(x => x.CodGruppo == updRec.CodGruppo)
                                .FirstOrDefaultAsync();
            if (dbRec != null)
            {
                dbRec.DescrGruppo = updRec.DescrGruppo;
                dbCtx.Entry(dbRec).State = EntityState.Modified;
            }
            else
            {
                await dbCtx.DbSetAnagGruppi.AddAsync(updRec);
            }
            var numRes = await dbCtx.SaveChangesAsync();
            return numRes != 0;
        }

        /// <inheritdoc />
        public async Task<List<ListValuesModel>> AnagStatiCommAsync()
        {
            return await ListValuesFiltAsync("PODL", "StatoComm");
        }

        /// <inheritdoc />
        public async Task<List<ListValuesModel>> AnagTipoArtLvAsync()
        {
            return await ListValuesFiltAsync("AnagArticoli", "Tipo");
        }

        /// <inheritdoc />
        public async Task<int> ArticoliCountAsync()
        {
            await using var dbCtx = await CreateContextAsync();
            return await dbCtx.DbSetArticoli.CountAsync();
        }

        /// <inheritdoc />
        public async Task<int> ArticoliCountSearchAsync(string tipoArt = "*", string azienda = "*", string searchVal = "")
        {
            await using var dbCtx = await CreateContextAsync();
            IQueryable<AnagArticoliModel> query = dbCtx.DbSetArticoli.AsNoTracking();

            if (tipoArt != "*")
            {
                query = query.Where(x => EF.Functions.Like(x.Tipo, tipoArt));
            }
            if (azienda != "*")
            {
                query = query.Where(x => EF.Functions.Like(x.Azienda, azienda));
            }
            if (!string.IsNullOrWhiteSpace(searchVal))
            {
                string pattern = $"%{searchVal}%";
                query = query.Where(x =>
                    EF.Functions.Like(x.CodArticolo, pattern) ||
                    EF.Functions.Like(x.DescArticolo, pattern) ||
                    EF.Functions.Like(x.Disegno, pattern));
            }

            return await query.OrderBy(x => x.CodArticolo).CountAsync();
        }

        /// <inheritdoc />
        public async Task<int> ArticoliCountUsedAsync()
        {
            await using var dbCtx = await CreateContextAsync();
            var result = await dbCtx
                                   .DbSetCounter
                                   .FromSqlRaw("EXEC stp_ART_CountUsed")
                                   .AsNoTracking()
                                   .ToListAsync();

            return result.FirstOrDefault()?.NumCount ?? 0;
        }

        /// <inheritdoc />
        public async Task<bool> ArticoliDeleteRecordAsync(AnagArticoliModel currRec)
        {
            await using var dbCtx = await CreateContextAsync();
            var currVal = await dbCtx
                            .DbSetArticoli
                            .Where(x => x.CodArticolo == currRec.CodArticolo)
                            .FirstOrDefaultAsync();
            if (currVal != null)
            {
                dbCtx.DbSetArticoli.Remove(currVal);
                return await dbCtx.SaveChangesAsync() > 0;
            }
            return false;
        }

        /// <inheritdoc />
        public async Task<List<AnagArticoliModel>> ArticoliGetByTipoAsync(string tipo, string azienda = "*")
        {
            await using var dbCtx = await CreateContextAsync();
            return await dbCtx
                            .DbSetArticoli
                            .AsNoTracking()
                            .Where(x => x.Tipo.ToUpper() == tipo.ToUpper() && (azienda == "*" || x.Azienda.ToUpper() == azienda.ToUpper()))
                            .OrderBy(x => x.CodArticolo)
                            .ToListAsync();
        }

        /// <inheritdoc />
        public async Task<List<AnagArticoliModel>> ArticoliGetSearchAsync(int numRecord, string tipoArt = "*", string azienda = "*", string searchVal = "")
        {
            await using var dbCtx = await CreateContextAsync();
            IQueryable<AnagArticoliModel> query = dbCtx.DbSetArticoli.AsNoTracking();

            if (tipoArt != "*")
            {
                query = query.Where(x => EF.Functions.Like(x.Tipo, tipoArt));
            }
            if (azienda != "*")
            {
                query = query.Where(x => EF.Functions.Like(x.Azienda, azienda));
            }
            if (!string.IsNullOrWhiteSpace(searchVal))
            {
                string pattern = $"%{searchVal}%";
                query = query.Where(x =>
                    EF.Functions.Like(x.CodArticolo, pattern) ||
                    EF.Functions.Like(x.DescArticolo, pattern) ||
                    EF.Functions.Like(x.Disegno, pattern));
            }

            return await query.OrderBy(x => x.CodArticolo).Take(numRecord).ToListAsync();
        }

        /// <inheritdoc />
        public async Task<List<AnagArticoliModel>> ArticoliGetUnusedAsync()
        {
            await using var dbCtx = await CreateContextAsync();
            return await dbCtx.DbSetArticoli.FromSqlRaw("EXEC stp_ART_getNotUsed").AsNoTracking().ToListAsync();
        }

        /// <inheritdoc />
        public async Task<List<AnagArticoliModel>> ArticoliGetUsedAsync()
        {
            await using var dbCtx = await CreateContextAsync();
            return await dbCtx.DbSetArticoli.FromSqlRaw("EXEC stp_ART_getUsed").AsNoTracking().ToListAsync();
        }

        /// <inheritdoc />
        public async Task<List<AnagArticoliModel>> ArticoliInKitAsync()
        {
            await using var dbCtx = await CreateContextAsync();
            return await dbCtx.DbSetArticoli.FromSqlRaw("EXEC stp_TempKIT_getArtChild").AsNoTracking().ToListAsync();
        }

        /// <inheritdoc />
        public async Task<bool> ArticoliUpdateRecord(AnagArticoliModel editRec)
        {
            await using var dbCtx = await CreateContextAsync();
            var currRec = await dbCtx.DbSetArticoli.FirstOrDefaultAsync(x => x.CodArticolo == editRec.CodArticolo);
            if (currRec != null)
            {
                currRec.Disegno = editRec.Disegno;
                currRec.DescArticolo = editRec.DescArticolo;
                currRec.Tipo = editRec.Tipo;
                currRec.Azienda = editRec.Azienda;
                dbCtx.Entry(currRec).State = EntityState.Modified;
                return await dbCtx.SaveChangesAsync() > 0;
            }
            return false;
        }

        /// <inheritdoc />
        public async Task<List<ListValuesModel>> ListValuesFiltAsync(string tabName, string fieldName)
        {
            await using var dbCtx = await CreateContextAsync();
            return await dbCtx.DbSetListValues
                              .Where(x => x.TableName == tabName && x.FieldName == fieldName)
                              .AsNoTracking()
                              .OrderBy(x => x.ordinal)
                              .ToListAsync();
        }

        /// <inheritdoc />
        public async Task<List<MacchineModel>> MacchineByMatrOperAsync(int MatrOpr)
        {
            await using var dbCtx = await CreateContextAsync();
            if (MatrOpr == 0)
            {
                return await dbCtx.DbSetMacchine.AsNoTracking().OrderBy(x => x.IdxMacchina).ToListAsync();
            }
            else
            {
                return await dbCtx.DbSetGrp2Oper
                                    .Where(g => g.MatrOpr == MatrOpr)
                                    .Join(dbCtx.DbSetGrp2Macc, g => g.CodGruppo, m => m.CodGruppo, (g, m) => m)
                                    .Distinct()
                                    .Join(dbCtx.DbSetMacchine, g => g.IdxMacchina, m => m.IdxMacchina, (g, m) => m)
                                    .Distinct()
                                    .AsNoTracking()
                                    .OrderBy(x => x.IdxMacchina)
                                    .ToListAsync();
            }
        }

        /// <inheritdoc />
        public async Task<List<MacchineModel>> MacchineGetFiltAsync(string codGruppo)
        {
            await using var dbCtx = await CreateContextAsync();
            if (codGruppo == "*")
            {
                return await dbCtx.DbSetMacchine.AsNoTracking().OrderBy(x => x.IdxMacchina).ToListAsync();
            }
            else
            {
                return await dbCtx.DbSetGrp2Macc
                                    .Where(g => g.CodGruppo == codGruppo)
                                    .Join(dbCtx.DbSetMacchine, g => g.IdxMacchina, m => m.IdxMacchina, (g, m) => m)
                                    .AsNoTracking()
                                    .OrderBy(x => x.IdxMacchina)
                                    .ToListAsync();
            }
        }

        /// <inheritdoc />
        public async Task<List<AnagOperatoriModel>> OperatoriGetFiltAsync(string codGruppo)
        {
            List<AnagOperatoriModel> dbResult = new List<AnagOperatoriModel>();
            await using var dbCtx = await CreateContextAsync();
            if (codGruppo == "*")
            {
                dbResult = await dbCtx
                            .DbOperatori
                            .AsNoTracking()
                            .OrderBy(x => x.MatrOpr)
                            .ToListAsync();
            }
            else
            {
                dbResult = await dbCtx
                            .DbSetGrp2Oper
                            .Where(g => g.CodGruppo == codGruppo)
                            .Join(dbCtx.DbOperatori,
                                g => g.MatrOpr,
                                m => m.MatrOpr,
                                (g, m) => m
                            )
                            .AsNoTracking()
                            .OrderBy(x => x.MatrOpr)
                            .ToListAsync();
            }
            return dbResult;
        }

        /// <inheritdoc />
        public async Task<Dictionary<int, int>> PODL_getDictOdlPodlAsync(List<int> missingIds)
        {
            if (missingIds == null || !missingIds.Any())
                return new Dictionary<int, int>();

            await using var dbCtx = await CreateContextAsync();
            return await dbCtx
                                .DbSetPODL
                                .AsNoTracking()
                                .Where(x => missingIds.Contains(x.IdxOdl))
                                .ToDictionaryAsync(x => x.IdxOdl, x => x.IdxPromessa);
        }

        /// <summary>
        /// Recupero dizionario traduzioni da cache o DB

        /// </summary>
        /// <param name="lingua">Codice lingua</param>
        /// <returns>Dizionario di traduzioni</returns>
        public async Task<Dictionary<string, string>> VocabolarioGetLangAsync(string lingua)
        {
            await using var dbCtx = await CreateContextAsync();
            var rawList = dbCtx
                    .DbSetVocabolario
                    .AsNoTracking()
                    .Where(x => x.Lingua.ToLower() == lingua.ToLower())
                    .OrderBy(x => x.Lemma)
                    .ToList();
            // Proietto in dizionario
            return rawList
                    .DistinctBy(t => t.Lemma, StringComparer.OrdinalIgnoreCase)
                    .ToDictionary(t => t.Lemma, t => t.Traduzione, StringComparer.OrdinalIgnoreCase);
        }

        #endregion Public Methods
    }
}