kreta/Kreta.BusinessLogic/Helpers/ImportExport/TanuloBesorolasImportExportHelper.cs

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.IO;
using System.Linq;
using System.Runtime.Caching;
using Kreta.BusinessLogic.Classes;
using Kreta.BusinessLogic.HelperClasses;
using Kreta.BusinessLogic.HelperClasses.ImportCo;
using Kreta.BusinessLogic.Logic;
using Kreta.Core;
using Kreta.Core.ConnectionType;
using Kreta.DataAccessManual;
using Kreta.DataAccessManual.Util;
using Kreta.Enums;
using Kreta.Enums.ManualEnums.ImportExport;
using Kreta.Resources;
using Newtonsoft.Json;

namespace Kreta.BusinessLogic.Helpers.ImportExport
{
    public class TanuloBesorolasImportExportHelper : LogicBase
    {
        #region Fields

        private readonly string _importObjectCacheKey;

        #endregion Fields

        #region Properties

        public static Dictionary<int, string> ImportHeaderList => new Dictionary<int, string>
        {
            { 00, ImportExportTanuloBesorolasResource.ImportHeaderNameTanuloNeve },
            { 01, ImportExportTanuloBesorolasResource.ImportHeaderNameTanuloOktatasiAzonosito },
            { 02, ImportExportTanuloBesorolasResource.ImportHeaderNameOsztalyCsoport }
        };

        public TanuloBesorolasImportCo ImportCo
        {
            get => (TanuloBesorolasImportCo)Cache.Get(_importObjectCacheKey);
            set
            {
                if (ImportCo != null)
                {
                    Cache.Remove(_importObjectCacheKey);
                }

                Cache.Add(_importObjectCacheKey, value, new CacheItemPolicy { SlidingExpiration = TimeSpan.FromMinutes(30) });
            }
        }

        #endregion Properties

        #region Constructors

        public TanuloBesorolasImportExportHelper(IConnectionType connectionType) : base(connectionType)
        {
            _importObjectCacheKey = $"{nameof(TanuloBesorolasImportCo)}_{IntezmenyId}_{FelhasznaloId}_ImportObjectCacheKey";
        }

        #endregion Constructors

        public void SetImportCo(List<List<string>> importData, DateTime besorolasDatum, bool? isJuttatasUpdate, bool isIntezmenySzakkepzoJuttatas, DateTime? kisorolasDatum, bool isSzakkepzoIntezmeny)
        {
            TanuloBesorolasImportCo importCo = GetImportCoFromImportData(importData, besorolasDatum, kisorolasDatum, isSzakkepzoIntezmeny);
            importCo.ImportMuvelet = (int)ImportMuveletEnum.Insert;

            SetNemImportalhatoSorokByValidation(importCo);

            SetOperationAndNemImportalhatoSorokByOperation(importCo);

            var tanuloBesorolasTanuloTanugyiAdatokImportJsonItemList = new List<TanuloBesorolasTanuloTanugyiAdatokImportJsonItemCo>();
            var mainImportJsonItemList = new List<TanuloBesorolasImportJsonItemCo>();
            foreach (TanuloBesorolasImportItemCo importItem in importCo.MainImportItemList)
            {
                if (importItem.IsOsztaly.Value)
                {
                    if (!importItem.Tanulo.TantervId.IsEntityId())
                    {
                        importItem.Tanulo.TantervId = new TantervHelper(ConnectionType).GetTop1TantervId();
                    }

                    tanuloBesorolasTanuloTanugyiAdatokImportJsonItemList.Add(new TanuloBesorolasTanuloTanugyiAdatokImportJsonItemCo(importItem.OsztalyCsoportId.Value, importItem.Tanulo, TanevId, IntezmenyId, FelhasznaloId));
                }

                mainImportJsonItemList.Add(new TanuloBesorolasImportJsonItemCo(importItem, besorolasDatum, kisorolasDatum, TanevId, IntezmenyId, FelhasznaloId));
            }

            importCo.TanuloBesorolasTanuloTanugyiAdatokImportJsonItemList = tanuloBesorolasTanuloTanugyiAdatokImportJsonItemList;
            importCo.MainImportJsonItemList = mainImportJsonItemList
                .OrderByDescending(x => x.IsOsztaly)
                .ThenBy(x => x.TanuloVezeteknev)
                .ThenBy(x => x.TanuloKeresztnev)
                .ThenBy(x => x.OsztalyCsoportNev)
                .ToList();

            importCo.IsJuttatasUpdate = isJuttatasUpdate;
            importCo.IsIntezmenySzakkepzoJuttatas = isIntezmenySzakkepzoJuttatas;
            ImportCo = importCo;
        }

        private static void SetNemImportalhatoSorokByValidation(TanuloBesorolasImportCo importCo)
        {
            Dictionary<int, List<ValidationResult>> validationResultDictionary = importCo.Validate();

            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
            foreach (TanuloBesorolasImportItemCo importItem in importCo.MainImportItemList.Where(x => validationResultDictionary.Keys.Contains(x.LineNumber)))
            {
                IEnumerable<ValidationResult> validationResultList = validationResultDictionary[importItem.LineNumber];
                importItem.ErrorList = validationResultList.Select(x => x.ErrorMessage).ToList();
                importCo.NemImportalhatoItemList.Add(importItem);
            }

            //NOTE: Azokat a sorokat, amelyek bekerültek a NemImportalhatoItemList-be, azokat kiveszzük a MainImportItemList-ből!
            importCo.MainImportItemList.RemoveRange(importCo.NemImportalhatoItemList);
        }

        private void SetOperationAndNemImportalhatoSorokByOperation(TanuloBesorolasImportCo importCo)
        {
            //NOTE: Azért van szükség Dictionary-re, mert így sokkal gyorsabb a keresés!
            Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary = GetCompareHashImportItemCompareCoDictionary(importCo.TanuloCsoportCoList);
            foreach (TanuloBesorolasImportItemCo importItem in importCo.MainImportItemList)
            {
                string compareHash = importItem.CompareHash;
                //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
                if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
                {
                    importItem.Operation = (int)ImportItemOperationEnum.Insert;
                }
                //NOTE: Ha találtunk egyezést, akkor hozzá kell adni a nem NemImportalhatoItemList-hez és jelezni, hogy már szerepel az adatbázisban!
                else
                {
                    importItem.ErrorList.Add(ImportExportCommonResource.NemImportalhatoMertMarSzerepelAzAdatbazisban);
                    importCo.NemImportalhatoItemList.Add(importItem);
                }
            }

            //NOTE: Azokat a sorokat, amelyek bekerültek a NemImportalhatoItemList-be, azokat kiveszzük a MainImportItemList-ből!
            importCo.MainImportItemList.RemoveRange(importCo.NemImportalhatoItemList);
        }

        private TanuloBesorolasImportCo GetImportCoFromImportData(List<List<string>> importData, DateTime besorolasDatum, DateTime? kisorolasDatum, bool isSzakkepzoIntezmeny)
        {
            var importCo = new TanuloBesorolasImportCo();
            importCo.BesorolasDatum = besorolasDatum;
            importCo.KisorolasDatum = kisorolasDatum;
            importCo.TanevUtolsoNapja = new TanevHelper(ConnectionType).GetTanevInfo().UtolsoNap;

            List<TanuloItemCo> tanuloCoList = new TanuloHelper(ConnectionType).GetTanuloCoList();

            importCo.OsztalyCsoportCoList = new OsztalyCsoportHelper(ConnectionType).GetOsztalyCsoportCoList();

            var tanuloCsoportHelper = new TanuloCsoportHelper(ConnectionType);
            importCo.TanuloCsoportCoList = tanuloCsoportHelper.GetTanuloCsoportCoList();
            importCo.JogviszonyLimits = tanuloCsoportHelper.GetJogviszonyLimits();

            int lineNumber = 1;
            foreach (List<string> importDataRow in importData.Skip(1))
            {
                var importItemCo = new TanuloBesorolasImportItemCo(isSzakkepzoIntezmeny)
                {
                    LineNumber = lineNumber,

                    TanuloNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloBesorolasResource.ImportHeaderNameTanuloNeve)],
                    TanuloOktatasiAzonositoImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloBesorolasResource.ImportHeaderNameTanuloOktatasiAzonosito)],
                    OsztalyCsoportImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloBesorolasResource.ImportHeaderNameOsztalyCsoport)]
                };

                importItemCo.Tanulo = tanuloCoList.SingleOrDefault(x =>
                    x.FelhasznaloNyomtatasiNevComparableString == importItemCo.TanuloNeveImportData?.ToComparableString() &&
                    x.FelhasznaloOktatasiAzonositoComparableString == importItemCo.TanuloOktatasiAzonosito?.ToComparableString());

                OsztalyCsoportItemCo osztalyCsoport = importCo.OsztalyCsoportCoList.SingleOrDefault(x =>
                    x.NevComparableString == importItemCo.OsztalyCsoportNev?.ToComparableString());
                importItemCo.OsztalyCsoportId = osztalyCsoport?.Id;
                importItemCo.IsOsztaly = osztalyCsoport?.IsOsztaly;

                //NOTE: A tanuló csoport lista további validációkhoz kellenek, ha nincs tanuló vagy osztály csoport id, akkor nincs értelme feltölteni a listát!
                if (importItemCo.TanuloId.IsEntityId() && importItemCo.OsztalyCsoportId.IsEntityId())
                {
                    importItemCo.TanuloOsztalyCsoportIdList = importCo.TanuloCsoportCoList.Where(x => x.FelhasznaloId == importItemCo.TanuloId.Value).Select(x => x.OsztalyCsoportId).ToList();
                }

                string md5HashInput =
                    importItemCo.TanuloId +
                    importItemCo.TanuloNeveImportData?.ToComparableString() +
                    importItemCo.TanuloOktatasiAzonosito?.ToComparableString() +
                    importItemCo.OsztalyCsoportId +
                    importItemCo.OsztalyCsoportNev?.ToComparableString();
                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(md5HashInput);

                importCo.MainImportItemList.Add(importItemCo);

                lineNumber++;
            }

            return importCo;
        }

        #region Template

        public MemoryStream GetTemplate()
        {
            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<TanuloCsoportItemCo>(TanuloCsoportItemCo.TanuloCsoportTemplateExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
            return SimpleExportLogic.GetTemplate(ImportExportTanuloBesorolasResource.ImportDefaultSheetName, simpleExportColumnCos);
        }

        #endregion Template

        #region Export

        public MemoryStream GetExport()
        {
            List<TanuloCsoportItemCo> coList = new TanuloCsoportHelper(ConnectionType).GetTanuloCsoportCoList().OrderBy(x => x.FelhasznaloVezeteknev).ThenBy(x => x.FelhasznaloKeresztnev).ThenBy(x => x.OsztalyCsoportNev).ToList();
            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<TanuloCsoportItemCo>(TanuloCsoportItemCo.TanuloCsoportExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
            return SimpleExportLogic.GetExport(ImportExportTanuloBesorolasResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
        }

        public MemoryStream GetNemImportalhatoSorokExport()
        {
            List<TanuloBesorolasImportItemCo> coList = ImportCo.NemImportalhatoItemList;
            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<TanuloBesorolasImportItemCo>(TanuloBesorolasImportItemCo.NemImportalhatoSorokExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
            return ImportExportHelper.NemImportalhatoSorokExport(ImportExportTanuloBesorolasResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
        }

        #endregion Export

        private Dictionary<string, ImportItemCompareCo> GetCompareHashImportItemCompareCoDictionary(List<TanuloCsoportItemCo> coList)
        {
            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
            foreach (TanuloCsoportItemCo co in coList)
            {
                string md5HashInput =
                    co.FelhasznaloId +
                    co.FelhasznaloNyomtatasiNevComparableString +
                    co.FelhasznaloOktatasiAzonositoComparableString +
                    co.OsztalyCsoportId +
                    co.OsztalyCsoportNevComparableString +
                    $"{co.BelepesDatum.ToShortDateString()} - {co.KilepesDatum?.ToShortDateString()}";
                string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);

                var importItemCompareCo = new ImportItemCompareCo
                {
                    Id = co.Id,
                    CompareHash = compareHash,
                    Importalt = co.Importalt
                };
                //NOTE: Elvileg nem fordulhatna elő, de ha az adatbázisban duplikált adat van, akkor csak az elsőt adjuk hozzá!
                if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
                {
                    compareHashImportItemCompareCoDictionary.Add(compareHash, importItemCompareCo);
                }
            }

            return compareHashImportItemCompareCoDictionary;
        }

        public void Import(object importJsonObject, DateTime besorolasDatum)
        {
            var importJson = JsonConvert.SerializeObject(importJsonObject);
            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
            {
                dalHandler.ImportExportDal().TanuloBesorolasImport(IntezmenyId, TanevId, FelhasznaloId, importJson, besorolasDatum);

                if (ImportCo.IsIntezmenySzakkepzoJuttatas && ImportCo.IsJuttatasUpdate.HasValue && ImportCo.IsJuttatasUpdate.Value)
                {
                    var dal = dalHandler.JuttatasDAL();
                    dal.UpdateTanulokSzakkepzesiJuttatasok(TanevId, FelhasznaloId, (int)JuttatasTipusEnum.szakkepzesi_juttatas);
                    dal.UpdateTanulokSzakkepzesiJuttatasok(TanevId, FelhasznaloId, (int)JuttatasTipusEnum.apaczaiosztondij);
                }
            });
        }

        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary()
        {
            //NOTE: Create dropdown lists
            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>();

            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
            {
                var helper = new ImportExportHelper(new DalHandlerConnectionType(ConnectionType, dalHandler));
                dropDownColumnSourceDictionary.Add(ImportExportTanuloBesorolasResource.ImportHeaderNameTanuloNeve, helper.GetTanuloList());
                dropDownColumnSourceDictionary.Add(ImportExportTanuloBesorolasResource.ImportHeaderNameOsztalyCsoport, helper.GetOsztalyCsoportList());
            });
            return dropDownColumnSourceDictionary;
        }
    }
}