init

Kreta.BusinessLogic/Helpers/ImportExport/AlkalmazottMunkaugyiAdatokImportExportHelper.cs

@@ -0,0 +1,398 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Data;
+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.ParameterClasses;
+using Kreta.DataAccessManual.Util;
+using Kreta.Enums;
+using Kreta.Enums.ManualEnums.ImportExport;
+using Kreta.Resources;
+
+namespace Kreta.BusinessLogic.Helpers.ImportExport
+{
+    public class AlkalmazottMunkaugyiAdatokImportExportHelper : LogicBase
+    {
+        #region Fields
+
+        private readonly string _importObjectCacheKey;
+
+        #endregion Fields
+
+        #region Properties
+
+        public static Dictionary<int, string> ImportHeaderList => new Dictionary<int, string>
+        {
+            { 00, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusNeve },
+            { 01, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusNevElotag },
+            { 02, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusVezetekneve },
+            { 03, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusUtoneve },
+            { 04, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusAnyjaNeve },
+            { 05, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusSzuletesiDatuma },
+            { 06, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusSzuletesiHelye },
+            { 07, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusOktatasiAzonosito },
+            { 08, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameAdoazonositoJel },
+            { 09, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusFokozat },
+            { 10, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameMunkakor },
+            { 11, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameFoglalkoztatasiJogviszony },
+            { 12, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameKotelezoOraszama },
+            { 13, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameMunkaidokedvezmenyOraszama },
+            { 14, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameFeladattalTerheltOraszamOka },
+            { 15, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameAlkalmazasKezdete },
+            { 16, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameFoglalkoztatasTipusa },
+            { 17, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameVezetoiOraszamOka },
+            { 18, CommonResource.Feladatellatasihely },
+            { 19, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameTartosanTavollevo },
+            { 20, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameBetoltetlenAllashely },
+            { 21, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameKulsoAlkalmazott },
+            { 22, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameFoallasu },
+            { 23, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameNyugdijasTovabbfoglalkoztatott },
+            { 24, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameSzakertoiVagyvizsgaelnokiTevekenyseg },
+            { 25, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameSzakmaiTovabbkepzes },
+            { 26, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameSzakvizsga },
+            { 27, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameAttanitoIntezmenyenBelul },
+            { 28, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameAttanitoMasIntezmenynel },
+            { 29, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameTartosHelyettesites },
+            { 30, ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameSzakertoSzaktanacsado }
+        };
+
+        public AlkalmazottMunkaugyiAdatokImportCo ImportCo
+        {
+            get => (AlkalmazottMunkaugyiAdatokImportCo)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 AlkalmazottMunkaugyiAdatokImportExportHelper(IConnectionType connectionType) : base(connectionType)
+        {
+            _importObjectCacheKey = $"{nameof(AlkalmazottMunkaugyiAdatokImportCo)}_{IntezmenyId}_{FelhasznaloId}_ImportObjectCacheKey";
+        }
+
+        #endregion Constructors
+
+        public void SetImportCo(List<List<string>> importData, bool isSzakkepzoIntezmeny)
+        {
+            AlkalmazottMunkaugyiAdatokImportCo importCo = GetImportCoFromImportData(importData);
+            importCo.ImportMuvelet = 1;
+
+            SetNemImportalhatoSorokByValidation(importCo, isSzakkepzoIntezmeny);
+
+            SetOperationAndNemImportalhatoSorokByOperation(importCo);
+
+            var mainImportJsonItemList = new List<AlkalmazottMunkaugyiAdatokImportJsonItemCo>(importCo.MainImportItemList.Select(x => new AlkalmazottMunkaugyiAdatokImportJsonItemCo(x, TanevId, IntezmenyId, FelhasznaloId)));
+            importCo.MainImportJsonItemList = mainImportJsonItemList;
+
+            ImportCo = importCo;
+        }
+
+        private static void SetNemImportalhatoSorokByValidation(AlkalmazottMunkaugyiAdatokImportCo importCo, bool isSzakkepzoIntezmeny)
+        {
+            Dictionary<int, List<ValidationResult>> validationResultDictionary = importCo.Validate(isSzakkepzoIntezmeny);
+
+            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
+            foreach (AlkalmazottMunkaugyiAdatokImportItemCo 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(AlkalmazottMunkaugyiAdatokImportCo importCo)
+        {
+            int importMuvelet = importCo.ImportMuvelet;
+            //NOTE: Azért van szükség Dictionary-re, mert így sokkal gyorsabb a keresés!
+            Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary = GetCompareHashImportItemCompareCoDictionary(importCo.AlkalmazottMunkaugyiAdatokCoList);
+            foreach (AlkalmazottMunkaugyiAdatokImportItemCo 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...
+                else
+                {
+                    ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                    //NOTE: ...ha az import művelet DeleteAndInsert és a db-ből jövő adat Importalt(a nem importáltakat egyelőre nem töröljük), akkor Insert, mert töröljük a korábbi elemeket és újra be kell szúrni!
+                    if (importMuvelet == (int)ImportMuveletEnum.DeleteAndInsert && importItemCompareCo.Importalt)
+                    {
+                        importItem.Operation = (int)ImportItemOperationEnum.Insert;
+                    }
+                    //NOTE: ...ha nincs törlés, akkor...
+                    else
+                    {
+                        //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
+                        if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                        {
+                            importItem.Id = importItemCompareCo.Id;
+                            importItem.Operation = (int)ImportItemOperationEnum.Update;
+                        }
+                        //NOTE: ...ha a művelet nem InsertAndUpdate, akkor hozzá kell adni a nem NemImportalhatoItemList-hez és jelezni, hogy már szerepel az adatbázisban(Insert vagy DeleteAndInsert műveletnél. A DeleteAndInsert csak akkor fut be ide, ha az elem nem importált.)!
+                        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);
+        }
+
+        public AlkalmazottMunkaugyiAdatokImportCo GetImportCoFromImportData(List<List<string>> importData)
+        {
+            List<AlkalmazottMunkaugyiAdatokCo> alkalmazottMunkaugyiAdatokCoList = null;
+            DataSet feladatellatasiHelyDataSet = null;
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                alkalmazottMunkaugyiAdatokCoList = new AlkalmazottMunkaugyiAdatokHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetAlkalmazottMunkaugyiAdatokCoList();
+                feladatellatasiHelyDataSet = dalHandler.FeladatEllatasiHelyDal().GetFeladatellatasiHelyDataSet(TanevId);
+            });
+
+            var importCo = new AlkalmazottMunkaugyiAdatokImportCo
+            {
+                AlkalmazottMunkaugyiAdatokCoList = alkalmazottMunkaugyiAdatokCoList
+            };
+
+            var feladatellatasiHelyTuple = new List<(int FeladatellatasiHelyId, string FeladatellatasiHely)>();
+
+            foreach (DataRow dataRow in feladatellatasiHelyDataSet.Tables[0].Rows)
+            {
+                feladatellatasiHelyTuple.Add((
+                    SDAConvert.ToInt32(dataRow["Id"]),
+                    $"{SDAConvert.ToString(dataRow["MukodesiHelyNev"])} - {SDAConvert.ToString(dataRow["OktatasiNevelesiFeladatTipusId_DNAME"])}"));
+            }
+
+            int lineNumber = 1;
+            foreach (List<string> importDataRow in importData.Skip(1))
+            {
+                var importItemCo = new AlkalmazottMunkaugyiAdatokImportItemCo(TanevId)
+                {
+                    LineNumber = lineNumber,
+
+                    PedagogusNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusNeve)],
+                    PedagogusNevElotagImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusNevElotag)],
+                    PedagogusVezetekneveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusVezetekneve)],
+                    PedagogusUtoneveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusUtoneve)],
+                    PedagogusAnyjaNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusAnyjaNeve)],
+                    PedagogusSzuletesiDatumaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusSzuletesiDatuma)],
+                    PedagogusSzuletesiHelyeImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusSzuletesiHelye)],
+                    PedagogusOktatasiAzonositoImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusOktatasiAzonosito)],
+                    AdoazonositoJelImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameAdoazonositoJel)],
+                    PedagogusFokozatImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusFokozat)],
+                    MunkakorImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameMunkakor)],
+                    FoglalkoztatasiJogviszonyImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameFoglalkoztatasiJogviszony)],
+                    KotelezoOraszamaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameKotelezoOraszama)],
+                    MunkaidokedvezmenyOraszamaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameMunkaidokedvezmenyOraszama)],
+                    FeladattalTerheltOraszamOkaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameFeladattalTerheltOraszamOka)],
+                    AlkalmazasKezdeteImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameAlkalmazasKezdete)],
+                    FoglalkoztatasTipusaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameFoglalkoztatasTipusa)],
+                    VezetoiOraszamOkaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameVezetoiOraszamOka)],
+                    FeladatellatasiHelyImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(CommonResource.Feladatellatasihely)],
+                    TartosanTavollevoImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameTartosanTavollevo)],
+                    BetoltetlenAllashelyImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameBetoltetlenAllashely)],
+                    KulsoAlkalmazottImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameKulsoAlkalmazott)],
+                    FoallasuImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameFoallasu)],
+                    NyugdijasTovabbfoglalkoztatottImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameNyugdijasTovabbfoglalkoztatott)],
+                    SzakertoiVagyVizsgaelnokiTevekenyseguImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameSzakertoiVagyvizsgaelnokiTevekenyseg)],
+                    SzakmaiTovabbkepzesImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameSzakmaiTovabbkepzes)],
+                    SzakvizsgaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameSzakvizsga)],
+                    AttanitoIntezmenyenBelulImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameAttanitoIntezmenyenBelul)],
+                    IsAttanitoMasIntezmenynelImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameAttanitoMasIntezmenynel)],
+                    IsTartosanTavollevoHelyettesitesImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameTartosHelyettesites)],
+                    SzakertoImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameSzakertoSzaktanacsado)]
+                };
+
+                int? feladatellatasiHelyId = feladatellatasiHelyTuple.FirstOrDefault(x => x.FeladatellatasiHely == importItemCo.FeladatellatasiHelyImportData).FeladatellatasiHelyId;
+                if (feladatellatasiHelyId.IsEntityId())
+                {
+                    importItemCo.FeladatellatasiHelyId = feladatellatasiHelyId;
+                }
+
+                var md5HashInput =
+                    $"{importItemCo.Vezeteknev?.ToComparableString()} {importItemCo.Keresztnev?.ToComparableString()}" +
+                    importItemCo.AnyjaNeve?.ToComparableString() +
+                    importItemCo.SzuletesiIdoString?.ToComparableString() +
+                    importItemCo.SzuletesiHely?.ToComparableString();
+                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                importCo.MainImportItemList.Add(importItemCo);
+
+                lineNumber++;
+            }
+
+            return importCo;
+        }
+
+        #region Template
+
+        public MemoryStream GetTemplate()
+        {
+            var dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary();
+
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<AlkalmazottMunkaugyiAdatokCo>(AlkalmazottMunkaugyiAdatokCo.AlkalmazottMunkaugyiAdatokExportAttributeId, dropDownColumnSourceDictionary);
+
+            return SimpleExportLogic.GetTemplate(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportDefaultSheetName, simpleExportColumnCos);
+        }
+
+        #endregion Template
+
+        #region Export
+
+        public MemoryStream GetExport()
+        {
+            var dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary();
+
+            List<AlkalmazottMunkaugyiAdatokCo> coList = new AlkalmazottMunkaugyiAdatokHelper(ConnectionType).GetAlkalmazottMunkaugyiAdatokCoList().OrderBy(x => x.NevElotagNelkul).ToList();
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<AlkalmazottMunkaugyiAdatokCo>(AlkalmazottMunkaugyiAdatokCo.AlkalmazottMunkaugyiAdatokExportAttributeId, dropDownColumnSourceDictionary);
+
+            return SimpleExportLogic.GetExport(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        public MemoryStream GetNemImportalhatoSorokExport()
+        {
+            var dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary();
+
+            List<AlkalmazottMunkaugyiAdatokImportItemCo> coList = ImportCo.NemImportalhatoItemList;
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<AlkalmazottMunkaugyiAdatokImportItemCo>(AlkalmazottMunkaugyiAdatokImportItemCo.NemImportalhatoSorokExportAttributeId, dropDownColumnSourceDictionary);
+
+            return ImportExportHelper.NemImportalhatoSorokExport(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        #endregion Export
+
+        public void Import(List<AlkalmazottMunkaugyiAdatokImportJsonItemCo> importCo)
+        {
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                var dal = dalHandler.AlkalmazottMunkaugyiAdatokDal();
+                foreach (AlkalmazottMunkaugyiAdatokImportJsonItemCo item in importCo)
+                {
+                    var alkalmazottMunkaugyiAdatokImportPco = new AlkalmazottMunkaugyiAdatokImportPco
+                    {
+                        Id = item.Id.Value,
+                        BesorolasiFokozat = item.BesorolasiFokozat,
+                        MunkakorTipusa = item.Munkakor,
+                        MunkaviszonyTipusa = item.Munkaviszony,
+                        KotelezoOraszam = item.KotelezoOraszam ?? 0,
+                        MunkaidoKedvezmenyOraszam = item.MunkaidoKedvezmenyOraszam,
+                        MunkaidoKedvezmenyOka = item.MunkaidoKedvezmenyOka,
+                        AlkalmazasKezdete = item.AlkalmazasKezdete,
+                        FoglalkoztatasTipus = item.FoglalkoztatasTipus,
+                        VezetoiOraszamOka = item.VezetoiOraszamOka,
+                        FeladatEllatasiHelyId = item.FeladatellatasiHelyId,
+                        AllandoHelyettesitesre = item.IsTartosTavollevoHelyettesites ?? false,
+                        TartosHelyettesites = item.IsTartosTavollet ?? false,
+                        BetoltetlenAllashely = item.IsBetoltetlenAllashely ?? false,
+                        IsKulsoAlkalmazott = item.IsKulsoAlkalmazott ?? false,
+                        Nyugdijas = item.IsNyugdijas ?? false,
+                        Attanito = item.IsAttanito ?? false,
+                        AdoazonositoJel = item.AdoazonositoJel,
+                        Foallas = item.IsFoallasu ?? false,
+                        SzakertoiVizsgaelnoki = item.IsSzakertoiVagyVizsgaelnokiTevekenysegu ?? false,
+                        Szakvizsga = item.IsSzakvizsga ?? false,
+                        OktatasiAzonosito = item.OktatasiAzonosito,
+                        Tovabbkepzes = item.IsSzakmaiTovabbkepzes ?? false,
+                        SzakertoMesterpedagogus = item.BesorolasiFokozat.HasValue && item.BesorolasiFokozat.Value == (int)BesorolasiFokozatTipusEnum.mesterpedagogus && item.IsSzakerto.HasValue && item.IsSzakerto.Value,
+                        IsSzakertoKutatotanar = item.BesorolasiFokozat.HasValue && item.BesorolasiFokozat.Value == (int)BesorolasiFokozatTipusEnum.kutatotanar && item.IsSzakerto.HasValue && item.IsSzakerto.Value,
+                        IsAttanitoMasIntezmenynel = item.IsAttanitoMasIntezmenynel ?? false
+                    };
+                    dal.Import(alkalmazottMunkaugyiAdatokImportPco);
+                }
+            });
+        }
+
+        private Dictionary<string, ImportItemCompareCo> GetCompareHashImportItemCompareCoDictionary(List<AlkalmazottMunkaugyiAdatokCo> coList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (var co in coList)
+            {
+                string md5HashInput =
+                    $"{co.FelhasznaloVezeteknevComparableString} {co.FelhasznaloKeresztnevComparableString}" +
+                    co.FelhasznaloAnyjaNeveComparableString +
+                    co.FelhasznaloSzuletesiIdoComparableString +
+                    co.FelhasznaloSzuletesiHelyComparableString;
+                string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                var importItemCompareCo = new ImportItemCompareCo
+                {
+                    Id = co.MunkaugyiAdatId,
+                    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;
+        }
+
+        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary()
+        {
+            //NOTE: Create dropdown lists
+            var logicalColumnDictionary = new Dictionary<string, IList<string>>();
+
+            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>(logicalColumnDictionary)
+            {
+                { ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusNevElotag, Constants.ElotagList },
+            };
+
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                var connectionType = new DalHandlerConnectionType(ConnectionType, dalHandler);
+
+                dropDownColumnSourceDictionary.Add(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusFokozat, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.BesorolasiFokozatTipus));
+
+                dropDownColumnSourceDictionary.Add(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameMunkakor, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.MunkakorTipus));
+
+                dropDownColumnSourceDictionary.Add(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameFoglalkoztatasiJogviszony, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.MunkaviszonyTipus));
+
+                dropDownColumnSourceDictionary.Add(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameFeladattalTerheltOraszamOka, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.MunkaidoKedvezmenyOka));
+
+                dropDownColumnSourceDictionary.Add(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameFoglalkoztatasTipusa, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.FoglalkoztatasTipusa));
+
+                dropDownColumnSourceDictionary.Add(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameVezetoiOraszamOka, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.VezetoiOraszamokTipus));
+
+                var helper = new ImportExportHelper(connectionType);
+                DataSet feladatellatasiHelyDataSet = dalHandler.FeladatEllatasiHelyDal().GetFeladatellatasiHelyDataSet(TanevId);
+
+                dropDownColumnSourceDictionary.Add(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNamePedagogusNeve, helper.GetTanarList());
+                dropDownColumnSourceDictionary.Add(CommonResource.Feladatellatasihely, helper.GetFeladatellatasiHelyList(feladatellatasiHelyDataSet));
+                dropDownColumnSourceDictionary.Add(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameMukodesiHely, helper.GetMukodesiHelyList(feladatellatasiHelyDataSet));
+                dropDownColumnSourceDictionary.Add(ImportExportAlkalmazottMunkaugyiAdatokResource.ImportHeaderNameEllatottKoznevelesiFeladat, helper.GetEllatottKoznevelesiFeladatList(feladatellatasiHelyDataSet));
+            });
+
+            return dropDownColumnSourceDictionary;
+        }
+    }
+}

Kreta.BusinessLogic/Helpers/ImportExport/AscImportExportHelper.cs

@@ -0,0 +1,977 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Xml.Serialization;
+using Aspose.Cells;
+using Kreta.BusinessLogic.Classes;
+using Kreta.BusinessLogic.HelperClasses;
+using Kreta.BusinessLogic.HelperClasses.AscImportExport;
+using Kreta.BusinessLogic.Logic;
+using Kreta.Core;
+using Kreta.Core.ConnectionType;
+using Kreta.Core.Exceptions;
+using Kreta.Resources;
+
+namespace Kreta.BusinessLogic.Helpers.ImportExport
+{
+    public class AscImportExportHelper : LogicBase
+    {
+        #region Fields
+
+        private static readonly AscImport AscImportData = new AscImport();
+
+        #endregion Fields
+
+        #region Properties
+
+        private static List<string> AscEgeszOsztalyNevuCsoportIdList { get; set; } = new List<string>();
+
+        #endregion Properties
+
+        #region Constructors
+
+        public AscImportExportHelper(IConnectionType connectionType) : base(connectionType) { }
+
+        #endregion Constructors
+
+        public static List<List<string>> GetTantargyfelosztasImportDataFromAsc(Stream ascImportFileStream)
+        {
+            var importData = new List<List<string>>
+            {
+                TantargyfelosztasImportExportHelper.ImportHeaderListEgyszeru.Select(x => x.Value).ToList()
+            };
+
+            timetable ascTimeTable = new XmlSerializer(typeof(timetable)).Deserialize(ascImportFileStream.StripNonValidXmlCharacters()) as timetable;
+
+            ValidateAscFile(ascTimeTable, true);
+
+            List<TantargyfelosztasFromAscModel> tantargyfelosztasFromAscModelList = GetTantargyfelosztasFromAscModelList(ascTimeTable);
+            importData.AddRange(tantargyfelosztasFromAscModelList.Select(x =>
+                new List<string>
+                {
+                    x.OsztalyNev.ReplaceMultipleSpacesAndTrim(),
+                    x.CsoportNev.ReplaceMultipleSpacesAndTrim(),
+                    x.TantargyNev.ReplaceMultipleSpacesAndTrim(),
+                    x.Oraszam.ReplaceMultipleSpacesAndTrim(),
+                    x.TanarNev.ReplaceMultipleSpacesAndTrim(),
+                    0.ToString(),
+                    CommonResource.Nem,
+                    CommonResource.Nem,
+                    0.ToString()
+                }));
+
+            return importData;
+        }
+
+        public static List<List<string>> GetOrarendImportDataFromAsc(Stream ascImportFileStream, string oraErvenyessegKezdeteString, string oraErvenyessegVegeString)
+        {
+            var importData = new List<List<string>>
+            {
+                OrarendImportExportHelper.ImportHeaderListOraErvenyessegiIdovel.Select(x => x.Value).ToList()
+            };
+
+            timetable ascTimeTable = new XmlSerializer(typeof(timetable)).Deserialize(ascImportFileStream.StripNonValidXmlCharacters()) as timetable;
+
+            ValidateAscFile(ascTimeTable, false);
+
+            List<OrarendFromAscModel> orarendFromAscModelList = GetOrarendFromAscModelList(ascTimeTable);
+            importData.AddRange(orarendFromAscModelList.Select(x =>
+                new List<string>
+                {
+                    oraErvenyessegKezdeteString.ReplaceMultipleSpacesAndTrim(),
+                    oraErvenyessegVegeString.ReplaceMultipleSpacesAndTrim(),
+                    x.Hetirend.ReplaceMultipleSpacesAndTrim(),
+                    x.Nap.ReplaceMultipleSpacesAndTrim(),
+                    x.Ora.ReplaceMultipleSpacesAndTrim(),
+                    x.OsztalyNev.ReplaceMultipleSpacesAndTrim(),
+                    x.CsoportNev.ReplaceMultipleSpacesAndTrim(),
+                    x.TantargyNev.ReplaceMultipleSpacesAndTrim(),
+                    x.TanarNev.ReplaceMultipleSpacesAndTrim(),
+                    x.TeremNev.ReplaceMultipleSpacesAndTrim()
+                }));
+
+            return importData;
+        }
+
+        private static void ValidateAscFile(timetable ascTimeTable, bool isOnlyTtfImport)
+        {
+            var errorList = new List<string>();
+            if (ascTimeTable.classes?.@class == null && ascTimeTable.groups?.group == null)
+            {
+                errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazOsztalyokatEsVagyCsoportokat);
+            }
+
+            if (ascTimeTable.subjects?.subject == null)
+            {
+                errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazTantargyakat);
+            }
+
+            if (ascTimeTable.teachers?.teacher == null)
+            {
+                errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazTanarokat);
+            }
+
+            if (ascTimeTable.lessons?.lesson == null)
+            {
+                errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazFoglalkozasokat);
+            }
+
+            if (!isOnlyTtfImport)
+            {
+                if (ascTimeTable.cards?.card == null)
+                {
+                    errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazOrakat);
+                }
+
+                if (ascTimeTable.classrooms?.classroom == null)
+                {
+                    errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazTermeket);
+                }
+
+                //NOTE: Különböző módon kell validálni a 2008-as és az azt követő ASC fájlokat!
+                if (ascTimeTable.displayname == null || ascTimeTable.displayname.Contains("2008"))
+                {
+                    if (ascTimeTable.lessons?.lesson != null)
+                    {
+                        var lesson = ascTimeTable.lessons.lesson;
+                        if (lesson.Any(x => string.IsNullOrWhiteSpace(x.weeks)))
+                        {
+                            errorList.Add(ImportExportOrarendResource.InvalidHetirendNincsKitoltve);
+                        }
+                        else if (lesson.Any(x => x.weeks.Length != lesson[0].weeks.Length))
+                        {
+                            errorList.Add(ImportExportOrarendResource.InvalidHetirendForLesson);
+                        }
+                    }
+
+                    if (ascTimeTable.days?.days == null)
+                    {
+                        errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazNapirendet);
+                    }
+                }
+                else
+                {
+                    if (ascTimeTable.weeksdefs?.weeksdef == null)
+                    {
+                        errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazHetirendet);
+                    }
+                    else
+                    {
+                        //NOTE: A hetirendek közül képesek az ASC-vel olyan fájlt generálni, ahol az Id megegyezhet, ezeket meg kell vizsgálnunk, hogy ilyen ne fordulhasson elő!
+                        List<AscHetirend> ascHetirendList = GetHetirendListFromAsc(ascTimeTable);
+
+                        Dictionary<string, List<AscHetirend>> duplicatedHetirendByIdIdDictionary = ascHetirendList
+                            .GroupBy(x => x.Id)
+                            .Where(x => x.Count() > 1)
+                            .ToDictionary(x => x.Key, x => x.ToList());
+
+                        foreach (var duplicatedItem in duplicatedHetirendByIdIdDictionary)
+                        {
+                            List<string> duplacatedItemNevList = duplicatedItem.Value.Select(x => $"\"{x.Nev}\"").ToList();
+                            errorList.Add(string.Format(ImportExportOrarendResource.InvalidHetirendEgyezes, string.Join(", ", duplacatedItemNevList)));
+                        }
+                    }
+
+                    if (ascTimeTable.daysdefs?.daysdef == null)
+                    {
+                        errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazNapirendet);
+                    }
+                }
+            }
+
+            if (errorList.Count > 0)
+            {
+                throw new BlException(string.Join(Constants.General.Sortores, errorList));
+            }
+        }
+
+        private static List<OrarendFromAscModel> GetOrarendFromAscModelList(timetable ascTimeTable)
+        {
+            var orarendFromAscModelList = new List<OrarendFromAscModel>();
+            List<TantargyfelosztasFromAscModel> tantargyfelosztasFromAscModelList = GetTantargyfelosztasFromAscModelList(ascTimeTable);
+
+            List<AscHetirend> ascHetirendList;
+            Dictionary<string, AscNapok> ascNapDictionary;
+            List<AscTimeCards> ascTimeCardList;
+            if (ascTimeTable.displayname == null || ascTimeTable.displayname.Contains("2008"))
+            {
+                ascHetirendList = GetHetirendListFromAsc2008(ascTimeTable);
+                ascNapDictionary = GetNapDictionaryFromAsc2008(ascTimeTable);
+                ascTimeCardList = GetAscTimeCardList2008(ascTimeTable, ascNapDictionary);
+            }
+            else
+            {
+                ascHetirendList = GetHetirendListFromAsc(ascTimeTable);
+                ascNapDictionary = GetNapDictionaryFromAsc(ascTimeTable);
+                ascTimeCardList = GetAscTimeCardList(ascTimeTable, ascNapDictionary);
+            }
+
+            List<AscTerem> ascTeremList = GetTeremListFromAsc(ascTimeTable);
+
+            foreach (AscTimeCards ascTimeCard in ascTimeCardList)
+            {
+                List<TantargyfelosztasFromAscModel> tantargyfelosztasList = tantargyfelosztasFromAscModelList.Where(x => x.Id.Equals(ascTimeCard.LessonId)).ToList();
+                if (tantargyfelosztasList.Count > 0)
+                {
+                    foreach (var tantargyfelosztas in tantargyfelosztasList)
+                    {
+                        string hetirendId = string.IsNullOrWhiteSpace(ascTimeCard.Het) ? tantargyfelosztas.LessonHetirendIdFromAsc : ascTimeCard.Het;
+                        orarendFromAscModelList.Add(new OrarendFromAscModel
+                        {
+                            Hetirend = ascHetirendList.Single(x => x.Id.Equals(hetirendId)).Nev,
+                            Nap = ascTimeCard.Nap,
+                            Ora = ascTimeCard.Sorszam,
+                            OsztalyNev = tantargyfelosztas.OsztalyNev,
+                            CsoportNev = tantargyfelosztas.CsoportNev,
+                            TantargyNev = tantargyfelosztas.TantargyNev,
+                            TanarNev = tantargyfelosztas.TanarNev,
+                            TeremNev = GetTeremNev(ascTimeCard.TeremIdListString, ascTeremList)
+                        });
+                    }
+                }
+            }
+
+            return orarendFromAscModelList;
+        }
+
+        private static List<AscHetirend> GetHetirendListFromAsc2008(timetable ascTimeTable)
+        {
+            var ascHetirendList = new List<AscHetirend>();
+            var hetirendNevList = new List<string> { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" };
+            int hetirendNevIndex = 0;
+
+            List<string> hetirendIdListFromAsc = new List<string>();
+            var hetirendCount = ascTimeTable.lessons.lesson[0].weeks.Length;
+            hetirendIdListFromAsc.Insert(0, string.Concat(Enumerable.Repeat("1", hetirendCount)));
+            var defaultHetirend = string.Concat(Enumerable.Repeat("0", hetirendCount));
+            if (hetirendCount > 1)
+            {
+                for (int i = 0; i < hetirendCount; i++)
+                {
+                    StringBuilder stringBuilder = new StringBuilder(defaultHetirend)
+                    {
+                        [i] = '1'
+                    };
+                    hetirendIdListFromAsc.Add(stringBuilder.ToString());
+                }
+            }
+
+            foreach (string hetirendIdFromAsc in hetirendIdListFromAsc)
+            {
+                if (!string.IsNullOrWhiteSpace(hetirendIdFromAsc))
+                {
+                    string hetNeve;
+                    string hetirendId;
+                    if (hetirendIdFromAsc.All(x => x.Equals('1')))
+                    {
+                        hetirendId = hetirendIdFromAsc;
+                        hetNeve = $"{CommonResource.MindenHeten}";
+                    }
+                    else
+                    {
+                        hetirendId = GenerateHetirendId(hetirendIdListFromAsc, hetirendNevIndex);
+                        hetNeve = $"{hetirendNevList[hetirendNevIndex]} {CommonResource.Het}";
+                        hetirendNevIndex++;
+                    }
+
+                    ascHetirendList.Add(new AscHetirend
+                    {
+                        Id = hetirendId,
+                        Nev = hetNeve
+                    });
+                }
+            }
+
+            return ascHetirendList;
+        }
+
+        private static string GenerateHetirendId(List<string> hetirendIdListByLesson, int hetirendNevIndex)
+        {
+            string tempString = string.Empty;
+            tempString = tempString.PadLeft(hetirendIdListByLesson.Count - 1, '0');
+            var stringBuilder = new StringBuilder(tempString)
+            {
+                [hetirendNevIndex] = '1'
+            };
+            string result = stringBuilder.ToString();
+            return result;
+        }
+
+        private static List<AscHetirend> GetHetirendListFromAsc(timetable ascTimeTable)
+        {
+            var ascHetirendList = new List<AscHetirend>();
+            foreach (timetableWeeksdefsWeeksdef het in ascTimeTable.weeksdefs.weeksdef)
+            {
+                ascHetirendList.Add(new AscHetirend
+                {
+                    Id = het.weeks,
+                    Nev = het.name.ReplaceMultipleSpacesAndTrim()
+                });
+            }
+
+            return ascHetirendList;
+        }
+
+        private static Dictionary<string, AscNapok> GetNapDictionaryFromAsc2008(timetable ascTimeTable)
+        {
+            var ascNapDictionary = new Dictionary<string, AscNapok>();
+            foreach (timetableDaysDays nap in ascTimeTable.days.days)
+            {
+                ascNapDictionary.Add(nap.day,
+                    new AscNapok
+                    {
+                        Id = nap.day,
+                        Nev = nap.name.ReplaceMultipleSpacesAndTrim()
+                    });
+            }
+
+            return ascNapDictionary;
+        }
+
+        private static Dictionary<string, AscNapok> GetNapDictionaryFromAsc(timetable ascTimeTable)
+        {
+            var ascNapDictionary = new Dictionary<string, AscNapok>();
+            foreach (timetableDaysdefsDaysdef nap in ascTimeTable.daysdefs.daysdef)
+            {
+                ascNapDictionary.Add(nap.days,
+                    new AscNapok
+                    {
+                        Id = nap.id,
+                        Nev = nap.name.ReplaceMultipleSpacesAndTrim(),
+                    });
+            }
+
+            return ascNapDictionary;
+        }
+
+        //NOTE: Itt a "card.day" kell!
+        private static List<AscTimeCards> GetAscTimeCardList2008(timetable ascTimeTable, Dictionary<string, AscNapok> ascNapDictionary)
+        {
+            var ascTimeCardList = new List<AscTimeCards>();
+            foreach (timetableCardsCard card in ascTimeTable.cards.card)
+            {
+                ascTimeCardList.Add(new AscTimeCards
+                {
+                    Sorszam = card.period,
+                    Het = string.IsNullOrWhiteSpace(card.weeks) ? string.Empty : card.weeks,
+                    Nap = ascNapDictionary[card.day].Nev,
+                    LessonId = card.lessonid,
+                    TeremIdListString = card.classroomids
+                });
+            }
+
+            return ascTimeCardList;
+        }
+
+        //NOTE: Itt a "card.days" kell!
+        private static List<AscTimeCards> GetAscTimeCardList(timetable ascTimeTable, Dictionary<string, AscNapok> ascNapDictionary)
+        {
+            var ascTimeCardList = new List<AscTimeCards>();
+            foreach (timetableCardsCard card in ascTimeTable.cards.card)
+            {
+                if (!ascTimeCardList.Any(x => x.LessonId == card.lessonid && x.Sorszam == card.period && x.Het == card.weeks && x.Nap == ascNapDictionary[card.days].Nev)) //A periodspercard miatt megegyszer ne fusson bele mert elso korben mar letrehozta (online xmlben tombonkent 1 card, dektopban minden ora kulon card)
+                {
+                    var lesson = ascTimeTable.lessons.lesson.SingleOrDefault(x => x.id == card.lessonid);
+                    var periodsPerCard = int.TryParse(lesson.periodspercard, out int result) ? result : 0;
+
+                    for (int i = 0; i < periodsPerCard; i++)
+                    {
+                        var newCard = new AscTimeCards
+                        {
+                            Sorszam = int.TryParse(card.period, out int period) ? (period + i).ToString() : card.period,
+                            Het = string.IsNullOrWhiteSpace(card.weeks) ? string.Empty : card.weeks,
+                            Nap = ascNapDictionary[card.days].Nev,
+                            LessonId = card.lessonid,
+                            TeremIdListString = card.classroomids
+                        };
+                        if (!ascTimeCardList.Any(x => x.LessonId == newCard.LessonId && x.Sorszam == newCard.Sorszam && x.Het == newCard.Het && x.Nap == newCard.Nap))
+                        {
+                            ascTimeCardList.Add(newCard);
+                        }
+                    }
+                }
+            }
+
+            return ascTimeCardList;
+        }
+
+        private static List<AscTerem> GetTeremListFromAsc(timetable ascTimeTable)
+        {
+            var ascTeremList = new List<AscTerem>();
+            foreach (timetableClassroomsClassroom terem in ascTimeTable.classrooms.classroom)
+            {
+                ascTeremList.Add(new AscTerem
+                {
+                    Id = terem.id,
+                    Nev = terem.name.ReplaceMultipleSpacesAndTrim()
+                });
+            }
+
+            return ascTeremList;
+        }
+
+        private static string GetTeremNev(string teremIdListString, List<AscTerem> ascTeremList)
+        {
+            List<string> teremIdList = teremIdListString.Split(',').ToList();
+            string teremNev = string.Empty;
+            foreach (string teremId in teremIdList)
+            {
+                if (!string.IsNullOrWhiteSpace(teremId))
+                {
+                    teremNev += ascTeremList.First(x => x.Id.Equals(teremId)).Nev;
+                }
+            }
+
+            return teremNev;
+        }
+
+        private static List<TantargyfelosztasFromAscModel> GetTantargyfelosztasFromAscModelList(timetable ascTimeTable)
+        {
+            List<LessonModel> lessonList = CreateLessonListFromAscXml(ascTimeTable);
+            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
+
+            //NOTE: 1A/I
+            List<LessonModel> filteredLessonList = GetFilteredLessonList(lessonList, isTobbOsztaly: false, isTobbCsoport: false, isTobbTanar: false, isNincsMegadvaOsztaly: false, isNincsMegadvaCsoport: false);
+            tantargyfelosztasFromAscModelList.AddRange(CreateTantargyfelosztasEgyOsztalyEgyCsoportEgyTanar(filteredLessonList));
+
+            //NOTE: 1A/II
+            filteredLessonList = GetFilteredLessonList(lessonList, isTobbOsztaly: false, isTobbCsoport: false, isTobbTanar: true, isNincsMegadvaOsztaly: false, isNincsMegadvaCsoport: false);
+            tantargyfelosztasFromAscModelList.AddRange(CreateTantargyfelosztasEgyOsztalyEgyCsoportTobbTanar(filteredLessonList));
+
+            //NOTE: 1B/I
+            filteredLessonList = GetFilteredLessonList(lessonList, isTobbOsztaly: false, isTobbCsoport: true, isTobbTanar: false, isNincsMegadvaOsztaly: false, isNincsMegadvaCsoport: false);
+            tantargyfelosztasFromAscModelList.AddRange(CreateTantargyfelosztasEgyOsztalyTobbCsoportEgyTanar(filteredLessonList));
+
+            //NOTE: 1B/II
+            filteredLessonList = GetFilteredLessonList(lessonList, isTobbOsztaly: false, isTobbCsoport: true, isTobbTanar: true, isNincsMegadvaOsztaly: false, isNincsMegadvaCsoport: false);
+            tantargyfelosztasFromAscModelList.AddRange(CreateTantargyfelosztasEgyOsztalyTobbCsoportTobbTanar(filteredLessonList));
+
+            //NOTE: 2B/I
+            filteredLessonList = GetFilteredLessonList(lessonList, isTobbOsztaly: true, isTobbCsoport: true, isTobbTanar: false, isNincsMegadvaOsztaly: false, isNincsMegadvaCsoport: false);
+            tantargyfelosztasFromAscModelList.AddRange(CreateTantargyfelosztasTobbOsztalyTobbCsoportEgyTanar(filteredLessonList));
+
+            //NOTE: 2B/II
+            filteredLessonList = GetFilteredLessonList(lessonList, isTobbOsztaly: true, isTobbCsoport: true, isTobbTanar: true, isNincsMegadvaOsztaly: false, isNincsMegadvaCsoport: false);
+            tantargyfelosztasFromAscModelList.AddRange(CreateTantargyfelosztasTobbOsztalyTobbCsoportTobbTanar(filteredLessonList));
+
+            //NOTE: 3C/I
+            filteredLessonList = GetFilteredLessonList(lessonList, isTobbOsztaly: false, isTobbCsoport: false, isTobbTanar: false, isNincsMegadvaOsztaly: true, isNincsMegadvaCsoport: true);
+            tantargyfelosztasFromAscModelList.AddRange(CreateTantargyfelosztasNincsOsztalyNincsCsoportEgyTanar(filteredLessonList));
+
+            //NOTE: 3C/II
+            filteredLessonList = GetFilteredLessonList(lessonList, isTobbOsztaly: false, isTobbCsoport: false, isTobbTanar: true, isNincsMegadvaOsztaly: true, isNincsMegadvaCsoport: true);
+            tantargyfelosztasFromAscModelList.AddRange(CreateTantargyfelosztasNincsOsztalyNincsCsoportTobbTanar(filteredLessonList));
+
+            return tantargyfelosztasFromAscModelList;
+        }
+
+        private static List<LessonModel> GetFilteredLessonList(List<LessonModel> lessonList, bool isTobbOsztaly, bool isTobbCsoport, bool isTobbTanar, bool isNincsMegadvaOsztaly, bool isNincsMegadvaCsoport)
+        {
+            List<LessonModel> result = lessonList.Where(x =>
+                x.IsTobbOsztaly == isTobbOsztaly &&
+                x.IsTobbCsoport == isTobbCsoport &&
+                x.IsTobbTanar == isTobbTanar &&
+                x.IsNincsMegadvaOsztaly == isNincsMegadvaOsztaly &&
+                x.IsNincsMegadvaCsoport == isNincsMegadvaCsoport).ToList();
+            return result;
+        }
+
+        private static List<TantargyfelosztasFromAscModel> CreateTantargyfelosztasEgyOsztalyEgyCsoportEgyTanar(List<LessonModel> filteredLessonList)
+        {
+            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
+            foreach (LessonModel lesson in filteredLessonList)
+            {
+                string osztalyNevFromLesson = lesson.OsztalyDictionary.SingleOrDefault().Value;
+
+                string csoportNevFromLesson = GetCsoportNevById(lesson.CsoportDictionary.SingleOrDefault().Key);
+                string osztalyCsoportNevFromLesson = $"{osztalyNevFromLesson} {csoportNevFromLesson}";
+
+                string osztalyNev = osztalyNevFromLesson;
+                string csoportNev = osztalyNevFromLesson.ToComparableString() == osztalyCsoportNevFromLesson.ToComparableString() ? string.Empty : osztalyCsoportNevFromLesson;
+                string tanarNev = lesson.TanarDictionary.SingleOrDefault().Value;
+                tantargyfelosztasFromAscModelList.Add(GetTantargyfelosztasFromAscModel(lesson, osztalyNev, csoportNev, tanarNev));
+            }
+
+            return tantargyfelosztasFromAscModelList;
+        }
+
+        private static List<TantargyfelosztasFromAscModel> CreateTantargyfelosztasEgyOsztalyEgyCsoportTobbTanar(List<LessonModel> filteredLessonList)
+        {
+            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
+            foreach (LessonModel lesson in filteredLessonList)
+            {
+                string osztalyNevFromLesson = lesson.OsztalyDictionary.SingleOrDefault().Value;
+                string csoportNevFromLesson = GetCsoportNevById(lesson.CsoportDictionary.SingleOrDefault().Key);
+                foreach (var tanar in lesson.TanarDictionary)
+                {
+                    string osztalyNev = osztalyNevFromLesson;
+                    string csoportNev = $"{osztalyNevFromLesson} {csoportNevFromLesson} - {lesson.TantargyNev} - {tanar.Value}";
+                    string tanarNev = tanar.Value;
+                    tantargyfelosztasFromAscModelList.Add(GetTantargyfelosztasFromAscModel(lesson, osztalyNev, csoportNev, tanarNev));
+                }
+            }
+
+            return tantargyfelosztasFromAscModelList;
+        }
+
+        private static List<TantargyfelosztasFromAscModel> CreateTantargyfelosztasEgyOsztalyTobbCsoportEgyTanar(List<LessonModel> filteredLessonList)
+        {
+            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
+            foreach (LessonModel lesson in filteredLessonList)
+            {
+                string csoportNevFromLesson = string.Join(", ", lesson.CsoportDictionary.Select(x => GetCsoportNevById(x.Key)).Where(x => !string.IsNullOrWhiteSpace(x)));
+
+                string osztalyNev = lesson.OsztalyDictionary.SingleOrDefault().Value;
+                string csoportNev = $"{osztalyNev} {csoportNevFromLesson}";
+                string tanarNev = lesson.TanarDictionary.SingleOrDefault().Value;
+                tantargyfelosztasFromAscModelList.Add(GetTantargyfelosztasFromAscModel(lesson, osztalyNev, csoportNev, tanarNev));
+            }
+
+            return tantargyfelosztasFromAscModelList;
+        }
+
+        private static List<TantargyfelosztasFromAscModel> CreateTantargyfelosztasEgyOsztalyTobbCsoportTobbTanar(List<LessonModel> filteredLessonList)
+        {
+            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
+            foreach (LessonModel lesson in filteredLessonList)
+            {
+                string csoportNevFromLesson = string.Join(", ", lesson.CsoportDictionary.Select(x => GetCsoportNevById(x.Key)).Where(x => !string.IsNullOrWhiteSpace(x)));
+
+                foreach (var tanar in lesson.TanarDictionary)
+                {
+                    string osztalyNev = lesson.OsztalyDictionary.SingleOrDefault().Value;
+                    string csoportNev = $"{osztalyNev} {csoportNevFromLesson} - {lesson.TantargyNev} - {tanar.Value}";
+                    string tanarNev = tanar.Value;
+                    tantargyfelosztasFromAscModelList.Add(GetTantargyfelosztasFromAscModel(lesson, osztalyNev, csoportNev, tanarNev));
+                }
+            }
+
+            return tantargyfelosztasFromAscModelList;
+        }
+
+        private static List<TantargyfelosztasFromAscModel> CreateTantargyfelosztasTobbOsztalyTobbCsoportEgyTanar(List<LessonModel> filteredLessonList)
+        {
+            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
+            foreach (LessonModel lesson in filteredLessonList)
+            {
+                List<List<string>> osztalyonkentiCsoportNevList = GetCsoportNevekOsztalyonkent(lesson);
+
+                bool isOsztalyonkentAzonosCsoportok = CheckOsztalyonkentAzonosCsoportok(osztalyonkentiCsoportNevList);
+
+                string osztalyCsoportNevFromLesson;
+                if (isOsztalyonkentAzonosCsoportok)
+                {
+                    List<string> osztalyNevList = lesson.OsztalyDictionary.Select(x => x.Value).ToList();
+                    string osztalyNevFromLesson = string.Join(", ", osztalyNevList);
+
+                    Dictionary<string, string> uniqueCsoportDictionary = GetDictionaryUniqueItemsByValue(lesson.CsoportDictionary);
+                    string csoportNevFromLesson = string.Join(", ", uniqueCsoportDictionary.Select(x => GetCsoportNevById(x.Key)).Where(x => !string.IsNullOrWhiteSpace(x)));
+
+                    osztalyCsoportNevFromLesson = $"{osztalyNevFromLesson} {csoportNevFromLesson}";
+                }
+                else
+                {
+                    string csoportNevFromLesson = string.Empty;
+                    foreach (var osztaly in lesson.OsztalyDictionary)
+                    {
+                        IEnumerable<AscCsoport> osztalyhozTartozoCsoportok = AscImportData.CsoportLista.Where(x => x.OsztalyId.Equals(osztaly.Key, StringComparison.OrdinalIgnoreCase) && lesson.CsoportDictionary.Select(c => c.Key).Contains(x.Id) && !AscEgeszOsztalyNevuCsoportIdList.Contains(x.Id));
+
+                        List<string> distinctCsoportNevek = osztalyhozTartozoCsoportok.Select(x => x.Nev).Distinct().ToList();
+                        string csoportNevListString = string.Join(", ", distinctCsoportNevek);
+
+                        csoportNevFromLesson += $"{osztaly.Value} {csoportNevListString}; ";
+                    }
+
+                    csoportNevFromLesson = csoportNevFromLesson.TrimEnd(' ', ';');
+
+                    osztalyCsoportNevFromLesson = csoportNevFromLesson;
+                }
+
+                //NOTE: Az osztály neve itt üres, mert ha több osztály van megadva az ASC-ben, akkor azok nálunk csoportonként jönnek létre pl.:
+                //      8.A, 8.B testnevelés, az nálunk egy közös csoport lesz.
+                string osztalyNev = string.Empty;
+                string csoportNev = osztalyCsoportNevFromLesson;
+                string tanarNev = lesson.TanarDictionary.SingleOrDefault().Value;
+                tantargyfelosztasFromAscModelList.Add(GetTantargyfelosztasFromAscModel(lesson, osztalyNev, csoportNev, tanarNev));
+            }
+
+            return tantargyfelosztasFromAscModelList;
+        }
+
+        private static List<TantargyfelosztasFromAscModel> CreateTantargyfelosztasTobbOsztalyTobbCsoportTobbTanar(List<LessonModel> filteredLessonList)
+        {
+            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
+            foreach (LessonModel lesson in filteredLessonList)
+            {
+                List<List<string>> osztalyonkentiCsoportNevList = GetCsoportNevekOsztalyonkent(lesson);
+
+                bool isOsztalyonkentAzonosCsoportok = CheckOsztalyonkentAzonosCsoportok(osztalyonkentiCsoportNevList);
+
+                string osztalyCsoportNevFromLesson;
+                if (isOsztalyonkentAzonosCsoportok)
+                {
+                    List<string> osztalyNevList = lesson.OsztalyDictionary.Select(x => x.Value).ToList();
+                    string osztalyNevFromLesson = string.Join(", ", osztalyNevList);
+
+                    Dictionary<string, string> uniqueCsoportDictionary = GetDictionaryUniqueItemsByValue(lesson.CsoportDictionary);
+                    string csoportNevFromLesson = string.Join(", ", uniqueCsoportDictionary.Select(x => GetCsoportNevById(x.Key)).Where(x => !string.IsNullOrWhiteSpace(x)));
+
+                    osztalyCsoportNevFromLesson = $"{osztalyNevFromLesson} {csoportNevFromLesson} - {lesson.TantargyNev}";
+                }
+                else
+                {
+                    string csoportNevFromLesson = string.Empty;
+                    foreach (var osztaly in lesson.OsztalyDictionary)
+                    {
+                        IEnumerable<AscCsoport> osztalyhozTartozoCsoportok = AscImportData.CsoportLista.Where(x => x.OsztalyId.Equals(osztaly.Key, StringComparison.OrdinalIgnoreCase) && lesson.CsoportDictionary.Select(c => c.Key).Contains(x.Id) && !AscEgeszOsztalyNevuCsoportIdList.Contains(x.Id));
+
+                        List<string> distinctCsoportNevek = osztalyhozTartozoCsoportok.Select(x => x.Nev).Distinct().ToList();
+                        string csoportNevListString = string.Join(", ", distinctCsoportNevek);
+
+                        csoportNevFromLesson += $"{osztaly.Value} {csoportNevListString}; ";
+                    }
+
+                    csoportNevFromLesson = csoportNevFromLesson.TrimEnd(' ', ';');
+
+                    osztalyCsoportNevFromLesson = $"{csoportNevFromLesson} - {lesson.TantargyNev} ";
+                }
+
+                foreach (var tanar in lesson.TanarDictionary)
+                {
+                    //NOTE: Az osztály neve itt üres, mert ha több osztály van megadva az ASC-ben, akkor azok nálunk csoportonként jönnek létre pl.:
+                    //      8.A, 8.B testnevelés, az nálunk egy közös csoport lesz.
+                    string osztalyNev = string.Empty;
+                    string csoportNev = $"{osztalyCsoportNevFromLesson} - {tanar.Value}";
+                    string tanarNev = tanar.Value;
+                    tantargyfelosztasFromAscModelList.Add(GetTantargyfelosztasFromAscModel(lesson, osztalyNev, csoportNev, tanarNev));
+                }
+            }
+
+            return tantargyfelosztasFromAscModelList;
+        }
+
+        private static List<TantargyfelosztasFromAscModel> CreateTantargyfelosztasNincsOsztalyNincsCsoportEgyTanar(List<LessonModel> filteredLessonList)
+        {
+            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
+            foreach (LessonModel lesson in filteredLessonList)
+            {
+                string tanarNevFromLesson = lesson.TanarDictionary.SingleOrDefault().Value;
+                int counter = tantargyfelosztasFromAscModelList.Select(x => x.CsoportNev).Count(x => x.Contains($"{lesson.TantargyNev} - {tanarNevFromLesson}")) + 1;
+
+                //NOTE: Az osztály neve itt üres, mert ha több osztály van megadva az ASC-ben, akkor azok nálunk csoportonként jönnek létre pl.:
+                //      8.A, 8.B testnevelés, az nálunk egy közös csoport lesz.
+                string osztalyNev = string.Empty;
+                string csoportNev = $"{lesson.TantargyNev} - {tanarNevFromLesson} {counter}";
+                string tanarNev = tanarNevFromLesson;
+                tantargyfelosztasFromAscModelList.Add(GetTantargyfelosztasFromAscModel(lesson, osztalyNev, csoportNev, tanarNev));
+            }
+
+            return tantargyfelosztasFromAscModelList;
+        }
+
+        private static List<TantargyfelosztasFromAscModel> CreateTantargyfelosztasNincsOsztalyNincsCsoportTobbTanar(List<LessonModel> filteredLessonList)
+        {
+            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
+            foreach (LessonModel lesson in filteredLessonList)
+            {
+                foreach (var tanar in lesson.TanarDictionary)
+                {
+                    string tanarNevFromLesson = tanar.Value;
+
+                    int counter = tantargyfelosztasFromAscModelList.Select(x => x.CsoportNev).Count(x => x.Contains($"{lesson.TantargyNev} - {tanarNevFromLesson}")) + 1;
+
+                    //NOTE: Az osztály neve itt üres, mert ha több osztály van megadva az ASC-ben, akkor azok nálunk csoportonként jönnek létre pl.:
+                    //      8.A, 8.B testnevelés, az nálunk egy közös csoport lesz.
+                    string osztalyNev = string.Empty;
+                    string csoportNev = $"{lesson.TantargyNev} - {tanarNevFromLesson} {counter}";
+                    string tanarNev = tanarNevFromLesson;
+                    tantargyfelosztasFromAscModelList.Add(GetTantargyfelosztasFromAscModel(lesson, osztalyNev, csoportNev, tanarNev));
+                }
+            }
+
+            return tantargyfelosztasFromAscModelList;
+        }
+
+        private static TantargyfelosztasFromAscModel GetTantargyfelosztasFromAscModel(LessonModel lesson, string osztalyNev, string csoportNev, string tanarNev)
+        {
+            var tantargyfelosztas = new TantargyfelosztasFromAscModel
+            {
+                Id = lesson.LessonIdFromAscXml.ReplaceMultipleSpacesAndTrim(),
+                TantargyNev = lesson.TantargyNev.ReplaceMultipleSpacesAndTrim(),
+                Oraszam = lesson.HetiOraszam.ReplaceMultipleSpacesAndTrim(),
+                LessonHetirendIdFromAsc = lesson.LessonHetirendId.ReplaceMultipleSpacesAndTrim(),
+
+                OsztalyNev = osztalyNev.ReplaceMultipleSpacesAndTrim(),
+                CsoportNev = csoportNev.ReplaceMultipleSpacesAndTrim(),
+                TanarNev = tanarNev.ReplaceMultipleSpacesAndTrim()
+            };
+            return tantargyfelosztas;
+        }
+
+        private static List<List<string>> GetCsoportNevekOsztalyonkent(LessonModel lesson)
+        {
+            var osztalyonkentiCsoportNevList = new List<List<string>>();
+            foreach (var osztaly in lesson.OsztalyDictionary)
+            {
+                IEnumerable<AscCsoport> osztalyhozTartozoCsoportok = AscImportData.CsoportLista.Where(x => x.OsztalyId.Equals(osztaly.Key, StringComparison.OrdinalIgnoreCase) && lesson.CsoportDictionary.Select(c => c.Key).Contains(x.Id));
+                osztalyonkentiCsoportNevList.Add(osztalyhozTartozoCsoportok.Select(x => x.Nev).OrderBy(x => x).ToList());
+            }
+
+            return osztalyonkentiCsoportNevList;
+        }
+
+        private static Dictionary<string, string> GetDictionaryUniqueItemsByValue(Dictionary<string, string> dictionary)
+        {
+            Dictionary<string, string> result = dictionary
+                .GroupBy(x => x.Value)
+                .Select(x => x.First())
+                .OrderBy(x => x.Value)
+                .ToDictionary(x => x.Key, x => x.Value);
+            return result;
+        }
+
+        private static bool CheckOsztalyonkentAzonosCsoportok(List<List<string>> osztalyonkentiCsoportNevList)
+        {
+            bool isOsztalyonkentEgyezoCsoport = true;
+            for (int i = 1; i < osztalyonkentiCsoportNevList.Count; i++)
+            {
+                isOsztalyonkentEgyezoCsoport = isOsztalyonkentEgyezoCsoport && osztalyonkentiCsoportNevList[0].ToList().SequenceEqual(osztalyonkentiCsoportNevList[i].ToList());
+            }
+
+            return isOsztalyonkentEgyezoCsoport;
+        }
+
+        private static string GetCsoportNevById(string csoportId)
+        {
+            AscCsoport csoport = AscImportData.CsoportLista.SingleOrDefault(x => x.Id.Equals(csoportId));
+            string csoportNev = string.Empty;
+            if (csoport != null)
+            {
+                csoportNev = AscEgeszOsztalyNevuCsoportIdList.Contains(csoport.Id) ? string.Empty : csoport.Nev;
+            }
+
+            return csoportNev;
+        }
+
+        private static List<LessonModel> CreateLessonListFromAscXml(timetable ascTimeTable)
+        {
+            var lessonList = new List<LessonModel>();
+
+            AscImportData.OsztalyLista = GetOsztalyListFromAsc(ascTimeTable.classes?.@class?.ToList() ?? new List<timetableClassesClass>());
+            AscImportData.CsoportLista = GetCsoportListFromAsc(ascTimeTable.groups?.group?.ToList() ?? new List<timetableGroupsGroup>());
+            AscImportData.TantargyLista = GetTantargyListFromAsc(ascTimeTable.subjects.subject.ToList());
+            AscImportData.TanarLista = GetTanarListFromAsc(ascTimeTable.teachers.teacher.ToList());
+
+            AscEgeszOsztalyNevuCsoportIdList = AscImportData.CsoportLista.Where(x => x.FelosztasId == "0").Select(x => x.Id).ToList();
+
+            foreach (timetableLessonsLesson lessonItem in ascTimeTable.lessons.lesson)
+            {
+                var tantargy = AscImportData.TantargyLista.SingleOrDefault(x => x.Id == lessonItem.subjectid);
+                string tantargyNev = string.Empty;
+                if (tantargy != null)
+                {
+                    tantargyNev = tantargy.Nev;
+                }
+
+                var lesson = new LessonModel
+                {
+                    OsztalyDictionary = GetOsztalyDictionary(lessonItem.classids, AscImportData.OsztalyLista),
+                    CsoportDictionary = GetCsoportDictionary(lessonItem.groupids, AscImportData.CsoportLista),
+                    TanarDictionary = GetTanarDictionary(lessonItem.teacherids, AscImportData.TanarLista),
+                    TantargyNev = tantargyNev,
+                    HetiOraszam = lessonItem.periodsperweek,
+                    LessonHetirendId = string.IsNullOrWhiteSpace(lessonItem.weeksdefid) ? lessonItem.weeks : lessonItem.weeksdefid,
+                    LessonIdFromAscXml = lessonItem.id
+                };
+                lesson.IsTobbOsztaly = lesson.OsztalyDictionary.Count > 1;
+                lesson.IsTobbCsoport = lesson.CsoportDictionary.Count > 1;
+                lesson.IsTobbTanar = lesson.TanarDictionary.Count > 1;
+                lesson.IsNincsMegadvaOsztaly = lesson.OsztalyDictionary.Count == 0;
+                lesson.IsNincsMegadvaCsoport = lesson.CsoportDictionary.Count == 0;
+
+                lessonList.Add(lesson);
+            }
+
+            return lessonList;
+        }
+
+        private static List<AscOsztaly> GetOsztalyListFromAsc(List<timetableClassesClass> classList)
+        {
+            var ascOsztalyList = new List<AscOsztaly>();
+            foreach (timetableClassesClass osztaly in classList)
+            {
+                ascOsztalyList.Add(new AscOsztaly
+                {
+                    Id = osztaly.id,
+                    Nev = osztaly.name.ReplaceMultipleSpacesAndTrim()
+                });
+            }
+
+            return ascOsztalyList;
+        }
+
+        private static List<AscCsoport> GetCsoportListFromAsc(List<timetableGroupsGroup> groupList)
+        {
+            var ascCsoportList = new List<AscCsoport>();
+            foreach (timetableGroupsGroup csoport in groupList)
+            {
+                csoport.divisiontag = string.IsNullOrWhiteSpace(csoport.divisiontag) ? "0" : csoport.divisiontag;
+                ascCsoportList.Add(new AscCsoport
+                {
+                    Id = csoport.id,
+                    Nev = csoport.name.ReplaceMultipleSpacesAndTrim(),
+                    OsztalyId = csoport.classid,
+                    FelosztasId = csoport.divisiontag
+                });
+            }
+
+            return ascCsoportList;
+        }
+
+        private static List<AscTantargy> GetTantargyListFromAsc(List<timetableSubjectsSubject> subjectList)
+        {
+            var ascTantargyList = new List<AscTantargy>();
+            foreach (timetableSubjectsSubject tantargy in subjectList)
+            {
+                ascTantargyList.Add(new AscTantargy
+                {
+                    Id = tantargy.id,
+                    Nev = tantargy.name.ReplaceMultipleSpacesAndTrim(),
+                });
+            }
+
+            return ascTantargyList;
+        }
+
+        private static List<AscTanar> GetTanarListFromAsc(List<timetableTeachersTeacher> teacherList)
+        {
+            var ascTanarList = new List<AscTanar>();
+            foreach (timetableTeachersTeacher tanar in teacherList)
+            {
+                ascTanarList.Add(new AscTanar
+                {
+                    Id = tanar.id,
+                    Nev = tanar.name.ReplaceMultipleSpacesAndTrim()
+                });
+            }
+
+            return ascTanarList;
+        }
+
+        private static Dictionary<string, string> GetOsztalyDictionary(string osztalyIdListString, List<AscOsztaly> ascOsztalyList)
+        {
+            var osztalyDictionary = new Dictionary<string, string>();
+            if (!string.IsNullOrWhiteSpace(osztalyIdListString))
+            {
+                foreach (string osztalyId in osztalyIdListString.Split(',').ToList())
+                {
+                    var osztaly = ascOsztalyList.SingleOrDefault(x => x.Id.Equals(osztalyId));
+                    if (osztaly != null)
+                    {
+                        osztalyDictionary.Add(osztalyId, osztaly.Nev);
+                    }
+                }
+            }
+
+            return osztalyDictionary;
+        }
+
+        private static Dictionary<string, string> GetCsoportDictionary(string csoportIdListString, List<AscCsoport> ascCsoportList)
+        {
+            var csoportDictionary = new Dictionary<string, string>();
+            if (!string.IsNullOrWhiteSpace(csoportIdListString))
+            {
+                foreach (string csoportId in csoportIdListString.Split(',').ToList())
+                {
+                    var csoport = ascCsoportList.SingleOrDefault(x => x.Id.Equals(csoportId));
+                    if (csoport != null)
+                    {
+                        csoportDictionary.Add(csoportId, csoport.Nev);
+                    }
+                }
+            }
+
+            return csoportDictionary;
+        }
+
+        private static Dictionary<string, string> GetTanarDictionary(string tanarIdListString, List<AscTanar> ascTanarList)
+        {
+            var tanarDictionary = new Dictionary<string, string>();
+            if (!string.IsNullOrWhiteSpace(tanarIdListString))
+            {
+                foreach (string tanarId in tanarIdListString.Split(',').ToList())
+                {
+                    var tanar = ascTanarList.SingleOrDefault(x => x.Id.Equals(tanarId));
+                    if (tanar != null && !tanarDictionary.ContainsKey(tanar.Id))
+                    {
+                        tanarDictionary.Add(tanarId, tanar.Nev);
+                    }
+                }
+            }
+
+            return tanarDictionary;
+        }
+
+        public MemoryStream ConvertAscXmlToExcel(Stream ascImportFileStream)
+        {
+            var dropDownColumnSourceDictionary = new OrarendImportExportHelper(ConnectionType).GetDefaultDropDownColumnSourceDictionary(false);
+            List<List<string>> importData = GetOrarendImportDataFromAsc(ascImportFileStream, DateTime.Now.ToShortDateString(), DateTime.Now.ToShortDateString());
+            using (var workbook = new Workbook())
+            {
+                List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos(OrarendImportExportHelper.ImportHeaderList, dropDownColumnSourceDictionary);
+                Worksheet worksheet = SimpleExportLogic.GetWorksheet(workbook, ImportExportOrarendResource.OrarendImport, simpleExportColumnCos);
+
+                int rowIndex = 1;
+                //NOTE: A Skip(1), azért kell, mert az asc-ből generált string listába beletesszük a header-öket az importálásokhoz, de a konvertáláshoz mi saját header-t generálunk!
+                foreach (List<string> importDataRow in importData.Skip(1))
+                {
+                    int columnIndex = 0;
+                    //NOTE: A Skip(2), azért kell, mert az óra érvényességi idők(kezdete, vége) nincs benne az xml-ben, viszont, mi belegeneráljuk a string lista első két elemeként!
+                    foreach (string importDataCell in importDataRow.Skip(2).ToList())
+                    {
+                        worksheet.Cells[rowIndex, columnIndex].Value = importDataCell;
+                        columnIndex++;
+                    }
+
+                    rowIndex++;
+                }
+
+                MemoryStream memoryStream = SimpleExportLogic.GetWorkbookMemoryStream(workbook);
+                return memoryStream;
+            }
+        }
+    }
+
+    public class TantargyfelosztasFromAscModel : BaseTantargyfelosztasFromAscModel
+    {
+        public string Oraszam { get; set; }
+
+        public string LessonHetirendIdFromAsc { get; set; }
+    }
+
+    public class OrarendFromAscModel : BaseTantargyfelosztasFromAscModel
+    {
+        public string Hetirend { get; set; }
+
+        public string Nap { get; set; }
+
+        public string Ora { get; set; }
+
+        public string TeremNev { get; set; }
+    }
+
+    public class BaseTantargyfelosztasFromAscModel
+    {
+        public string Id { get; set; }
+
+        public string OsztalyNev { get; set; }
+
+        public string CsoportNev { get; set; }
+
+        public string TantargyNev { get; set; }
+
+        public string TanarNev { get; set; }
+    }
+}

Kreta.BusinessLogic/Helpers/ImportExport/BaseTantargyfelosztasImportExportHelper.cs

@@ -0,0 +1,164 @@
+using System.Collections.Generic;
+using System.Linq;
+using Kreta.BusinessLogic.Classes;
+using Kreta.BusinessLogic.HelperClasses;
+using Kreta.BusinessLogic.HelperClasses.ImportCo;
+using Kreta.Core.ConnectionType;
+using Kreta.Enums.ManualEnums.ImportExport;
+
+namespace Kreta.BusinessLogic.Helpers.ImportExport
+{
+    public class BaseTantargyfelosztasImportExportHelper : LogicBase
+    {
+        public BaseTantargyfelosztasImportExportHelper(IConnectionType connectionType) : base(connectionType) { }
+
+        protected static void SetOperationTantargy(BaseTantargyfelosztasImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary)
+        {
+            var compareHash = importItem.CompareHashTantargy;
+            //NOTE: Ha nem találtunk egyezést, akkor Insert!
+            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+            {
+                importItem.OperationTantargy = (int)ImportItemOperationEnum.Insert;
+            }
+        }
+
+        protected static void SetOperationOsztaly(BaseTantargyfelosztasImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary)
+        {
+            var compareHash = importItem.CompareHashOsztaly;
+            if (!string.IsNullOrWhiteSpace(compareHash))
+            {
+                //NOTE: Ha nem találtunk egyezést, akkor Insert!
+                if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+                {
+                    importItem.OperationOsztaly = (int)ImportItemOperationEnum.Insert;
+                }
+            }
+        }
+
+        protected static void SetOperationCsoport(BaseTantargyfelosztasImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary)
+        {
+            var compareHash = importItem.CompareHashCsoport;
+            if (!string.IsNullOrWhiteSpace(compareHash))
+            {
+                //NOTE: Ha nem találtunk egyezést, akkor Insert!
+                if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+                {
+                    importItem.OperationCsoport = (int)ImportItemOperationEnum.Insert;
+                }
+            }
+        }
+
+        protected Dictionary<string, ImportItemCompareCo> GetTantargyCompareHashImportItemCompareCoDictionary()
+        {
+            List<TantargyItemCo> coList = new TantargyHelper(ConnectionType).GetTantargyCoList();
+
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (TantargyItemCo co in coList)
+            {
+                string md5HashInput = co.NevComparableString;
+                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;
+        }
+
+        protected Dictionary<string, ImportItemCompareCo> GetOsztalyCompareHashImportItemCompareCoDictionary()
+        {
+            List<OsztalyItemCo> coList = new OsztalyHelper(ConnectionType).GetOsztalyCoList();
+
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (OsztalyItemCo co in coList)
+            {
+                string md5HashInput = co.NevComparableString;
+                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;
+        }
+
+        protected Dictionary<string, ImportItemCompareCo> GetCsoportCompareHashImportItemCompareCoDictionary()
+        {
+            List<CsoportItemCo> coList = new CsoportHelper(ConnectionType).GetCsoportCoList();
+
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (CsoportItemCo co in coList)
+            {
+                string md5HashInput = co.NevComparableString;
+                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;
+        }
+
+        protected Dictionary<string, ImportItemCompareCo> GetTantargyfelosztasCompareHashImportItemCompareCoDictionary(List<BaseTantargyfelosztasImportItemCo> baseTantargyfelosztasImportItemList)
+        {
+            List<TantargyfelosztasItemCo> coList = new TantargyFelosztasHelper(ConnectionType).GetTantargyfelosztasCoList();
+
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (TantargyfelosztasItemCo co in coList)
+            {
+                var md5HashInput =
+                    co.OsztalyCsoportNevComparableString +
+                    co.TantargyNevComparableString +
+                    co.TanarNevComparableString;
+                //NOTE: Ha a tanar neve szerepel az import-ban és van hozzá tartozó születési idő, akkor hozzá kell tenni a compare-he a születési idő-t is
+                if (baseTantargyfelosztasImportItemList.Any(x => x.TanarNev.ToComparableString() == co.TanarNevComparableString && x.TanarSzuletesiIdo.HasValue))
+                {
+                    md5HashInput += co.TanarSzuletesiIdoComparableString;
+                }
+
+                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;
+        }
+    }
+}

Kreta.BusinessLogic/Helpers/ImportExport/EszkozImportExportHelper.cs

@@ -0,0 +1,278 @@
+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;
+
+namespace Kreta.BusinessLogic.Helpers.ImportExport
+{
+    public class EszkozImportExportHelper : LogicBase
+    {
+        #region Fields
+
+        private readonly string _importObjectCacheKey;
+
+        #endregion Fields
+
+        #region Properties
+
+        public static Dictionary<int, string> ImportHeaderList => new Dictionary<int, string>
+        {
+            { 00, ImportExportEszkozResource.ImportHeaderNameEszkozNeve },
+            { 01, ImportExportEszkozResource.ImportHeaderNameHelyiseg },
+            { 02, ImportExportEszkozResource.ImportHeaderNameEszkozTipus },
+            { 03, ImportExportEszkozResource.ImportHeaderNameMennyiseg },
+            { 04, ImportExportEszkozResource.ImportHeaderNameEszkozSzemelyiFelelose },
+            { 05, ImportExportEszkozResource.ImportHeaderNameLeltariSzam }
+        };
+
+        public EszkozImportCo ImportCo
+        {
+            get => (EszkozImportCo)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 EszkozImportExportHelper(IConnectionType connectionType) : base(connectionType)
+        {
+            _importObjectCacheKey = $"{nameof(EszkozImportCo)}_{IntezmenyId}_{FelhasznaloId}_ImportObjectCacheKey";
+        }
+
+        #endregion Constructors
+
+        public void SetImportCo(List<List<string>> importData, int importMuvelet)
+        {
+            EszkozImportCo importCo = GetImportCoFromImportData(importData);
+            importCo.ImportMuvelet = importMuvelet;
+
+            SetNemImportalhatoSorokByValidation(importCo);
+
+            SetOperationAndNemImportalhatoSorokByOperation(importCo);
+
+            var mainImportJsonItemList = new List<EszkozImportJsonItemCo>(importCo.MainImportItemList.Select(x => new EszkozImportJsonItemCo(x, importCo.TeremCoList, importCo.FelelosCoList, TanevId, IntezmenyId, FelhasznaloId)));
+            importCo.MainImportJsonItemList = mainImportJsonItemList;
+
+            ImportCo = importCo;
+        }
+
+        private static void SetNemImportalhatoSorokByValidation(EszkozImportCo importCo)
+        {
+            Dictionary<int, List<ValidationResult>> validationResultDictionary = importCo.Validate();
+
+            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
+            foreach (EszkozImportItemCo 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(EszkozImportCo importCo)
+        {
+            int importMuvelet = importCo.ImportMuvelet;
+            //NOTE: Azért van szükség Dictionary-re, mert így sokkal gyorsabb a keresés!
+            Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary = GetCompareHashImportItemCompareCoDictionary(importCo.EszkozCoList);
+            foreach (EszkozImportItemCo 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...
+                else
+                {
+                    ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                    //NOTE: ...ha az import művelet DeleteAndInsert és a db-ből jövő adat Importalt(a nem importáltakat egyelőre nem töröljük), akkor Insert, mert töröljük a korábbi elemeket és újra be kell szúrni!
+                    if (importMuvelet == (int)ImportMuveletEnum.DeleteAndInsert && importItemCompareCo.Importalt)
+                    {
+                        importItem.Operation = (int)ImportItemOperationEnum.Insert;
+                    }
+                    //NOTE: ...ha nincs törlés, akkor...
+                    else
+                    {
+                        //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
+                        if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                        {
+                            importItem.Id = importItemCompareCo.Id;
+                            importItem.Operation = (int)ImportItemOperationEnum.Update;
+                        }
+                        //NOTE: ...ha a művelet nem InsertAndUpdate, akkor hozzá kell adni a nem NemImportalhatoItemList-hez és jelezni, hogy már szerepel az adatbázisban(Insert vagy DeleteAndInsert műveletnél. A DeleteAndInsert csak akkor fut be ide, ha az elem nem importált.)!
+                        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 EszkozImportCo GetImportCoFromImportData(List<List<string>> importData)
+        {
+            var importCo = new EszkozImportCo
+            {
+                EszkozCoList = new EszkozHelper(ConnectionType).GetEszkozCoList(),
+                FelelosCoList = new AlkalmazottHelper(ConnectionType).GetAlkalmazottCoList(),
+                TeremCoList = new TeremHelper(ConnectionType).GetTeremCoList(),
+            };
+
+            int lineNumber = 1;
+            foreach (List<string> importDataRow in importData.Skip(1))
+            {
+                var importItemCo = new EszkozImportItemCo(TanevId)
+                {
+                    LineNumber = lineNumber,
+
+                    EszkozNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportEszkozResource.ImportHeaderNameEszkozNeve)],
+                    HelyisegImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportEszkozResource.ImportHeaderNameHelyiseg)],
+                    EszkozTipusImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportEszkozResource.ImportHeaderNameEszkozTipus)],
+                    DarabszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportEszkozResource.ImportHeaderNameMennyiseg)],
+                    EszkozSzemelyiFeleloseImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportEszkozResource.ImportHeaderNameEszkozSzemelyiFelelose)],
+                    LeltariSzamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportEszkozResource.ImportHeaderNameLeltariSzam)]
+                };
+
+                string md5HashInput = importItemCo.Nev?.ToComparableString();
+                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                importCo.MainImportItemList.Add(importItemCo);
+
+                lineNumber++;
+            }
+
+            return importCo;
+        }
+
+        #region Template
+
+        public MemoryStream GetTemplate()
+        {
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<EszkozItemCo>(EszkozItemCo.EszkozTemplateExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
+            return SimpleExportLogic.GetTemplate(ImportExportEszkozResource.ImportDefaultSheetName, simpleExportColumnCos);
+        }
+
+        #endregion Template
+
+        #region Export
+
+        public MemoryStream GetExport()
+        {
+            List<EszkozItemCo> coList = new EszkozHelper(ConnectionType).GetEszkozCoList().OrderBy(o => o.Nev).ToList();
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<EszkozItemCo>(EszkozItemCo.EszkozExportAttributeId, GetExportDropDownColumnSourceDictionary());
+            return SimpleExportLogic.GetExport(ImportExportEszkozResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        public MemoryStream GetEszkozKeresesExport(EszkozokSearchCo co)
+        {
+            List<EszkozItemCo> coList = new EszkozHelper(ConnectionType).GetEszkozKeresesExport(co).OrderBy(o => o.Nev).ToList();
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<EszkozItemCo>(EszkozItemCo.EszkozExportAttributeId);
+            return SimpleExportLogic.GetExport(ImportExportEszkozResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        public MemoryStream GetNemImportalhatoSorokExport()
+        {
+            List<EszkozImportItemCo> coList = ImportCo.NemImportalhatoItemList;
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<EszkozImportItemCo>(EszkozImportItemCo.NemImportalhatoSorokExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
+            return ImportExportHelper.NemImportalhatoSorokExport(ImportExportEszkozResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        #endregion Export
+
+        private Dictionary<string, ImportItemCompareCo> GetCompareHashImportItemCompareCoDictionary(IList<EszkozItemCo> coList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (EszkozItemCo co in coList)
+            {
+                string md5HashInput = co.NevComparableString;
+                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;
+        }
+
+        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary()
+        {
+            //NOTE: Create dropdown lists
+            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>();
+
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                var connectionType = new DalHandlerConnectionType(ConnectionType, dalHandler);
+
+                dropDownColumnSourceDictionary.Add(ImportExportEszkozResource.ImportHeaderNameEszkozTipus, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.EszkozTipus));
+
+                var helper = new ImportExportHelper(connectionType);
+                dropDownColumnSourceDictionary.Add(ImportExportEszkozResource.ImportHeaderNameHelyiseg, helper.GetTeremList());
+                dropDownColumnSourceDictionary.Add(ImportExportEszkozResource.ImportHeaderNameEszkozSzemelyiFelelose, helper.GetTanarList(true));
+            });
+
+            return dropDownColumnSourceDictionary;
+        }
+
+        private Dictionary<string, IList<string>> GetExportDropDownColumnSourceDictionary()
+        {
+            //NOTE: Create dropdown lists
+            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>();
+
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                var connectionType = new DalHandlerConnectionType(ConnectionType, dalHandler);
+
+                dropDownColumnSourceDictionary.Add(ImportExportEszkozResource.ImportHeaderNameEszkozTipus, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.EszkozTipus));
+                dropDownColumnSourceDictionary.Add(ImportExportEszkozResource.ExportHeaderNameKategoria, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.EszkozKategoria));
+                dropDownColumnSourceDictionary.Add(ImportExportEszkozResource.ExportHeaderNameCel, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.EszkozCel));
+                dropDownColumnSourceDictionary.Add(ImportExportEszkozResource.ExportHeaderNameJelleg, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.EszkozJelleg));
+                dropDownColumnSourceDictionary.Add(ImportExportEszkozResource.ExportHeaderNameMennyisegiEgyseg, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.MertekegysegTipus));
+
+                var helper = new ImportExportHelper(connectionType);
+                dropDownColumnSourceDictionary.Add(ImportExportEszkozResource.ImportHeaderNameHelyiseg, helper.GetTeremList());
+                dropDownColumnSourceDictionary.Add(ImportExportEszkozResource.ImportHeaderNameEszkozSzemelyiFelelose, helper.GetTanarList(true));
+            });
+
+            return dropDownColumnSourceDictionary;
+        }
+    }
+}

Kreta.BusinessLogic/Helpers/ImportExport/FelhasznaloBelepesImportExportHelper.cs

@@ -0,0 +1,465 @@
+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;
+using Kreta.Enums.ManualEnums.ImportExport;
+using Kreta.Resources;
+
+namespace Kreta.BusinessLogic.Helpers.ImportExport
+{
+    public class FelhasznaloBelepesImportExportHelper : LogicBase
+    {
+        #region Fields
+
+        private readonly string _importObjectCacheKey;
+
+        #endregion Fields
+
+        #region Properties
+
+        public static Dictionary<int, string> ImportHeaderListForAlkalmazott => new Dictionary<int, string>
+        {
+            { 00, ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottNeve },
+            { 01, ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottOktatasiAzonosito },
+            { 02, ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottSzuletesiDatuma },
+            { 03, ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottFelhasznaloneve },
+            { 04, ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottJelszava }
+        };
+
+        public static Dictionary<int, string> ImportHeaderListForTanulo => new Dictionary<int, string>
+        {
+            { 00, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNevSzulidoOktazon },
+            { 01, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloFelhasznaloneve },
+            { 02, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloJelszava }
+        };
+
+        public static Dictionary<int, string> ImportHeaderListForGondviselo => new Dictionary<int, string>
+        {
+            { 00, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNeve },
+            { 01, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloOktatasiAzonosito },
+            { 02, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloSzuletesiDatuma },
+            { 03, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloOsztalya },
+            { 04, ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloNeve },
+            { 05, ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloRokonsagiFoka },
+            { 06, ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloFelhasznaloneve },
+            { 07, ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloJelszava }
+        };
+
+        public FelhasznaloBelepesImportCo ImportCo
+        {
+            get => (FelhasznaloBelepesImportCo)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 FelhasznaloBelepesImportExportHelper(IConnectionType connectionType) : base(connectionType)
+        {
+            _importObjectCacheKey = $"{nameof(FelhasznaloBelepesImportCo)}_{IntezmenyId}_{FelhasznaloId}_ImportObjectCacheKey";
+        }
+
+        #endregion Constructors
+
+        public void SetImportCo(List<List<string>> importData, int importMuvelet, FelhasznaloBelepesExportImportTipusEnum tipusEnum, bool isGeneraltFileLetoltes, bool isEmailKuldes, int? anotherYearId, bool isKovTanev, bool isSzakkepzoIntezmeny)
+        {
+            FelhasznaloBelepesImportCo importCo = GetImportCoFromImportData(importData, tipusEnum, anotherYearId, isKovTanev);
+            importCo.ImportMuvelet = importMuvelet;
+            importCo.IsGeneraltFileLetoltes = isGeneraltFileLetoltes;
+            importCo.IsEmailKuldes = isEmailKuldes;
+            importCo.TipusEnum = tipusEnum;
+
+            Dictionary<int, List<ValidationResult>> validationResultDictionary = importCo.Validate(ConnectionType, isSzakkepzoIntezmeny);
+            SetNemImportalhatoSorokByValidation(importCo, validationResultDictionary);
+
+            SetOperationAndNemImportalhatoSorokByOperation(importCo);
+
+            var mainImportJsonItemList = new List<FelhasznaloBelepesImportJsonItemCo>(importCo.MainImportItemList.Select(x => new FelhasznaloBelepesImportJsonItemCo(x, TanevId, IntezmenyId, FelhasznaloId)));
+            importCo.MainImportJsonItemList = mainImportJsonItemList;
+
+            ImportCo = importCo;
+        }
+
+        private static void SetNemImportalhatoSorokByValidation(FelhasznaloBelepesImportCo importCo, Dictionary<int, List<ValidationResult>> validationResultDictionary)
+        {
+            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
+            foreach (FelhasznaloBelepesImportItemCo 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(FelhasznaloBelepesImportCo importCo)
+        {
+            int importMuvelet = importCo.ImportMuvelet;
+            //NOTE: Azért van szükség Dictionary-re, mert így sokkal gyorsabb a keresés!
+            Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary = GetCompareHashImportItemCompareCoDictionary(importCo.FelhasznaloBelepesCoList, importCo.TipusEnum);
+            foreach (FelhasznaloBelepesImportItemCo importItem in importCo.MainImportItemList)
+            {
+                string compareHash = importItem.CompareHash;
+                ImportItemCompareCo importItemCompareCo = null;
+                if (compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+                {
+                    importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                }
+
+                //NOTE: Ha nem találtunk egyezést és nincs felhasználó belépése a felhasználónak, akkor mindeképpen Insert!
+                if (importItemCompareCo == null || !importItemCompareCo.Id.IsEntityId())
+                {
+                    importItem.Operation = (int)ImportItemOperationEnum.Insert;
+                }
+                //NOTE: Ha találtunk egyezést, akkor...
+                else
+                {
+                    //NOTE: ...ha az import művelet DeleteAndInsert és a db-ből jövő adat Importalt(a nem importáltakat egyelőre nem töröljük), akkor Insert, mert töröljük a korábbi elemeket és újra be kell szúrni!
+                    if (importMuvelet == (int)ImportMuveletEnum.DeleteAndInsert && importItemCompareCo.Importalt)
+                    {
+                        importItem.Operation = (int)ImportItemOperationEnum.Insert;
+                    }
+                    //NOTE: ...ha nincs törlés, akkor...
+                    else
+                    {
+                        //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
+                        if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                        {
+                            importItem.Id = importItemCompareCo.Id;
+                            importItem.Operation = (int)ImportItemOperationEnum.Update;
+                        }
+                        //NOTE: ...ha a művelet nem InsertAndUpdate, akkor hozzá kell adni a nem NemImportalhatoItemList-hez és jelezni, hogy már szerepel az adatbázisban(Insert vagy DeleteAndInsert műveletnél. A DeleteAndInsert csak akkor fut be ide, ha az elem nem importált.)!
+                        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 FelhasznaloBelepesImportCo GetImportCoFromImportData(List<List<string>> importData, FelhasznaloBelepesExportImportTipusEnum tipusEnum, int? anotherYearId, bool isKovTanev)
+        {
+            var felhasznaloBelepesHelper = new FelhasznaloBelepesHelper(ConnectionType);
+            var felhasznaloBelepesCoList = new List<FelhasznaloBelepesItemCo>();
+
+            felhasznaloBelepesCoList.AddRange(felhasznaloBelepesHelper.GetFelhasznaloBelepesCoList().OrderBy(x => x.FelhasznaloVezeteknev).ThenBy(x => x.FelhasznaloKeresztnev));
+
+            if (anotherYearId.HasValue)
+            {
+                var anotherYearFelBelCoList = felhasznaloBelepesHelper.GetFelhasznaloBelepesCoList(anotherYearId);
+                anotherYearFelBelCoList.ForEach(x => x.AnotherYearTanevMegnevezes = (isKovTanev ? ErrorResource.AzAktualisTaneven : ErrorResource.AKovetkezoTaneven));
+                felhasznaloBelepesCoList.AddRange(anotherYearFelBelCoList.OrderBy(x => x.FelhasznaloVezeteknev).ThenBy(x => x.FelhasznaloKeresztnev));
+            }
+
+            var importCo = new FelhasznaloBelepesImportCo
+            {
+                FelhasznaloBelepesCoList = felhasznaloBelepesCoList,
+                TipusEnum = tipusEnum
+            };
+
+            int lineNumber = 1;
+            foreach (List<string> importDataRow in importData.Skip(1))
+            {
+                FelhasznaloBelepesImportItemCo importItemCo;
+                switch (tipusEnum)
+                {
+                    case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
+                        importItemCo = new FelhasznaloBelepesImportItemCo(TanevId)
+                        {
+                            NeveImportData = importDataRow[ImportHeaderListForAlkalmazott.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottNeve)],
+                            OktatasiAzonositoImportData = importDataRow[ImportHeaderListForAlkalmazott.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottOktatasiAzonosito)],
+                            SzuletesiDatumaImportData = importDataRow[ImportHeaderListForAlkalmazott.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottSzuletesiDatuma)],
+                            FelhasznaloNeveImportData = importDataRow[ImportHeaderListForAlkalmazott.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottFelhasznaloneve)],
+                            JelszavaImportData = importDataRow[ImportHeaderListForAlkalmazott.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottJelszava)]
+                        };
+
+                        break;
+
+                    case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
+                        importItemCo = new FelhasznaloBelepesImportItemCo(TanevId)
+                        {
+                            TanuloNevOktAzonSzulDatumImportData = importDataRow[ImportHeaderListForTanulo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNevSzulidoOktazon)],
+                            FelhasznaloNeveImportData = importDataRow[ImportHeaderListForTanulo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloFelhasznaloneve)],
+                            JelszavaImportData = importDataRow[ImportHeaderListForTanulo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloJelszava)]
+                        };
+                        (importItemCo.NeveImportData, importItemCo.SzuletesiDatumaImportData, importItemCo.OktatasiAzonositoImportData) = GetNevSzulDatumOktAzonFromTanuloImportData(importItemCo.TanuloNevOktAzonSzulDatumImportData);
+                        break;
+
+                    case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
+                        importItemCo = new FelhasznaloBelepesImportItemCo(TanevId)
+                        {
+                            NeveImportData = importDataRow[ImportHeaderListForGondviselo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNeve)],
+                            OktatasiAzonositoImportData = importDataRow[ImportHeaderListForGondviselo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloOktatasiAzonosito)],
+                            SzuletesiDatumaImportData = importDataRow[ImportHeaderListForGondviselo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloSzuletesiDatuma)],
+                            GondviseloNeveImportData = importDataRow[ImportHeaderListForGondviselo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloNeve)],
+                            GondviseloRokonsagiFokaImportData = importDataRow[ImportHeaderListForGondviselo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloRokonsagiFoka)],
+                            FelhasznaloNeveImportData = importDataRow[ImportHeaderListForGondviselo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloFelhasznaloneve)],
+                            JelszavaImportData = importDataRow[ImportHeaderListForGondviselo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloJelszava)]
+                        };
+                        break;
+
+                    default:
+                        throw new Exception();
+                }
+
+                importItemCo.TipusEnum = tipusEnum;
+                importItemCo.LineNumber = lineNumber;
+
+                //NOTE: Azért nem SingleOrDefault, mert az adatbázisban lehet olyan hiba, hogy egy tanulóhoz több olyan gondviselő van, akinek a neve és rokonsági foka megegyezik
+                importItemCo.FelhasznaloBelepes = importCo.FelhasznaloBelepesCoList.Where(x => x.TipusEnum == importItemCo.TipusEnum).FirstOrDefault(x =>
+                    x.FelhasznaloNyomtatasiNevComparableString == importItemCo.NeveImportData?.ToComparableString() &&
+                    x.FelhasznaloOktatasiAzonositoComparableString == importItemCo.OktatasiAzonosito?.ToComparableString() &&
+                    x.FelhasznaloSzuletesiIdo == importItemCo.SzuletesiIdo &&
+                    (x.TipusEnum != FelhasznaloBelepesExportImportTipusEnum.Gondviselo && !x.GondviseloId.IsEntityId() ||
+                     x.TipusEnum == FelhasznaloBelepesExportImportTipusEnum.Gondviselo && x.GondviseloId.IsEntityId() && x.GondviseloNevComparableString == importItemCo.GondviseloNev?.ToComparableString() && x.GondviseloRokonsagiFokId == importItemCo.GondviseloRokonsagiFokId));
+
+                string md5HashInput =
+                    importItemCo.NeveImportData?.ToComparableString() +
+                    importItemCo.OktatasiAzonosito?.ToComparableString() +
+                    importItemCo.SzuletesiIdoString?.ToComparableString();
+                if (importItemCo.TipusEnum == FelhasznaloBelepesExportImportTipusEnum.Gondviselo)
+                {
+                    md5HashInput += importItemCo.GondviseloNev?.ToComparableString();
+                    md5HashInput += importItemCo.GondviseloRokonsagiFokId;
+                }
+
+                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                importCo.MainImportItemList.Add(importItemCo);
+
+                lineNumber++;
+            }
+
+            return importCo;
+        }
+
+        private (string nev, string szulDatum, string oktAzon) GetNevSzulDatumOktAzonFromTanuloImportData(string tanuloNevOktAzonSzulDatumImportData)
+        {
+            var splittedTanuloNev = tanuloNevOktAzonSzulDatumImportData.Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
+
+            var nev = splittedTanuloNev.ElementAtOrDefault(0);
+            var szulDatum = splittedTanuloNev.ElementAtOrDefault(1);
+            var oktAzon = splittedTanuloNev.ElementAtOrDefault(2);
+
+            return (nev, szulDatum, oktAzon);
+        }
+
+        #region Template
+
+        public MemoryStream GetTemplate(FelhasznaloBelepesExportImportTipusEnum tipusEnum)
+        {
+            string worksheetName = DetailsByEnum(tipusEnum).WorksheetName;
+            string simpleExportColumnAttributeId = null;
+            switch (tipusEnum)
+            {
+                case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
+                    simpleExportColumnAttributeId = FelhasznaloBelepesItemCo.AlkalmazottFelhasznaloBelepesExportAttributeId;
+                    break;
+
+                case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
+                    simpleExportColumnAttributeId = FelhasznaloBelepesItemCo.TanuloFelhasznaloBelepesExportAttributeId;
+                    break;
+
+                case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
+                    simpleExportColumnAttributeId = FelhasznaloBelepesItemCo.GondviseloFelhasznaloBelepesExportAttributeId;
+                    break;
+            }
+
+            if (simpleExportColumnAttributeId == null)
+            {
+                throw new NullReferenceException(string.Format(ErrorResource.Az0ValtozoErtekeNemLehetNull, nameof(simpleExportColumnAttributeId)));
+            }
+
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<FelhasznaloBelepesItemCo>(simpleExportColumnAttributeId, GetDefaultDropDownColumnSourceDictionary(tipusEnum));
+            return SimpleExportLogic.GetTemplate(worksheetName, simpleExportColumnCos);
+        }
+
+        #endregion Template
+
+        #region Export
+
+        public MemoryStream GetExport(FelhasznaloBelepesExportImportTipusEnum tipusEnum)
+        {
+            string worksheetName = DetailsByEnum(tipusEnum).WorksheetName;
+            string simpleExportColumnAttributeId = null;
+            switch (tipusEnum)
+            {
+                case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
+                    simpleExportColumnAttributeId = FelhasznaloBelepesItemCo.AlkalmazottFelhasznaloBelepesExportAttributeId;
+                    break;
+
+                case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
+                    simpleExportColumnAttributeId = FelhasznaloBelepesItemCo.TanuloFelhasznaloBelepesExportAttributeId;
+                    break;
+
+                case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
+                    simpleExportColumnAttributeId = FelhasznaloBelepesItemCo.GondviseloFelhasznaloBelepesExportAttributeId;
+                    break;
+            }
+
+            if (simpleExportColumnAttributeId == null)
+            {
+                throw new NullReferenceException(string.Format(ErrorResource.Az0ValtozoErtekeNemLehetNull, nameof(simpleExportColumnAttributeId)));
+            }
+
+            List<FelhasznaloBelepesItemCo> coList = new FelhasznaloBelepesHelper(ConnectionType).GetFelhasznaloBelepesCoList()
+                .Where(x => x.TipusEnum == tipusEnum)
+                .OrderBy(x => x.FelhasznaloVezeteknev)
+                .ThenBy(x => x.FelhasznaloKeresztnev)
+                .ToList();
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<FelhasznaloBelepesItemCo>(simpleExportColumnAttributeId, GetDefaultDropDownColumnSourceDictionary(tipusEnum));
+            return SimpleExportLogic.GetExport(worksheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        public MemoryStream GetNemImportalhatoSorokExport(FelhasznaloBelepesExportImportTipusEnum tipusEnum)
+        {
+            string worksheetName = DetailsByEnum(tipusEnum).WorksheetName;
+            string simpleExportColumnAttributeId = null;
+            switch (tipusEnum)
+            {
+                case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
+                    simpleExportColumnAttributeId = FelhasznaloBelepesImportItemCo.AlkalmazottNemImportalhatoSorokExportAttributeId;
+                    break;
+
+                case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
+                    simpleExportColumnAttributeId = FelhasznaloBelepesImportItemCo.TanuloNemImportalhatoSorokExportAttributeId;
+                    break;
+
+                case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
+                    simpleExportColumnAttributeId = FelhasznaloBelepesImportItemCo.GondviseloNemImportalhatoSorokExportAttributeId;
+                    break;
+            }
+
+            if (simpleExportColumnAttributeId == null)
+            {
+                throw new NullReferenceException(string.Format(ErrorResource.Az0ValtozoErtekeNemLehetNull, nameof(simpleExportColumnAttributeId)));
+            }
+
+            List<FelhasznaloBelepesImportItemCo> coList = ImportCo.NemImportalhatoItemList;
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<FelhasznaloBelepesImportItemCo>(simpleExportColumnAttributeId, GetDefaultDropDownColumnSourceDictionary(tipusEnum));
+            return ImportExportHelper.NemImportalhatoSorokExport(worksheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        #endregion Export
+
+        private Dictionary<string, ImportItemCompareCo> GetCompareHashImportItemCompareCoDictionary(List<FelhasznaloBelepesItemCo> coList, FelhasznaloBelepesExportImportTipusEnum tipusEnum)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (FelhasznaloBelepesItemCo co in coList.Where(i => i.TipusEnum == tipusEnum))
+            {
+                string md5HashInput =
+                    co.FelhasznaloNyomtatasiNevComparableString +
+                    co.FelhasznaloOktatasiAzonositoComparableString +
+                    co.FelhasznaloSzuletesiIdoComparableString;
+                if (tipusEnum == FelhasznaloBelepesExportImportTipusEnum.Gondviselo)
+                {
+                    md5HashInput += co.GondviseloNevComparableString;
+                    md5HashInput += co.GondviseloRokonsagiFokId;
+                }
+
+                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 (string WorksheetName, Dictionary<int, string> ExcelHeaderList) DetailsByEnum(FelhasznaloBelepesExportImportTipusEnum tipusEnum)
+        {
+            switch (tipusEnum)
+            {
+                case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
+                    return (ImportExportFelhasznaloBelepesResource.AlkalmazottFelhasznaloBelepesiAdatok, ImportHeaderListForAlkalmazott);
+
+                case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
+                    return (ImportExportFelhasznaloBelepesResource.TanuloFelhasznaloBelepesiAdatok, ImportHeaderListForTanulo);
+
+                case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
+                    return (ImportExportFelhasznaloBelepesResource.GondviseloFelhasznaloBelepesiAdatok, ImportHeaderListForGondviselo);
+            }
+
+            return (string.Empty, null);
+        }
+
+        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary(FelhasznaloBelepesExportImportTipusEnum tipusEnum)
+        {
+            //NOTE: Create dropdown lists
+            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>();
+            switch (tipusEnum)
+            {
+                case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
+                    Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+                    {
+                        var helper = new ImportExportHelper(new DalHandlerConnectionType(ConnectionType, dalHandler));
+                        dropDownColumnSourceDictionary.Add(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottNeve, helper.GetTanarList());
+                    });
+                    break;
+
+                case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
+                    Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+                    {
+                        var helper = new ImportExportHelper(new DalHandlerConnectionType(ConnectionType, dalHandler));
+                        dropDownColumnSourceDictionary.Add(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNevSzulidoOktazon, helper.GetTanuloNevOktAzonSzulDatumList());
+                    });
+                    break;
+
+                case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
+                    Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+                    {
+                        var connectionType = new DalHandlerConnectionType(ConnectionType, dalHandler);
+
+                        var helper = new ImportExportHelper(connectionType);
+                        dropDownColumnSourceDictionary.Add(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNeve, helper.GetTanuloList());
+                        dropDownColumnSourceDictionary.Add(ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloNeve, helper.GetGondviseloList());
+
+                        dropDownColumnSourceDictionary.Add(ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloRokonsagiFoka, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.RokonsagiFok));
+                    });
+                    break;
+
+                default:
+                    throw new Exception();
+            }
+
+            return dropDownColumnSourceDictionary;
+        }
+    }
+}

Kreta.BusinessLogic/Helpers/ImportExport/GondviseloImportExportHelper.cs

@@ -0,0 +1,529 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Data;
+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 GondviseloImportExportHelper : LogicBase
+    {
+        #region Fields
+
+        private readonly string _importObjectCacheKey;
+
+        #endregion Fields
+
+        #region Properties
+
+        public static Dictionary<int, string> ImportHeaderList => new Dictionary<int, string>
+        {
+            { 00, ImportExportGondviseloResource.ImportHeaderNameTanuloNeve },
+            { 01, ImportExportGondviseloResource.ImportHeaderNameTanuloOktatasiAzonosito },
+            { 02, ImportExportGondviseloResource.ImportHeaderNameGondviseloNevElotag },
+            { 03, ImportExportGondviseloResource.ImportHeaderNameGondviseloVezetekNev },
+            { 04, ImportExportGondviseloResource.ImportHeaderNameGondviseloKeresztNev },
+            { 05, ImportExportGondviseloResource.ImportHeaderNameGondviseloRokonsagiFoka },
+            { 06, ImportExportGondviseloResource.ImportHeaderNameTorvenyesKepviselo },
+            { 07, ImportExportGondviseloResource.ImportHeaderNameGondviseloTelefonszama },
+            { 08, ImportExportGondviseloResource.ImportHeaderNameTelefonTipus },
+            { 09, ImportExportGondviseloResource.ImportHeaderNameGondviseloEmailCime },
+            { 10, ImportExportGondviseloResource.ImportHeaderNameEmailTipus },
+            { 11, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimTipusa },
+            { 12, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimOrszag },
+            { 13, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimIranyitoszam },
+            { 14, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimHelysegNev },
+            { 15, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimKozteruletNev },
+            { 16, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimKozteruletJelleg },
+            { 17, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimHazszam },
+            { 18, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimEmelet },
+            { 19, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimAjto },
+        };
+
+        public static Dictionary<int, string> ExportHeaderList => new Dictionary<int, string>(ImportHeaderList);
+
+        public GondviseloImportCo ImportCo
+        {
+            get => (GondviseloImportCo)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 GondviseloImportExportHelper(IConnectionType connectionType) : base(connectionType)
+        {
+            _importObjectCacheKey = $"{nameof(GondviseloImportCo)}_{IntezmenyId}_{FelhasznaloId}_ImportObjectCacheKey";
+        }
+
+        #endregion Constructors
+
+        public void SetImportCo(List<List<string>> importData, int importMuvelet, bool isGeneraltFileLetoltes, bool isEmailKuldes, bool isSzirIntezmeny)
+        {
+            GondviseloImportCo importCo = GetImportCoFromImportData(importData);
+            importCo.ImportMuvelet = importMuvelet;
+            importCo.IsGeneraltFileLetoltes = isGeneraltFileLetoltes;
+            importCo.IsEmailKuldes = isEmailKuldes;
+
+            SetNemImportalhatoSorokByValidation(importCo);
+
+            List<GondviseloItemCo> coList = importCo.GondviseloCoList;
+            //NOTE: Azért van szükség Dictionary-kre, mert így sokkal gyorsabb a keresés!
+            Dictionary<string, ImportItemCompareCo> telefonCompareHashImportItemCompareCoDictionary = GetTelefonCompareHashImportItemCompareCoDictionary(coList);
+            Dictionary<string, ImportItemCompareCo> emailCompareHashImportItemCompareCoDictionary = GetEmailCompareHashImportItemCompareCoDictionary(coList);
+            Dictionary<string, ImportItemCompareCo> cimCompareHashImportItemCompareCoDictionary = GetCimCompareHashImportItemCompareCoDictionary(coList);
+            Dictionary<string, ImportItemCompareCo> gondviseloCompareHashImportItemCompareCoDictionary = GetGondviseloCompareHashImportItemCompareCoDictionary(coList);
+            foreach (GondviseloImportItemCo importItem in importCo.MainImportItemList)
+            {
+                if (!string.IsNullOrWhiteSpace(importItem.Telefonszam))
+                {
+                    SetOperationTelefon(importItem, telefonCompareHashImportItemCompareCoDictionary, importCo.ImportMuvelet);
+                }
+
+                if (!string.IsNullOrWhiteSpace(importItem.EmailCim))
+                {
+                    SetOperationEmail(importItem, emailCompareHashImportItemCompareCoDictionary, importCo.ImportMuvelet);
+                }
+
+                if (!string.IsNullOrWhiteSpace(importItem.CimTipusaNev) && importItem.CimOrszagId.IsEntityId())
+                {
+                    SetOperationCim(importItem, cimCompareHashImportItemCompareCoDictionary, importCo.ImportMuvelet);
+                }
+
+                SetOperationGondviselo(importItem, gondviseloCompareHashImportItemCompareCoDictionary, importCo.ImportMuvelet);
+            }
+
+            //NOTE: Azokat a sorokat, amelyek bekerültek a NemImportalhatoItemList-be, azokat kiveszzük a MainImportItemList-ből!
+            importCo.MainImportItemList.RemoveRange(importCo.NemImportalhatoItemList);
+
+            var telefonImportJsonItemList = new List<TelefonGondviseloImportJsonItemCo>();
+            var emailImportJsonItemList = new List<EmailGondviseloImportJsonItemCo>();
+            var cimImportJsonItemList = new List<CimGondviseloImportJsonItemCo>();
+            var mainImportJsonItemList = new List<GondviseloImportJsonItemCo>();
+            foreach (GondviseloImportItemCo importItem in importCo.MainImportItemList)
+            {
+                if (!string.IsNullOrWhiteSpace(importItem.Telefonszam))
+                {
+                    telefonImportJsonItemList.Add(new TelefonGondviseloImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
+                }
+
+                if (!string.IsNullOrWhiteSpace(importItem.EmailCim))
+                {
+                    emailImportJsonItemList.Add(new EmailGondviseloImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
+                }
+
+                if (!string.IsNullOrWhiteSpace(importItem.CimTipusaNev))
+                {
+                    cimImportJsonItemList.Add(new CimGondviseloImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
+                }
+
+                mainImportJsonItemList.Add(new GondviseloImportJsonItemCo(importItem, isSzirIntezmeny, TanevId, IntezmenyId, FelhasznaloId));
+            }
+
+            importCo.TelefonGondviseloImportJsonItemList = telefonImportJsonItemList;
+            importCo.EmailGondviseloImportJsonItemList = emailImportJsonItemList;
+            importCo.CimGondviseloImportJsonItemList = cimImportJsonItemList;
+            importCo.MainImportJsonItemList = mainImportJsonItemList;
+
+            ImportCo = importCo;
+        }
+
+        private static void SetNemImportalhatoSorokByValidation(GondviseloImportCo importCo)
+        {
+            Dictionary<int, List<ValidationResult>> validationResultDictionary = importCo.Validate();
+
+            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
+            foreach (GondviseloImportItemCo 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 static void SetOperationTelefon(GondviseloImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int importMuvelet)
+        {
+            var compareHash = importItem.CompareHashTelefon;
+            //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
+            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+            {
+                importItem.OperationTelefon = (int)ImportItemOperationEnum.Insert;
+            }
+            //NOTE: Ha találtunk egyezést, akkor...
+            else
+            {
+                ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
+                if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                {
+                    importItem.TelefonId = importItemCompareCo.Id;
+                    importItem.OperationTelefon = (int)ImportItemOperationEnum.Update;
+                }
+            }
+        }
+
+        private static void SetOperationEmail(GondviseloImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int importMuvelet)
+        {
+            var compareHash = importItem.CompareHashEmail;
+            //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
+            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+            {
+                importItem.OperationEmail = (int)ImportItemOperationEnum.Insert;
+            }
+            //NOTE: Ha találtunk egyezést, akkor...
+            else
+            {
+                ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
+                if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                {
+                    importItem.EmailId = importItemCompareCo.Id;
+                    importItem.OperationEmail = (int)ImportItemOperationEnum.Update;
+                }
+            }
+        }
+
+        private static void SetOperationCim(GondviseloImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int importMuvelet)
+        {
+            var compareHash = importItem.CompareHashCim;
+            //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
+            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+            {
+                importItem.OperationCim = (int)ImportItemOperationEnum.Insert;
+            }
+            //NOTE: Ha találtunk egyezést, akkor...
+            else
+            {
+                ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
+                if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                {
+                    importItem.CimId = importItemCompareCo.Id;
+                    importItem.OperationCim = (int)ImportItemOperationEnum.Update;
+                }
+            }
+        }
+
+        private void SetOperationGondviselo(GondviseloImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int importMuvelet)
+        {
+            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...
+            else
+            {
+                ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
+                if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                {
+                    importItem.Id = importItemCompareCo.Id;
+                    importItem.Operation = (int)ImportItemOperationEnum.Update;
+                }
+            }
+        }
+
+        private GondviseloImportCo GetImportCoFromImportData(List<List<string>> importData)
+        {
+            var importCo = new GondviseloImportCo
+            {
+                GondviseloCoList = new GondviseloHelper(ConnectionType).GetGondviseloCoList()
+            };
+
+            List<TanuloItemCo> tanuloCoList = new TanuloHelper(ConnectionType).GetTanuloCoList();
+            int lineNumber = 1;
+            foreach (List<string> importDataRow in importData.Skip(1))
+            {
+                var importItemCo = new GondviseloImportItemCo(TanevId)
+                {
+                    LineNumber = lineNumber,
+
+                    TanuloNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameTanuloNeve)],
+                    TanuloOktatasiAzonositoImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameTanuloOktatasiAzonosito)],
+                    GondviseloNevElotagImportData = Extensions.NameExtensions.CleanElotag(importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloNevElotag)]),
+                    GondviseloVezeteknevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloVezetekNev)].ReplaceMultipleSpacesAndTrim(),
+                    GondviseloKeresztnevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloKeresztNev)].ReplaceMultipleSpacesAndTrim(),
+                    GondviseloRokonsagiFokaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloRokonsagiFoka)],
+                    GondviseloTelefonszamaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloTelefonszama)],
+                    GondviseloEmailCimeImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloEmailCime)],
+                    CimAjtoImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimAjto)],
+                    EmailTipusImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameEmailTipus)],
+                    CimEmeletImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimEmelet)],
+                    CimHazszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimHazszam)],
+                    CimHelysegNevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimHelysegNev)],
+                    CimIranyitoszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimIranyitoszam)],
+                    CimKozteruletJellegeImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimKozteruletJelleg)],
+                    CimKozteruletNevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimKozteruletNev)],
+                    CimOrszagImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimOrszag)],
+                    CimTipusaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimTipusa)],
+                    TelefonTipusImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameTelefonTipus)],
+                    TorvenyesKepviseloImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameTorvenyesKepviselo)],
+                };
+
+                //NOTE: Azért nem SingleOrDefault, mert többször gondviselője is lehet egy tanulónak.
+                importItemCo.FelhasznaloId = tanuloCoList.FirstOrDefault(x =>
+                    x.FelhasznaloNyomtatasiNevComparableString == importItemCo.TanuloNeveImportData?.ToComparableString() &&
+                    x.FelhasznaloOktatasiAzonositoComparableString == importItemCo.FelhasznaloOktatasiAzonosito?.ToComparableString())?.Id;
+
+                var gondviseloNev = Extensions.NameExtensions.GetNevSorrendben("F", Extensions.NameExtensions.CleanElotag(importItemCo.GondviseloNevElotag), importItemCo.GondviseloVezeteknev, importItemCo.GondviseloKeresztnev);
+                //NOTE: Azért nem SingleOrDefault, mert hibásan lehet több gondviselő ugyanazzal a névvel és rokonsági fokkal
+                importItemCo.Gondviselo = importCo.GondviseloCoList.FirstOrDefault(x =>
+                    x.FelhasznaloId == importItemCo.FelhasznaloId &&
+                    x.NevComparableString == gondviseloNev?.ToComparableString() &&
+                    x.RokonsagiFokId == importItemCo.RokonsagiFokId);
+
+                string telefonMd5HashInput =
+                    importItemCo.FelhasznaloId +
+                    gondviseloNev?.ToComparableString() +
+                    importItemCo.RokonsagiFokId;
+                importItemCo.CompareHashTelefon = ImportExportHelper.GetMd5Hash(telefonMd5HashInput);
+
+                string emailMd5HashInput =
+                    importItemCo.FelhasznaloId +
+                    gondviseloNev?.ToComparableString() +
+                    importItemCo.RokonsagiFokId;
+                importItemCo.CompareHashEmail = ImportExportHelper.GetMd5Hash(emailMd5HashInput);
+
+                string cimMd5HashInput =
+                    importItemCo.FelhasznaloId +
+                    gondviseloNev?.ToComparableString() +
+                    importItemCo.RokonsagiFokId +
+                    importItemCo.CimTipusaId;
+                importItemCo.CompareHashCim = ImportExportHelper.GetMd5Hash(cimMd5HashInput);
+
+                string gondviseloMd5HashInput =
+                    importItemCo.FelhasznaloId +
+                    gondviseloNev?.ToComparableString() +
+                    importItemCo.RokonsagiFokId;
+                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(gondviseloMd5HashInput);
+
+                importCo.MainImportItemList.Add(importItemCo);
+
+                lineNumber++;
+            }
+
+            return importCo;
+        }
+
+        public MemoryStream GetTemplate()
+        {
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<GondviseloItemCo>(GondviseloItemCo.GondviselokExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
+            return SimpleExportLogic.GetTemplate(ImportExportGondviseloResource.ImportDefaultSheetName, simpleExportColumnCos);
+        }
+
+        public MemoryStream GetExport()
+        {
+            List<GondviseloItemCo> coList = new GondviseloHelper(ConnectionType).GetGondviseloCoList().OrderBy(x => x.FelhasznaloVezeteknev).ThenBy(x => x.FelhasznaloKeresztnev).ThenBy(x => x.VezetekNev).ThenBy(x => x.KeresztNev).ToList();
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<GondviseloItemCo>(GondviseloItemCo.GondviselokExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
+            return SimpleExportLogic.GetExport(ImportExportGondviseloResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        public MemoryStream GetNemImportalhatoSorokExport()
+        {
+            List<GondviseloImportItemCo> coList = ImportCo.NemImportalhatoItemList.OrderBy(x => x.TanuloNeveImportData).ThenBy(x => x.GondviseloVezeteknevImportData).ThenBy(x => x.GondviseloKeresztnevImportData).ToList();
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<GondviseloImportItemCo>(GondviseloImportItemCo.NemImportalhatoSorokExportAttributeId);
+            return ImportExportHelper.NemImportalhatoSorokExport(ImportExportGondviseloResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        private Dictionary<string, ImportItemCompareCo> GetTelefonCompareHashImportItemCompareCoDictionary(List<GondviseloItemCo> gondviseloItemCoList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (GondviseloItemCo gondviseloItemCo in gondviseloItemCoList)
+            {
+                var telefon = gondviseloItemCo.TelefonList.FirstOrDefault();
+                if (telefon != null)
+                {
+                    var md5HashInput =
+                        gondviseloItemCo.FelhasznaloId +
+                        gondviseloItemCo.NevComparableString +
+                        gondviseloItemCo.RokonsagiFokId;
+                    string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                    var importItemCompareCo = new ImportItemCompareCo
+                    {
+                        Id = telefon.Id,
+                        CompareHash = compareHash
+                    };
+                    //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;
+        }
+
+        private Dictionary<string, ImportItemCompareCo> GetEmailCompareHashImportItemCompareCoDictionary(List<GondviseloItemCo> gondviseloItemCoList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (GondviseloItemCo gondviseloItemCo in gondviseloItemCoList)
+            {
+                var email = gondviseloItemCo.EmailList.FirstOrDefault();
+                if (email != null)
+                {
+                    var md5HashInput =
+                        gondviseloItemCo.FelhasznaloId +
+                        gondviseloItemCo.NevComparableString +
+                        gondviseloItemCo.RokonsagiFokId;
+                    string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                    var importItemCompareCo = new ImportItemCompareCo
+                    {
+                        Id = email.Id,
+                        CompareHash = compareHash
+                    };
+                    //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;
+        }
+
+        private Dictionary<string, ImportItemCompareCo> GetCimCompareHashImportItemCompareCoDictionary(List<GondviseloItemCo> gondviseloItemCoList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (GondviseloItemCo gondviseloItemCo in gondviseloItemCoList)
+            {
+                var cim = gondviseloItemCo.AllandoLakcim;
+                if (cim != null)
+                {
+                    var md5HashInput =
+                        gondviseloItemCo.FelhasznaloId +
+                        gondviseloItemCo.NevComparableString +
+                        gondviseloItemCo.RokonsagiFokId +
+                        cim.TipusId;
+                    string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                    var importItemCompareCo = new ImportItemCompareCo
+                    {
+                        Id = cim.Id,
+                        CompareHash = compareHash
+                    };
+                    //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;
+        }
+
+        private Dictionary<string, ImportItemCompareCo> GetGondviseloCompareHashImportItemCompareCoDictionary(List<GondviseloItemCo> gondviseloItemCoList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (GondviseloItemCo co in gondviseloItemCoList)
+            {
+                var md5HashInput =
+                    co.FelhasznaloId +
+                    co.NevComparableString +
+                    co.RokonsagiFokId;
+                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 BelepesiAdatokListCO Import(object importJsonObject, bool isEmailKuldes, bool isActivTanev, bool isKovTanev, bool isSzirIntezmeny)
+        {
+            string importJson = JsonConvert.SerializeObject(importJsonObject);
+            var belepesiAdatokListCo = new BelepesiAdatokListCO();
+            if (!isSzirIntezmeny && (isActivTanev || isKovTanev))
+            {
+                Dal.CustomConnection.Run(ConnectionType, h =>
+                {
+                    DataSet result = h.ImportExportDal().GondviseloImport(IntezmenyId, TanevId, FelhasznaloId, importJson);
+                    h.Felhasznalo().UpdateAllEgyediAzonosito();
+
+                    if (isActivTanev && result.Tables[0].Rows.Count > 0)
+                    {
+                        var tanuloHelper = new TanuloHelper(new DalHandlerConnectionType(ConnectionType, h));
+                        foreach (DataRow dataRow in result.Tables[0].Rows)
+                        {
+                            tanuloHelper.AlapertelmezettGondviseloBelepesGeneralas(SDAConvert.ToInt32(dataRow["ID"]), isEmailKuldes, belepesiAdatokListCo);
+                        }
+                    }
+                });
+            }
+
+            return belepesiAdatokListCo;
+        }
+
+        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary()
+        {
+            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>();
+
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                var connectionType = new DalHandlerConnectionType(ConnectionType, dalHandler);
+
+                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameGondviseloRokonsagiFoka, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.RokonsagiFok));
+                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameTelefonTipus, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.TelefonTipus));
+                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameEmailTipus, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.EmailTipus));
+                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimOrszag, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.OrszagTipus));
+
+                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimTipusa, new List<string> { CimTipusEnum.allando_lakcim.GetDisplayName(TanevId) });
+
+                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimKozteruletJelleg, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.KozteruletJelleg));
+
+                var importExportHelper = new ImportExportHelper(connectionType);
+
+                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameTanuloNeve, importExportHelper.GetTanuloList());
+
+                var telepulesHelper = new TelepulesHelper(connectionType);
+
+                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimIranyitoszam, telepulesHelper.GetIranyitoszamok("").Select(i => i.Iranyitoszam).ToList());
+                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimHelysegNev, telepulesHelper.GetTelepulesek().Select(t => t.TelepulesNev).ToList());
+            });
+
+            return dropDownColumnSourceDictionary;
+        }
+    }
+}

Kreta.BusinessLogic/Helpers/ImportExport/ImportExportHelper.cs

@@ -0,0 +1,407 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using Aspose.Cells;
+using Kreta.BusinessLogic.Classes;
+using Kreta.BusinessLogic.HelperClasses;
+using Kreta.BusinessLogic.HelperClasses.ImportCo;
+using Kreta.BusinessLogic.Logic;
+using Kreta.BusinessLogic.Utils;
+using Kreta.Core;
+using Kreta.Core.ConnectionType;
+using Kreta.DataAccessManual;
+using Kreta.DataAccessManual.Util;
+using Kreta.Enums;
+using Kreta.Enums.ManualEnums.ImportExport;
+using Kreta.Framework.Util;
+using Kreta.Resources;
+using Newtonsoft.Json;
+using OfficeOpenXml;
+
+namespace Kreta.BusinessLogic.Helpers.ImportExport
+{
+    public class ImportExportHelper : LogicBase
+    {
+        public ImportExportHelper(IConnectionType connectionType) : base(connectionType) { }
+
+        public static List<List<string>> GetImportDataFromExcel(Stream uploadedFile, Dictionary<int, string> expectedImportHeaderList, out List<string> errorResult)
+        {
+            errorResult = new List<string>();
+            if (uploadedFile is FileStream fileStream)
+            {
+                var fileInfo = new FileInfo(fileStream.Name);
+                if (fileInfo.Extension != ".xlsx")
+                {
+                    errorResult.Add(ErrorResource.CsakXlsxKiterjesztesuExcelFiletLehetImportalni);
+                    return null;
+                }
+            }
+
+            using (var excelPackage = new ExcelPackage(uploadedFile))
+            {
+                var importData = new List<List<string>>();
+
+                var excelWorksheet = excelPackage.Workbook.Worksheets.First();
+                var startExcelCellAddress = excelWorksheet.Dimension.Start;
+                var endExcelCellAddress = excelWorksheet.Dimension.End;
+                var lastExpectedImportColumnIndex = expectedImportHeaderList.Count;
+
+                var excelHeaderList = new Dictionary<int, string>();
+                for (var columnIndex = startExcelCellAddress.Column; columnIndex <= lastExpectedImportColumnIndex; columnIndex++)
+                {
+                    var value = excelWorksheet.Cells[1, columnIndex].Text.ReplaceMultipleSpacesAndTrim();
+                    excelHeaderList.Add(columnIndex, value);
+                }
+
+                for (var expectedImportHeaderColumnIndex = 0; expectedImportHeaderColumnIndex < lastExpectedImportColumnIndex; expectedImportHeaderColumnIndex++)
+                {
+                    var excelHeaderColumnIndex = expectedImportHeaderColumnIndex + 1;
+                    if (!expectedImportHeaderList[expectedImportHeaderColumnIndex].Equals(excelHeaderList[excelHeaderColumnIndex]))
+                    {
+                        errorResult.Add(string.Format(ErrorResource.RosszImportHeader, excelHeaderColumnIndex, excelHeaderList[excelHeaderColumnIndex], expectedImportHeaderList[expectedImportHeaderColumnIndex]));
+                    }
+                }
+
+                if (errorResult.Count > 0)
+                {
+                    return null;
+                }
+
+                for (var rowIndex = startExcelCellAddress.Row; rowIndex <= endExcelCellAddress.Row; rowIndex++)
+                {
+                    var currentRowDataList = new List<string>();
+                    for (var columnIndex = startExcelCellAddress.Column; columnIndex <= lastExpectedImportColumnIndex; columnIndex++)
+                    {
+                        var value = excelWorksheet.Cells[rowIndex, columnIndex].Text.ReplaceMultipleSpacesAndTrim();
+                        currentRowDataList.Add(value);
+                    }
+
+                    importData.Add(currentRowDataList);
+                }
+
+                //NOTE: Kitöröljük azokat a sorokat, ahol minden cella üres.
+                importData.RemoveAll(x => x.All(string.IsNullOrWhiteSpace));
+
+                return importData;
+            }
+        }
+
+        public static string GetMd5Hash(string input)
+        {
+            if (string.IsNullOrWhiteSpace(input))
+            {
+                return Constants.General.ImportMD5InvalidInput;
+            }
+
+            using (HashAlgorithm hashAlgorithm = MD5.Create())
+            {
+                var inputArray = hashAlgorithm.ComputeHash(Encoding.UTF8.GetBytes(input));
+                var stringBuilder = new StringBuilder();
+                foreach (var item in inputArray)
+                {
+                    stringBuilder.Append(item.ToString("x2"));
+                }
+
+                var result = stringBuilder.ToString();
+                return result;
+            }
+        }
+
+        public void Import(object importJsonObject, int importMuvelet, bool isSubTable = false, bool isTorlesCsakImportalt = true)
+        {
+            var importJson = JsonConvert.SerializeObject(importJsonObject);
+            var isTorles = importMuvelet == (int)ImportMuveletEnum.DeleteAndInsert;
+            Dal.CustomConnection.Run(ConnectionType, dalHandler => dalHandler.ImportExportDal().Import(IntezmenyId, TanevId, FelhasznaloId, importJson, isTorles, isSubTable, isTorlesCsakImportalt));
+        }
+
+        public static MemoryStream NemImportalhatoSorokExport<T>(
+            string worksheetName,
+            List<SimpleExportColumnCo> simpleExportColumnCos,
+            List<T> coList, int tanevId) where T : BaseImportItemCo
+        {
+            using (var workbook = new Workbook())
+            {
+                var worksheet = SimpleExportLogic.GetWorksheet(workbook, worksheetName, simpleExportColumnCos);
+                worksheet.FillWithData(coList, simpleExportColumnCos, tanevId);
+
+                NemImportalhatoSorokExportEgyediHibaOszlop(worksheet, simpleExportColumnCos, coList);
+
+                var sheetCodeNameAndColumnsToWrapIndexDictionary = new Dictionary<string, List<int>>
+                {
+                    { workbook.Worksheets[0].CodeName, new List<int> { simpleExportColumnCos.Count } }
+                };
+                var memoryStream = SimpleExportLogic.GetWorkbookMemoryStream(workbook, sheetCodeNameAndColumnsToWrapIndexDictionary);
+                return memoryStream;
+            }
+        }
+
+        private static void NemImportalhatoSorokExportEgyediHibaOszlop<T>(Worksheet worksheet, List<SimpleExportColumnCo> simpleExportColumnCos, List<T> coList) where T : BaseImportItemCo
+        {
+            var errorHeaderColumn = simpleExportColumnCos.Count;
+
+            var errorHeaderCell = worksheet.Cells[0, errorHeaderColumn];
+            errorHeaderCell.Value = ImportExportCommonResource.ImportalastMeghiusitoOk;
+
+            var rowNumber = 1;
+            foreach (var errorList in coList.Select(x => x.ErrorList))
+            {
+                var errorCell = worksheet.Cells[rowNumber, errorHeaderColumn];
+                errorCell.Value = string.Join(Environment.NewLine, errorList);
+                errorCell.SetTextWrap();
+
+                rowNumber++;
+            }
+
+            worksheet.EgyediSzovegesOszlopFormazas(errorHeaderColumn);
+        }
+
+        public static MemoryStream GetTemplate(string worksheetName, Dictionary<int, string> headerNameDictionary, Dictionary<string, IList<string>> dropDownColumnSourceDictionary = null)
+        {
+            var simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos(headerNameDictionary, dropDownColumnSourceDictionary);
+            return SimpleExportLogic.GetTemplate(worksheetName, simpleExportColumnCos);
+        }
+
+        public static Worksheet GetWorksheetsWithDropDownFormula(Workbook workbook, string worksheetName, Dictionary<int, string> headerNameDictionary, Dictionary<string, IList<string>> dropDownColumnSourceDictionary = null)
+        {
+            var simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos(headerNameDictionary, dropDownColumnSourceDictionary);
+            var worksheet = SimpleExportLogic.GetWorksheet(workbook, worksheetName, simpleExportColumnCos);
+            return worksheet;
+        }
+
+        #region Az excel-ekben megjelenő dropdownlist-ek kiválasztható elemei
+
+        public IList<string> GetOsztalyCsoportList()
+        {
+            var result = new OsztalyCsoportHelper(ConnectionType).GetOsztalyCsoportCoList()
+                .OrderByDescending(x => x.IsOsztaly)
+                .ThenBy(x => x.Nev)
+                .Select(x => x.Nev)
+                .ToList();
+            return result;
+        }
+
+        public IList<string> GetOsztalyList()
+        {
+            var result = new OsztalyHelper(ConnectionType).GetOsztalyCoList().Select(x => x.Nev).OrderBy(o => o).ToList();
+            return result;
+        }
+
+        public IList<string> GetCsoportList()
+        {
+            var result = new CsoportHelper(ConnectionType).GetCsoportCoList().Select(x => x.Nev).OrderBy(o => o).ToList();
+            return result;
+        }
+
+        public IList<string> GetCsoportListBySzervezet(int? szervezetTipus = null, int? szervezetId = null)
+        {
+            var result = new CsoportHelper(ConnectionType).GetCsoportListBySzervezet(szervezetTipus, szervezetId).Select(x => x.Nev).OrderBy(o => o).ToList();
+            return result;
+        }
+
+        public IList<string> GetTantargyList(bool isExtended = false, bool isFromSzervezet = false, bool isSzakkepzo = false)
+        {
+            List<string> result;
+            if (isExtended)
+            {
+                var list = new List<string>
+                {
+                    CommonResource.Mind,
+                    TanuloErtekelesResource.Magatartas,
+                    TanuloErtekelesResource.Szorgalom
+                };
+                result = list.Union(new TantargyHelper(ConnectionType).GetTantargyCoList().Select(x => x.Nev).OrderBy(o => o)).ToList();
+
+            }
+            else
+            {
+                result = new TantargyHelper(ConnectionType).GetTantargyCoList().Select(x => x.Nev).OrderBy(o => o).ToList();
+            }
+
+            if (!isFromSzervezet)
+                result.RemoveAll(x=> x.Contains(TantargyResource.DualisKepzes));
+
+            if (!isSzakkepzo)
+                result.RemoveAll(x => x.Contains(TantargyResource.ApaczaiKonzultacio));
+
+            return result;
+        }
+
+        public IList<string> GetTantargyListBySzervezet(bool isFromSzervezet = false, bool isSzakkepzo = false)
+        {
+            List<string> result;
+            result = new TantargyHelper(ConnectionType).GetTantargyCoList().Select(x => x.Nev).OrderBy(o => o).ToList();
+
+            if (!isSzakkepzo)
+            {
+                result.RemoveAll(x => x.Contains(TantargyResource.ApaczaiKonzultacio));
+            }
+
+            if (!isFromSzervezet)
+            {
+                result.RemoveAll(x => x.Contains(TantargyResource.DualisKepzes));
+            }
+            else
+            {
+                result = result.Where(x => x.Contains(TantargyResource.DualisKepzes)).ToList();
+            }
+
+            return result;
+        }
+        
+
+        public IList<string> GetTanuloErtekelesTipusList()
+        {
+            var list = new List<string>
+            {
+                CommonResource.Mind
+            };
+
+            return Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                var connectionType = new DalHandlerConnectionType(ConnectionType, dalHandler);
+
+                return list.Union(EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.ErtekelesTipus)).ToList();
+            });
+        }
+
+        public IList<string> GetEvfolyamTipusList()
+        {
+            var list = new List<string>
+            {
+                CommonResource.Mind
+            };
+
+            return Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                var connectionType = new DalHandlerConnectionType(ConnectionType, dalHandler);
+
+                return list.Union(EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.EvfolyamTipus)).ToList();
+            });
+        }
+
+        public IList<string> GetTanarList(bool isSzuletesiIdovel = false)
+        {
+            List<string> result;
+            var tanarCoList = new AlkalmazottHelper(ConnectionType).GetAlkalmazottCoList();
+            if (isSzuletesiIdovel)
+            {
+                var tanarNevList = new List<string>();
+                //NOTE: Erre azért van szükség, ha több egyforma nevű tanár szerepel az adatbázisban, akkor zárójelben mögé tesszük a születési dátumát, hogy meg tudjuk őket különböztetni!
+                foreach (var item in tanarCoList)
+                {
+                    var tanarNev = item.FelhasznaloNyomtatasiNev;
+                    if (tanarCoList.Count(x => x.FelhasznaloNyomtatasiNevComparableString == item.FelhasznaloNyomtatasiNevComparableString) > 1)
+                    {
+                        tanarNev += $" ({item.FelhasznaloSzuletesiIdo.ToString(Core.Constants.ToStringPattern.HungarianDate)})";
+                    }
+
+                    tanarNevList.Add(tanarNev);
+                }
+
+                result = tanarNevList.Distinct().OrderBy(o => o).ToList();
+            }
+            else
+            {
+                result = tanarCoList.Select(x => x.FelhasznaloNyomtatasiNev).Distinct().OrderBy(o => o).ToList();
+            }
+
+            return result;
+        }
+
+        public IList<string> GetTanarListBySzervezet(bool isSzuletesiIdovel = false, int? szervezetTipus = null, int? szervezetId = null)
+        {
+            List<string> result;
+            var tanarCoList = new AlkalmazottHelper(ConnectionType).GetAlkalmazottCoListBySzervezet(szervezetTipus, szervezetId);
+            if (isSzuletesiIdovel)
+            {
+                var tanarNevList = new List<string>();
+                //NOTE: Erre azért van szükség, ha több egyforma nevű tanár szerepel az adatbázisban, akkor zárójelben mögé tesszük a születési dátumát, hogy meg tudjuk őket különböztetni!
+                foreach (var item in tanarCoList)
+                {
+                    var tanarNev = item.FelhasznaloNyomtatasiNev;
+                    if (tanarCoList.Count(x => x.FelhasznaloNyomtatasiNevComparableString == item.FelhasznaloNyomtatasiNevComparableString) > 1)
+                    {
+                        tanarNev += $" ({item.FelhasznaloSzuletesiIdo.ToString(Core.Constants.ToStringPattern.HungarianDate)})";
+                    }
+
+                    tanarNevList.Add(tanarNev);
+                }
+
+                result = tanarNevList.Distinct().OrderBy(o => o).ToList();
+            }
+            else
+            {
+                result = tanarCoList.Select(x => x.FelhasznaloNyomtatasiNev).Distinct().OrderBy(o => o).ToList();
+            }
+
+            return result;
+        }
+
+        public IList<string> GetTanuloList()
+        {
+            var result = new TanuloHelper(ConnectionType).GetTanuloCoList().Select(x => x.FelhasznaloNyomtatasiNev).Distinct().OrderBy(o => o).ToList();
+            return result;
+        }
+
+        public IList<string> GetTanuloNevOktAzonSzulDatumList()
+        {
+            var result = new TanuloHelper(ConnectionType).GetTanuloCoList().Select(x => $"{x.FelhasznaloNyomtatasiNev};{x.FelhasznaloSzuletesiIdo.ToString(Constants.ToStringPattern.HungarianDateWithSuffix)};{x.FelhasznaloOktatasiAzonosito}").Distinct().OrderBy(o => o).ToList();
+            return result;
+        }
+
+        public IList<string> GetGondviseloList()
+        {
+            var result = new GondviseloHelper(ConnectionType).GetGondviseloCoList().Select(x => Extensions.NameExtensions.GetNevSorrendben("F", x.Elotag, x.VezetekNev, x.KeresztNev)).Distinct().OrderBy(o => o).ToList();
+            return result;
+        }
+
+        public IList<string> GetHetiRendTipusList()
+        {
+            var hetiRendDictionaryItemList = ((int)GeneratedAdatszotarTipusEnum.HetiRendTipus).GetItemsByType(TanevId);
+            var result = hetiRendDictionaryItemList.OrderBy(o => o.Order).Select(x => x.Name).ToList();
+            return result;
+        }
+
+        public IList<string> GetHetNapjaTipusList()
+        {
+            var result = CommonUtils.OrderedHetNapjaTipusEnumList.Select(x => x.GetDisplayName(TanevId)).ToList();
+            return result;
+        }
+
+        public IList<string> GetTeremList()
+        {
+            var result = new TeremHelper(ConnectionType).GetTeremCoList().Select(x => x.Nev).OrderBy(o => o).ToList();
+            return result;
+        }
+
+        public IList<string> GetTeremListBySzervezet(int? szervezetTipus = null, int? szervezetId = null)
+        {
+            var result = new TeremHelper(ConnectionType).GetTeremCoListBySzervezet(szervezetTipus, szervezetId).Select(x => x.Nev).OrderBy(o => o).ToList();
+            return result;
+        }
+
+        public IList<string> GetMukodesiHelyList(DataSet feladatellatasiHelyDataSet)
+        {
+            var result = (from DataRow dataRow in feladatellatasiHelyDataSet.Tables[0].Rows select SDAConvert.ToString(dataRow["MukodesiHelyNev"])).ToList();
+            return result;
+        }
+
+        public IList<string> GetFeladatellatasiHelyList(DataSet feladatellatasiHelyDataSet)
+        {
+            var result = (from DataRow dataRow in feladatellatasiHelyDataSet.Tables[0].Rows select $"{SDAConvert.ToString(dataRow["MukodesiHelyNev"])} - {SDAConvert.ToString(dataRow["OktatasiNevelesiFeladatTipusId_DNAME"])}").ToList();
+            return result;
+        }
+
+        public IList<string> GetEllatottKoznevelesiFeladatList(DataSet feladatellatasiHelyDataSet)
+        {
+            var result = (from DataRow dataRow in feladatellatasiHelyDataSet.Tables[0].Rows select SDAConvert.ToString(dataRow["OktatasiNevelesiFeladatTipusId_DNAME"])).ToList();
+            return result;
+        }
+
+        #endregion Az excel-ekben megjelenő dropdownlist-ek kiválasztható elemei
+    }
+}

Kreta.BusinessLogic/Helpers/ImportExport/NebuloImportExportHelper.cs

@@ -0,0 +1,597 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Data;
+using System.IO;
+using System.Linq;
+using System.Runtime.Caching;
+using Aspose.Cells;
+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.Enums;
+using Kreta.Enums.ManualEnums.ImportExport;
+using Kreta.Resources;
+
+namespace Kreta.BusinessLogic.Helpers.ImportExport
+{
+    public class NebuloImportExportHelper : LogicBase
+    {
+        #region Fields
+
+        private readonly string _importObjectCacheKey;
+
+        #endregion Fields
+
+        #region Properties
+
+        public static Dictionary<int, string> ImportHeaderList => new Dictionary<int, string>
+        {
+            { 00, ImportExportNebuloResource.ImportHeaderNameFenntartoAzonosito },
+            { 01, ImportExportNebuloResource.ImportHeaderNameFenntartoMegnevezese },
+            { 02, ImportExportNebuloResource.ImportHeaderNameErvenyesKotelezettsegTipusa },
+            { 03, ImportExportNebuloResource.ImportHeaderNameOktatasiAzonositoSzam },
+            { 04, ImportExportNebuloResource.ImportHeaderNameViseltElonev },
+            { 05, ImportExportNebuloResource.ImportHeaderNameViseltVezeteknev },
+            { 06, ImportExportNebuloResource.ImportHeaderNameViseltKeresztnev },
+            { 07, ImportExportNebuloResource.ImportHeaderNameViseltNevNevsorrend },
+            { 08, ImportExportNebuloResource.ImportHeaderNameSzuletesiElonev },
+            { 09, ImportExportNebuloResource.ImportHeaderNameSzuletesiVezeteknev },
+            { 10, ImportExportNebuloResource.ImportHeaderNameSzuletesiKeresztnev },
+            { 11, ImportExportNebuloResource.ImportHeaderNameSzuletesiNevNevsorrend },
+            { 12, ImportExportNebuloResource.ImportHeaderNameAnyjaNeveElonev },
+            { 13, ImportExportNebuloResource.ImportHeaderNameAnyjaNeveVezeteknev },
+            { 14, ImportExportNebuloResource.ImportHeaderNameAnyjaNeveKeresztnev },
+            { 15, ImportExportNebuloResource.ImportHeaderNameAnyjaNeveNevsorrend },
+            { 16, ImportExportNebuloResource.ImportHeaderNameSzuletesiIdo },
+            { 17, ImportExportNebuloResource.ImportHeaderNameSzuletesiTelepules },
+            { 18, ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimOrszag },
+            { 19, ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimTelepules },
+            { 20, ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimIranyitoszam },
+            { 21, ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimKozteruletNev },
+            { 22, ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimKozteruletJelleg },
+            { 23, ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimHazszam },
+            { 24, ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimPontositas },
+            { 25, ImportExportNebuloResource.ImportHeaderNameAllandoLakcimOrszag },
+            { 26, ImportExportNebuloResource.ImportHeaderNameAllandoLakcimTelepules },
+            { 27, ImportExportNebuloResource.ImportHeaderNameAllandoLakcimIranyitoszam },
+            { 28, ImportExportNebuloResource.ImportHeaderNameAllandoLakcimKozteruletNev },
+            { 29, ImportExportNebuloResource.ImportHeaderNameAllandoLakcimKozteruletJelleg },
+            { 30, ImportExportNebuloResource.ImportHeaderNameAllandoLakcimHazszam },
+            { 31, ImportExportNebuloResource.ImportHeaderNameAllandoLakcimPontositas },
+            { 32, ImportExportNebuloResource.ImportHeaderNameErvenyesKotelezettsegKezdete },
+            { 33, ImportExportNebuloResource.ImportHeaderNameErvenyesKotelezettsegVege },
+            { 34, ImportExportNebuloResource.ImportHeaderNameHalasztasJogcime },
+            { 35, ImportExportNebuloResource.ImportHeaderNameHalasztastEngedelyezoSzervTipusa },
+            { 36, ImportExportNebuloResource.ImportHeaderNameHalasztastEngedelyezoSzervMegnevezese },
+            { 37, ImportExportNebuloResource.ImportHeaderNameHalasztasHatalyaVegdatuma },
+            { 38, ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoAktivVagySzuneteloJogviszonya },
+            { 39, ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyTipusa },
+            { 40, ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyStatusza },
+            { 41, ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyIntezmenyOmAzonositoja },
+            { 42, ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyIntezmenyNeve },
+            { 43, ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyUgyviteliHelySorszama },
+            { 44, ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyUgyviteliHelyAzonositoja },
+            { 45, ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyUgyviteliHelyNeve },
+            { 46, ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyUgyviteliHelyCime },
+            { 47, ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyKezdete },
+            { 48, ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonySzunetelesenekKezdete },
+            { 49, ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonySzunetelesenekVarhatoVege },
+            { 50, ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonySzunetelesJogcime },
+            { 51, ImportExportNebuloResource.ImportHeaderNameKotelezettsegetAzIlletekesFenntartohozTartozoIntezmenybenTeljesiti },
+            { 52, ImportExportNebuloResource.ImportHeaderNameAzUtolsoKotelezettsegetTeljesitoJogviszonyVegdatuma },
+        };
+
+        public static Dictionary<int, string> OldExportHeaderList => new Dictionary<int, string>
+        {
+            { 00, ImportExportNebuloResource.ExportHeaderNameElotag },
+            { 01, ImportExportNebuloResource.ExportHeaderNameTanuloCsaladneve },
+            { 02, ImportExportNebuloResource.ExportHeaderNameTanuloUtoneve },
+            { 03, ImportExportNebuloResource.ExportHeaderNameEdesanyjaSzuletesiCsaladneve },
+            { 04, ImportExportNebuloResource.ExportHeaderNameEdesanyjaSzuletesiUtoneve },
+            { 05, ImportExportNebuloResource.ExportHeaderNameSzuletesiHely },
+            { 06, ImportExportNebuloResource.ExportHeaderNameSzuletesiIdo },
+            { 07, ImportExportNebuloResource.ExportHeaderNameAllandoLakcimTelepules },
+            { 08, ImportExportNebuloResource.ExportHeaderNameAllandoLakcimIranyitoszam },
+            { 09, ImportExportNebuloResource.ExportHeaderNameAllandoLakcimKozteruletNev },
+            { 10, ImportExportNebuloResource.ExportHeaderNameAllandoLakcimKozteruletJelleg },
+            { 11, ImportExportNebuloResource.ExportHeaderNameAllandoLakcimHazszam },
+            { 12, ImportExportNebuloResource.ExportHeaderNameAllandoLakcimEmelet },
+            { 13, ImportExportNebuloResource.ExportHeaderNameAllandoLakcimAjto },
+            { 14, ImportExportNebuloResource.ExportHeaderNameNeme },
+            { 15, ImportExportNebuloResource.ExportHeaderNameNebuloOktatasiAzonositoSzama },
+            { 16, ImportExportNebuloResource.ExportHeaderNameSzuletesiCsaladneve },
+            { 17, ImportExportNebuloResource.ExportHeaderNameSzuletesiUtoneve },
+            { 18, ImportExportNebuloResource.ExportHeaderNameSzuletesiOrszag },
+            { 19, ImportExportNebuloResource.ExportHeaderNameAnyanyelv },
+            { 20, ImportExportNebuloResource.ExportHeaderNameAllampolgarsag },
+            { 21, ImportExportNebuloResource.ExportHeaderNameAllampolgarsag2 },
+            { 22, ImportExportNebuloResource.ExportHeaderNameTartozkodasiHelyMegegyezikALakcimmel },
+            { 23, ImportExportNebuloResource.ExportHeaderNameTHIRSZ },
+            { 24, ImportExportNebuloResource.ExportHeaderNameTHHelysegNev },
+            { 25, ImportExportNebuloResource.ExportHeaderNameTHKozteruletNev },
+            { 26, ImportExportNebuloResource.ExportHeaderNameTHKozteruletJelleg },
+            { 27, ImportExportNebuloResource.ExportHeaderNameTHSzam },
+            { 28, ImportExportNebuloResource.ExportHeaderNameTHEmelet },
+            { 29, ImportExportNebuloResource.ExportHeaderNameTHAjto },
+
+            { 30, ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviselojeNeve },
+            { 31, ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviselojenekRokonsagiFoka },
+            { 32, ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviselojeEmailCime },
+            { 33, ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviselojeTelefonszama },
+            { 34, ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviseloLakhelyMegegyezik },
+            { 35, ImportExportNebuloResource.ExportHeaderNameTKIRSZ },
+            { 36, ImportExportNebuloResource.ExportHeaderNameTKHelysegNev },
+            { 37, ImportExportNebuloResource.ExportHeaderNameTKKozteruletNev },
+            { 38, ImportExportNebuloResource.ExportHeaderNameTKKozteruletJelleg },
+            { 39, ImportExportNebuloResource.ExportHeaderNameTKSzam },
+            { 40, ImportExportNebuloResource.ExportHeaderNameTKEmelet },
+            { 41, ImportExportNebuloResource.ExportHeaderNameTKAjto },
+
+            { 42, ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviselojeNeve2 },
+            { 43, ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviselojenekRokonsagiFoka2 },
+            { 44, ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviselojeEmailCime2 },
+            { 45, ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviselojeTelefonszama2 },
+            { 46, ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviseloLakhelyMegegyezik2 },
+            { 47, ImportExportNebuloResource.ExportHeaderNameTKIRSZ2 },
+            { 48, ImportExportNebuloResource.ExportHeaderNameTKHelysegNev2 },
+            { 49, ImportExportNebuloResource.ExportHeaderNameTKKozteruletNev2 },
+            { 50, ImportExportNebuloResource.ExportHeaderNameTKKozteruletJelleg2 },
+            { 51, ImportExportNebuloResource.ExportHeaderNameTKSzam2 },
+            { 52, ImportExportNebuloResource.ExportHeaderNameTKEmelet2 },
+            { 53, ImportExportNebuloResource.ExportHeaderNameTKAjto2 },
+
+            { 54, ImportExportNebuloResource.ExportHeaderNameOvodaAzonosito },
+            { 55, ImportExportNebuloResource.ExportHeaderNameOvodaNeve },
+            { 56, ImportExportNebuloResource.ExportHeaderNameEletvitelszeruOttLakasKorzetes },
+            { 57, ImportExportNebuloResource.ExportHeaderNameSzakertoiBizottsagKormanyhivatalAltalKijelolttanulo },
+            { 58, ImportExportNebuloResource.ExportHeaderNameSzulojeTestvereTartosanBetegVagyFogyatekkalElo },
+            { 59, ImportExportNebuloResource.ExportHeaderNameTestvereAzIntezmenyTanuloja },
+            { 60, ImportExportNebuloResource.ExportHeaderNameSzulojenekMunkahelyeAzIskolaKorzetebenTalalhato },
+            { 61, ImportExportNebuloResource.ExportHeaderNameAzIskolaALakohelyetolEgyKilometerenBelulTalalhato },
+            { 62, ImportExportNebuloResource.ExportHeaderNameSajatosNevelesiIgenyu },
+            { 63, ImportExportNebuloResource.ExportHeaderNameSNILetszamSuly },
+            { 64, ImportExportNebuloResource.ExportHeaderNameBeilleszkedesiTanulasiMagatartasiProblemak },
+            { 65, ImportExportNebuloResource.ExportHeaderNameBTMLetszamSuly },
+            { 66, ImportExportNebuloResource.ExportHeaderNameFeladatellatasiHely },
+            { 67, ImportExportNebuloResource.ExportHeaderNameTagozat },
+            { 68, ImportExportNebuloResource.ExportHeaderNameKirSzolgaltatas },
+            { 69, ImportExportNebuloResource.ExportHeaderNameEtikaVagyHitEsErkolcstan },
+            { 70, ImportExportNebuloResource.ExportHeaderNameEgyhaziJogiSzemelyekHitEsErkolcstanOktatasai },
+            { 71, ImportExportNebuloResource.ExportHeaderNameMegjegyzes },
+            { 72, ImportExportNebuloResource.ExportHeaderNameFelvetelStatusza },
+            { 73, ImportExportNebuloResource.ExportHeaderNameOsszevontOsztalybaKerult },
+            { 74, ImportExportNebuloResource.ExportHeaderNameIndoklas }
+        };
+
+        public NebuloImportCo ImportCo
+        {
+            get => (NebuloImportCo)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 NebuloImportExportHelper(IConnectionType connectionType) : base(connectionType)
+        {
+            _importObjectCacheKey = $"{nameof(NebuloImportCo)}_{IntezmenyId}_{FelhasznaloId}_ImportObjectCacheKey";
+        }
+
+        #endregion Constructors
+
+        public void SetImportCo(List<List<string>> importData, int importMuvelet)
+        {
+            NebuloImportCo importCo = GetImportCoFromImportData(importData);
+            importCo.ImportMuvelet = importMuvelet;
+
+            SetNemImportalhatoSorokByValidation(importCo);
+
+            SetOperationAndNemImportalhatoSorokByOperation(importCo);
+
+            var mainImportJsonItemList = new List<NebuloImportJsonItemCo>(importCo.MainImportItemList.Select(x => new NebuloImportJsonItemCo(x, TanevId, IntezmenyId, FelhasznaloId)));
+            importCo.MainImportJsonItemList = mainImportJsonItemList;
+
+            ImportCo = importCo;
+        }
+
+        private static void SetNemImportalhatoSorokByValidation(NebuloImportCo importCo)
+        {
+            Dictionary<int, List<ValidationResult>> validationResultDictionary = importCo.Validate();
+
+            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
+            foreach (NebuloImportItemCo 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(NebuloImportCo importCo)
+        {
+            int importMuvelet = importCo.ImportMuvelet;
+            //NOTE: Azért van szükség Dictionary-re, mert így sokkal gyorsabb a keresés!
+            Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary = GetCompareHashImportItemCompareCoDictionary(importCo.NebuloCoList);
+            foreach (NebuloImportItemCo 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...
+                else
+                {
+                    ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                    //NOTE: ...ha az import művelet DeleteAndInsert és a db-ből jövő adat Importalt(a nem importáltakat egyelőre nem töröljük), akkor Insert, mert töröljük a korábbi elemeket és újra be kell szúrni!
+                    if (importMuvelet == (int)ImportMuveletEnum.DeleteAndInsert && importItemCompareCo.Importalt)
+                    {
+                        importItem.Operation = (int)ImportItemOperationEnum.Insert;
+                    }
+                    //NOTE: ...ha nincs törlés, akkor...
+                    else
+                    {
+                        //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
+                        if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                        {
+                            importItem.Id = importItemCompareCo.Id;
+                            importItem.Operation = (int)ImportItemOperationEnum.Update;
+                        }
+                        //NOTE: ...ha a művelet nem InsertAndUpdate, akkor hozzá kell adni a nem NemImportalhatoItemList-hez és jelezni, hogy már szerepel az adatbázisban(Insert vagy DeleteAndInsert műveletnél. A DeleteAndInsert csak akkor fut be ide, ha az elem nem importált.)!
+                        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 NebuloImportCo GetImportCoFromImportData(List<List<string>> importData)
+        {
+            var importCo = new NebuloImportCo
+            {
+                NebuloCoList = new NebuloHelper(ConnectionType).GetNebuloList()
+            };
+
+            DataSet feladatellatasiHelyDataSet = Dal.CustomConnection.Run(ConnectionType, dalHandler => dalHandler.FeladatEllatasiHelyDal().GetFeladatEllatasiHelyekForkDropDown(TanevId));
+
+            int? feladatellatasiHelyId = feladatellatasiHelyDataSet.Tables[0].Rows.Count > 1 ? (int?)null : SDAConvert.ToInt32(feladatellatasiHelyDataSet.Tables[0].Rows[0]["ID"]);
+
+            int lineNumber = 1;
+            foreach (List<string> importDataRow in importData.Skip(1))
+            {
+                var importItemCo = new NebuloImportItemCo(TanevId)
+                {
+                    LineNumber = lineNumber,
+
+                    FenntartoAzonositoImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameFenntartoAzonosito)],
+                    FenntartoMegnevezeseImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameFenntartoMegnevezese)],
+                    ErvenyesKotelezettsegTipusaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameErvenyesKotelezettsegTipusa)],
+                    OktatasiAzonositoSzamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameOktatasiAzonositoSzam)],
+                    ViseltElonevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameViseltElonev)],
+                    ViseltVezeteknevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameViseltVezeteknev)],
+                    ViseltKeresztnevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameViseltKeresztnev)],
+                    ViseltNevNevsorrendImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameViseltNevNevsorrend)],
+                    SzuletesiElonevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameSzuletesiElonev)],
+                    SzuletesiVezeteknevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameSzuletesiVezeteknev)],
+                    SzuletesiKeresztnevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameSzuletesiKeresztnev)],
+                    SzuletesiNevNevsorrendImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameSzuletesiNevNevsorrend)],
+                    AnyjaNeveElonevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAnyjaNeveElonev)],
+                    AnyjaNeveVezeteknevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAnyjaNeveVezeteknev)],
+                    AnyjaNeveKeresztnevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAnyjaNeveKeresztnev)],
+                    AnyjaNeveNevsorrendImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAnyjaNeveNevsorrend)],
+                    SzuletesiIdoImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameSzuletesiIdo)],
+                    SzuletesiTelepulesImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameSzuletesiTelepules)],
+                    TartozkodasiCimOrszagImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimOrszag)],
+                    TartozkodasiCimTelepulesImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimTelepules)],
+                    TartozkodasiCimIranyitoszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimIranyitoszam)],
+                    TartozkodasiCimKozteruletNevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimKozteruletNev)],
+                    TartozkodasiCimKozteruletJellegImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimKozteruletJelleg)],
+                    TartozkodasiCimHazszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimHazszam)],
+                    TartozkodasiCimPontositasImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimPontositas)],
+                    AllandoLakcimOrszagImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAllandoLakcimOrszag)],
+                    AllandoLakcimTelepulesImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAllandoLakcimTelepules)],
+                    AllandoLakcimIranyitoszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAllandoLakcimIranyitoszam)],
+                    AllandoLakcimKozteruletNevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAllandoLakcimKozteruletNev)],
+                    AllandoLakcimKozteruletJellegImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAllandoLakcimKozteruletJelleg)],
+                    AllandoLakcimHazszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAllandoLakcimHazszam)],
+                    AllandoLakcimPontositasImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAllandoLakcimPontositas)],
+                    ErvenyesKotelezettsegKezdeteImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameErvenyesKotelezettsegKezdete)],
+                    ErvenyesKotelezettsegVegeImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameErvenyesKotelezettsegVege)],
+                    HalasztasJogcimeImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameHalasztasJogcime)],
+                    HalasztastEngedelyezoSzervTipusaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameHalasztastEngedelyezoSzervTipusa)],
+                    HalasztastEngedelyezoSzervMegnevezeseImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameHalasztastEngedelyezoSzervMegnevezese)],
+                    HalasztasHatalyaVegdatumaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameHalasztasHatalyaVegdatuma)],
+                    KotelezettseghezKapcsolodoAktivVagySzuneteloJogviszonyaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoAktivVagySzuneteloJogviszonya)],
+                    KotelezettseghezKapcsolodoJogviszonyTipusaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyTipusa)],
+                    KotelezettseghezKapcsolodoJogviszonyStatuszaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyStatusza)],
+                    KotelezettseghezKapcsolodoJogviszonyIntezmenyOmAzonositojaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyIntezmenyOmAzonositoja)],
+                    KotelezettseghezKapcsolodoJogviszonyIntezmenyNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyIntezmenyNeve)],
+                    KotelezettseghezKapcsolodoJogviszonyUgyviteliHelySorszamaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyUgyviteliHelySorszama)],
+                    KotelezettseghezKapcsolodoJogviszonyUgyviteliHelyAzonositojaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyUgyviteliHelyAzonositoja)],
+                    KotelezettseghezKapcsolodoJogviszonyUgyviteliHelyNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyUgyviteliHelyNeve)],
+                    KotelezettseghezKapcsolodoJogviszonyUgyviteliHelyCimeImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyUgyviteliHelyCime)],
+                    KotelezettseghezKapcsolodoJogviszonyKezdeteImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyKezdete)],
+                    KotelezettseghezKapcsolodoJogviszonySzunetelesenekKezdeteImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonySzunetelesenekKezdete)],
+                    KotelezettseghezKapcsolodoJogviszonySzunetelesenekVarhatoVegeImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonySzunetelesenekVarhatoVege)],
+                    KotelezettseghezKapcsolodoJogviszonySzunetelesJogcimeImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonySzunetelesJogcime)],
+                    KotelezettsegetAzIlletekesFenntartohozTartozoIntezmenybenTeljesitiImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettsegetAzIlletekesFenntartohozTartozoIntezmenybenTeljesiti)],
+                    AzUtolsoKotelezettsegetTeljesitoJogviszonyVegdatumaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAzUtolsoKotelezettsegetTeljesitoJogviszonyVegdatuma)],
+
+                    FeladatellatasiHelyId = feladatellatasiHelyId
+                };
+
+                var nebulo = importCo.NebuloCoList.FirstOrDefault(x =>
+                    $"{x.SzuletesiVezeteknevComparableString} {x.SzuletesiKeresztnevComparableString}" == $"{importItemCo.SzuletesiVezeteknev?.ToComparableString()} {importItemCo.SzuletesiKeresztnev?.ToComparableString()}" &&
+                    $"{x.AnyjaVezetekneveComparableString} {x.AnyjaKeresztneveComparableString}" == $"{importItemCo.AnyjaVezeteknev?.ToComparableString()} { importItemCo.AnyjaKeresztnev?.ToComparableString()}" &&
+                    x.SzuletesiHelyComparableString == importItemCo.SzuletesiHely?.ToComparableString() &&
+                    x.SzuletesiIdo == importItemCo.SzuletesiIdo);
+
+                if (nebulo?.FelvetelStatuszaId == null)
+                {
+                    importItemCo.FelvetelStatuszaId = (int)FelvetelStatuszaTipusEnum.NemJelentMeg;
+                }
+                else
+                {
+                    importItemCo.FelvetelStatuszaId = nebulo.FelvetelStatuszaId.Value;
+                }
+
+                string md5HashInput =
+                    $"{importItemCo.SzuletesiVezeteknev?.ToComparableString()} {importItemCo.SzuletesiKeresztnev?.ToComparableString()}" +
+                    $"{importItemCo.AnyjaVezeteknev?.ToComparableString()} {importItemCo.AnyjaKeresztnev?.ToComparableString()}" +
+                    importItemCo.SzuletesiHely?.ToComparableString() +
+                    importItemCo.SzuletesiIdoString?.ToComparableString();
+                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                importCo.MainImportItemList.Add(importItemCo);
+
+                lineNumber++;
+            }
+
+            return importCo;
+        }
+
+        public MemoryStream GetExport(NebuloSearchCo searchCo = null)
+        {
+            var dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary();
+
+            List<NebuloCo> coList = new NebuloHelper(ConnectionType).GetNebuloListForExport(searchCo);
+            using (var workbook = new Workbook())
+            {
+                var worksheet = ImportExportHelper.GetWorksheetsWithDropDownFormula(workbook, ImportExportNebuloResource.ImportDefaultSheetName, OldExportHeaderList, dropDownColumnSourceDictionary);
+
+                int rowNumber = 1;
+                foreach (NebuloCo co in coList.OrderBy(x => x.Vezeteknev).ThenBy(x => x.Keresztnev).ToList())
+                {
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameElotag)].Value = co.Elotag ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTanuloCsaladneve)].Value = co.Vezeteknev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTanuloUtoneve)].Value = co.Keresztnev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameEdesanyjaSzuletesiCsaladneve)].Value = co.AnyjaVezetekneve ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameEdesanyjaSzuletesiUtoneve)].Value = co.AnyjaKeresztneve ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameSzuletesiHely)].Value = co.SzuletesiHely ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameSzuletesiIdo)].Value = co.SzuletesiIdo?.ToString(Constants.ToStringPattern.HungarianDate) ?? string.Empty;
+
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameAllandoLakcimTelepules)].Value = co.Helyseg ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameAllandoLakcimIranyitoszam)].Value = co.Iranyitoszam ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameAllandoLakcimKozteruletNev)].Value = co.KozteruletNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameAllandoLakcimKozteruletJelleg)].Value = co.KozteruletJellegNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameAllandoLakcimHazszam)].Value = co.Hazszam ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameAllandoLakcimEmelet)].Value = co.Emelet ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameAllandoLakcimAjto)].Value = co.Ajto ?? string.Empty;
+
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameNeme)].Value = co.NemeNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameNebuloOktatasiAzonositoSzama)].Value = co.OktatasiAzonositoSzama ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameSzuletesiCsaladneve)].Value = co.SzuletesiVezeteknev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameSzuletesiUtoneve)].Value = co.SzuletesiKeresztnev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameSzuletesiOrszag)].Value = co.SzuletesiOrszagNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameAnyanyelv)].Value = co.AnyanyelvNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameAllampolgarsag)].Value = co.AllampolgarsagNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameAllampolgarsag2)].Value = co.Allampolgarsag2Nev ?? string.Empty;
+
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTartozkodasiHelyMegegyezikALakcimmel)].Value = co.THCimeAzonos.GetDisplayName();
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTHIRSZ)].Value = co.THIranyitoszam ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTHHelysegNev)].Value = co.THHelyseg ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTHKozteruletNev)].Value = co.THKozteruletNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTHKozteruletJelleg)].Value = co.THKozteruletJellegNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTHSzam)].Value = co.THHazszam ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTHEmelet)].Value = co.THEmelet ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTHAjto)].Value = co.THAjto ?? string.Empty;
+
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviselojeNeve)].Value = co.TKNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviselojenekRokonsagiFoka)].Value = co.TKRokonsagiFokNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviselojeEmailCime)].Value = co.TKEmail ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviselojeTelefonszama)].Value = co.TKTelefon ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviseloLakhelyMegegyezik)].Value = co.TKCimeAzonos.GetDisplayName();
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTKIRSZ)].Value = co.TKIranyitoszam ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTKHelysegNev)].Value = co.TKHelyseg ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTKKozteruletNev)].Value = co.TKKozteruletNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTKKozteruletJelleg)].Value = co.TKKozteruletJellegNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTKSzam)].Value = co.TKHazszam ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTKEmelet)].Value = co.TKEmelet ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTKAjto)].Value = co.TKAjto ?? string.Empty;
+
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviselojeNeve2)].Value = co.TKNev2 ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviselojenekRokonsagiFoka2)].Value = co.TKRokonsagiFok2Nev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviselojeEmailCime2)].Value = co.TKEmail2 ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviselojeTelefonszama2)].Value = co.TKTelefon2 ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTorvenyesKepviseloLakhelyMegegyezik2)].Value = co.TKCimeAzonos2.GetDisplayName();
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTKIRSZ2)].Value = co.TKIranyitoszam2 ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTKHelysegNev2)].Value = co.TKHelyseg2 ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTKKozteruletNev2)].Value = co.TKKozteruletNev2 ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTKKozteruletJelleg2)].Value = co.TKKozteruletJelleg2Nev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTKSzam2)].Value = co.TKHazszam2 ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTKEmelet2)].Value = co.TKEmelet2 ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTKAjto2)].Value = co.TKAjto2 ?? string.Empty;
+
+                    //worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameOvodaAzonosito)].Value = co.OvodaAzonosito ?? string.Empty;
+                    //worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameOvodaNeve)].Value = co.OvodaNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameEletvitelszeruOttLakasKorzetes)].Value = co.EletvitelszeruOttLakasKorzetes.GetDisplayName();
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameSzakertoiBizottsagKormanyhivatalAltalKijelolttanulo)].Value = co.SzakertoiBizottsagKormanyhivatalAltalKijelolttanulo.GetDisplayName();
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameSzulojeTestvereTartosanBetegVagyFogyatekkalElo)].Value = co.SzulojeTestvereTartosanBetegVagyFogyatekkalElo.GetDisplayName();
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTestvereAzIntezmenyTanuloja)].Value = co.TestvereAzIntezmenyTanuloja.GetDisplayName();
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameSzulojenekMunkahelyeAzIskolaKorzetebenTalalhato)].Value = co.SzulojenekMunkahelyeAzIskolaKorzetebenTalalhato.GetDisplayName();
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameAzIskolaALakohelyetolEgyKilometerenBelulTalalhato)].Value = co.AzIskolaALakohelyetolEgyKilometerenBelulTalalhato.GetDisplayName();
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameSajatosNevelesiIgenyu)].Value = co.SNI?.GetDisplayName() ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameSNILetszamSuly)].Value = co.SNILetszamSuly?.ToString() ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameBeilleszkedesiTanulasiMagatartasiProblemak)].Value = co.BTM?.GetDisplayName() ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameBTMLetszamSuly)].Value = co.BTMLetszamSuly?.ToString() ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameFeladatellatasiHely)].Value = co.FeladatellatasiHelyNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameTagozat)].Value = co.TagozatNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameKirSzolgaltatas)].Value = co.KirSzolgaltatasTipusNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameEtikaVagyHitEsErkolcstan)].Value = co.EtikaHitErkolcstanNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameEgyhaziJogiSzemelyekHitEsErkolcstanOktatasai)].Value = co.FelekezetNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameMegjegyzes)].Value = co.Megjegyzes ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameFelvetelStatusza)].Value = co.FelvetelStatuszaNev ?? string.Empty;
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameOsszevontOsztalybaKerult)].Value = co.IsOsszevontOsztaly.GetDisplayName();
+                    worksheet.Cells[rowNumber, OldExportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ExportHeaderNameIndoklas)].Value = co.Indoklas ?? string.Empty;
+
+                    rowNumber++;
+                }
+
+                MemoryStream memoryStream = SimpleExportLogic.GetWorkbookMemoryStream(workbook);
+                return memoryStream;
+            }
+        }
+
+        public MemoryStream GetNemImportalhatoSorokExport()
+        {
+            var dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary();
+
+            using (var workbook = new Workbook())
+            {
+                var worksheet = ImportExportHelper.GetWorksheetsWithDropDownFormula(workbook, ImportExportNebuloResource.ImportDefaultSheetName, ImportHeaderList, dropDownColumnSourceDictionary);
+
+                int rowNumber = 1;
+                foreach (NebuloImportItemCo co in ImportCo.NemImportalhatoItemList.OrderBy(x => x.Vezeteknev).ThenBy(x => x.Keresztnev).ToList())
+                {
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameFenntartoAzonosito)].Value = co.FenntartoAzonositoImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameFenntartoMegnevezese)].Value = co.FenntartoMegnevezeseImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameErvenyesKotelezettsegTipusa)].Value = co.ErvenyesKotelezettsegTipusaImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameOktatasiAzonositoSzam)].Value = co.OktatasiAzonositoSzamImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameViseltElonev)].Value = co.ViseltElonevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameViseltVezeteknev)].Value = co.ViseltVezeteknevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameViseltKeresztnev)].Value = co.ViseltKeresztnevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameViseltNevNevsorrend)].Value = co.ViseltNevNevsorrendImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameSzuletesiElonev)].Value = co.SzuletesiElonevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameSzuletesiVezeteknev)].Value = co.SzuletesiVezeteknevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameSzuletesiKeresztnev)].Value = co.SzuletesiKeresztnevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameSzuletesiNevNevsorrend)].Value = co.SzuletesiNevNevsorrendImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAnyjaNeveElonev)].Value = co.AnyjaNeveElonevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAnyjaNeveVezeteknev)].Value = co.AnyjaNeveVezeteknevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAnyjaNeveKeresztnev)].Value = co.AnyjaNeveKeresztnevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAnyjaNeveNevsorrend)].Value = co.AnyjaNeveNevsorrendImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameSzuletesiIdo)].Value = co.SzuletesiIdoImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameSzuletesiTelepules)].Value = co.SzuletesiTelepulesImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimOrszag)].Value = co.TartozkodasiCimOrszagImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimTelepules)].Value = co.TartozkodasiCimTelepulesImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimIranyitoszam)].Value = co.TartozkodasiCimIranyitoszamImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimKozteruletNev)].Value = co.TartozkodasiCimKozteruletNevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimKozteruletJelleg)].Value = co.TartozkodasiCimKozteruletJellegImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimHazszam)].Value = co.TartozkodasiCimHazszamImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameTartozkodasiCimPontositas)].Value = co.TartozkodasiCimPontositasImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAllandoLakcimOrszag)].Value = co.AllandoLakcimOrszagImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAllandoLakcimTelepules)].Value = co.AllandoLakcimTelepulesImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAllandoLakcimIranyitoszam)].Value = co.AllandoLakcimIranyitoszamImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAllandoLakcimKozteruletNev)].Value = co.AllandoLakcimKozteruletNevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAllandoLakcimKozteruletJelleg)].Value = co.AllandoLakcimKozteruletJellegImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAllandoLakcimHazszam)].Value = co.AllandoLakcimHazszamImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAllandoLakcimPontositas)].Value = co.AllandoLakcimPontositasImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameErvenyesKotelezettsegKezdete)].Value = co.ErvenyesKotelezettsegKezdeteImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameErvenyesKotelezettsegVege)].Value = co.ErvenyesKotelezettsegVegeImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameHalasztasJogcime)].Value = co.HalasztasJogcimeImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameHalasztastEngedelyezoSzervTipusa)].Value = co.HalasztastEngedelyezoSzervTipusaImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameHalasztastEngedelyezoSzervMegnevezese)].Value = co.HalasztastEngedelyezoSzervMegnevezeseImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameHalasztasHatalyaVegdatuma)].Value = co.HalasztasHatalyaVegdatumaImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoAktivVagySzuneteloJogviszonya)].Value = co.KotelezettseghezKapcsolodoAktivVagySzuneteloJogviszonyaImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyTipusa)].Value = co.KotelezettseghezKapcsolodoJogviszonyTipusaImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyStatusza)].Value = co.KotelezettseghezKapcsolodoJogviszonyStatuszaImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyIntezmenyOmAzonositoja)].Value = co.KotelezettseghezKapcsolodoJogviszonyIntezmenyOmAzonositojaImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyIntezmenyNeve)].Value = co.KotelezettseghezKapcsolodoJogviszonyIntezmenyNeveImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyUgyviteliHelySorszama)].Value = co.KotelezettseghezKapcsolodoJogviszonyUgyviteliHelySorszamaImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyUgyviteliHelyAzonositoja)].Value = co.KotelezettseghezKapcsolodoJogviszonyUgyviteliHelyAzonositojaImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyUgyviteliHelyNeve)].Value = co.KotelezettseghezKapcsolodoJogviszonyUgyviteliHelyNeveImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyUgyviteliHelyCime)].Value = co.KotelezettseghezKapcsolodoJogviszonyUgyviteliHelyCimeImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonyKezdete)].Value = co.KotelezettseghezKapcsolodoJogviszonyKezdeteImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonySzunetelesenekKezdete)].Value = co.KotelezettseghezKapcsolodoJogviszonySzunetelesenekKezdeteImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonySzunetelesenekVarhatoVege)].Value = co.KotelezettseghezKapcsolodoJogviszonySzunetelesenekVarhatoVegeImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettseghezKapcsolodoJogviszonySzunetelesJogcime)].Value = co.KotelezettseghezKapcsolodoJogviszonySzunetelesJogcimeImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameKotelezettsegetAzIlletekesFenntartohozTartozoIntezmenybenTeljesiti)].Value = co.KotelezettsegetAzIlletekesFenntartohozTartozoIntezmenybenTeljesitiImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportNebuloResource.ImportHeaderNameAzUtolsoKotelezettsegetTeljesitoJogviszonyVegdatuma)].Value = co.AzUtolsoKotelezettsegetTeljesitoJogviszonyVegdatumaImportData;
+
+                    Cell errorCell = worksheet.Cells[rowNumber, ImportHeaderList.Count];
+                    errorCell.Value = string.Join(Environment.NewLine, co.ErrorList);
+                    errorCell.SetTextWrap();
+
+                    rowNumber++;
+                }
+
+                var sheetCodeNameAndColumnsToWrapIndexDictionary = new Dictionary<string, List<int>>
+                {
+                    { workbook.Worksheets[0].CodeName, new List<int> { ImportHeaderList.Count } }
+                };
+                MemoryStream memoryStream = SimpleExportLogic.GetWorkbookMemoryStream(workbook, sheetCodeNameAndColumnsToWrapIndexDictionary);
+                return memoryStream;
+            }
+        }
+
+        private Dictionary<string, ImportItemCompareCo> GetCompareHashImportItemCompareCoDictionary(List<NebuloCo> coList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (NebuloCo co in coList)
+            {
+                string md5HashInput =
+                    $"{co.SzuletesiVezeteknevComparableString} {co.SzuletesiKeresztnevComparableString}" +
+                    $"{co.AnyjaVezetekneveComparableString} {co.AnyjaKeresztneveComparableString}" +
+                    co.SzuletesiHelyComparableString +
+                    co.SzuletesiIdoComparableString;
+                string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                var importItemCompareCo = new ImportItemCompareCo
+                {
+                    Id = co.Id.Value,
+                    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;
+        }
+
+        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary()
+        {
+            //NOTE: Create dropdown lists
+            var logicalColumnDictionary = new Dictionary<string, IList<string>>();
+            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>(logicalColumnDictionary);
+
+            return dropDownColumnSourceDictionary;
+        }
+    }
+}

Kreta.BusinessLogic/Helpers/ImportExport/OrarendImportExportHelper.cs

@@ -0,0 +1,801 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Data;
+using System.IO;
+using System.Linq;
+using System.Runtime.Caching;
+using Aspose.Cells;
+using Kreta.BusinessLogic.Classes;
+using Kreta.BusinessLogic.HelperClasses;
+using Kreta.BusinessLogic.HelperClasses.ImportCo;
+using Kreta.BusinessLogic.Helpers.SystemSettings;
+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;
+using Kreta.Enums.ManualEnums.ImportExport;
+using Kreta.Enums.ManualEnums.SystemSettings;
+using Kreta.Resources;
+using Newtonsoft.Json;
+using Cache = Kreta.Core.Cache;
+
+namespace Kreta.BusinessLogic.Helpers.ImportExport
+{
+    public class OrarendImportExportHelper : BaseTantargyfelosztasImportExportHelper
+    {
+        #region Fields
+
+        private readonly string _importObjectCacheKey;
+
+        #endregion Fields
+
+        #region Properties
+
+        public static Dictionary<int, string> ImportHeaderList =>
+            new Dictionary<int, string>
+            {
+                { 00, ImportExportOrarendResource.ImportHeaderNameHetirend },
+                { 01, ImportExportOrarendResource.ImportHeaderNameNap },
+                { 02, ImportExportOrarendResource.ImportHeaderNameOra },
+                { 03, ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly },
+                { 04, ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport },
+                { 05, ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy },
+                { 06, ImportExportTantargyfelosztasResource.ImportHeaderNameTanar },
+                { 07, ImportExportOrarendResource.ImportHeaderNameHelyiseg }
+            };
+
+        public static Dictionary<int, string> ImportHeaderListNapirend =>
+            new Dictionary<int, string>
+            {
+                { 00, ImportExportOrarendResource.ImportHeaderNameHetirend },
+                { 01, ImportExportOrarendResource.ImportHeaderNameNap },
+                { 02, ImportExportOrarendResource.ImportHeaderNameFoglalkozasKezdete },
+                { 03, ImportExportOrarendResource.ImportHeaderNameFoglalkozasVege },
+                { 04, ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly },
+                { 05, ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport },
+                { 06, ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy },
+                { 07, ImportExportTantargyfelosztasResource.ImportHeaderNameTanar },
+                { 08, ImportExportOrarendResource.ImportHeaderNameHelyiseg }
+            };
+
+        public static Dictionary<int, string> ImportHeaderListOraErvenyessegiIdovel =>
+            new Dictionary<int, string>
+            {
+                { 00, ImportExportOrarendResource.ImportHeaderNameOraErvenyessegKezdete },
+                { 01, ImportExportOrarendResource.ImportHeaderNameOraErvenyessegVege },
+                { 02, ImportExportOrarendResource.ImportHeaderNameHetirend },
+                { 03, ImportExportOrarendResource.ImportHeaderNameNap },
+                { 04, ImportExportOrarendResource.ImportHeaderNameOra },
+                { 05, ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly },
+                { 06, ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport },
+                { 07, ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy },
+                { 08, ImportExportTantargyfelosztasResource.ImportHeaderNameTanar },
+                { 09, ImportExportOrarendResource.ImportHeaderNameHelyiseg }
+            };
+
+        public static Dictionary<int, string> ImportHeaderListNapirendOraErvenyessegiIdovel =>
+            new Dictionary<int, string>
+            {
+                { 00, ImportExportOrarendResource.ImportHeaderNameOraErvenyessegKezdete },
+                { 01, ImportExportOrarendResource.ImportHeaderNameOraErvenyessegVege },
+                { 02, ImportExportOrarendResource.ImportHeaderNameHetirend },
+                { 03, ImportExportOrarendResource.ImportHeaderNameNap },
+                { 04, ImportExportOrarendResource.ImportHeaderNameFoglalkozasKezdete },
+                { 05, ImportExportOrarendResource.ImportHeaderNameFoglalkozasVege },
+                { 06, ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly },
+                { 07, ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport },
+                { 08, ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy },
+                { 09, ImportExportTantargyfelosztasResource.ImportHeaderNameTanar },
+                { 10, ImportExportOrarendResource.ImportHeaderNameHelyiseg }
+            };
+
+        public OrarendImportCo ImportCo
+        {
+            get => (OrarendImportCo)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 OrarendImportExportHelper(IConnectionType connectionType) : base(connectionType)
+        {
+            _importObjectCacheKey = $"{nameof(OrarendImportCo)}_{IntezmenyId}_{FelhasznaloId}_ImportObjectCacheKey";
+        }
+
+        #endregion Constructors
+
+        public void SetImportCo(OrarendImportFileUploadCo orarendImportFileUploadCo, bool isAktivTanev)
+        {
+            OrarendImportCo importCo = GetImportCoFromImportData(orarendImportFileUploadCo, isAktivTanev);
+            importCo.OrarendImportMuvelet = orarendImportFileUploadCo.OrarendImportMuvelet;
+            importCo.FeladatellatasiHelyId = orarendImportFileUploadCo.FeladatellatasiHelyId;
+            importCo.MukodesiHelyId = new FeladatEllatasiHelyHelper(ConnectionType).GetMukodesiHelyIdByFeladatellatasiHelyId(orarendImportFileUploadCo.FeladatellatasiHelyId);
+
+            SetNemImportalhatoSorokByValidation(importCo, isAktivTanev);
+
+            //NOTE: Azért van szükség Dictionary-kre, mert így sokkal gyorsabb a keresés!
+            Dictionary<string, ImportItemCompareCo> tantargyCompareHashImportItemCompareCoDictionary = GetTantargyCompareHashImportItemCompareCoDictionary();
+            Dictionary<string, ImportItemCompareCo> osztalyCompareHashImportItemCompareCoDictionary = GetOsztalyCompareHashImportItemCompareCoDictionary();
+            Dictionary<string, ImportItemCompareCo> csoportCompareHashImportItemCompareCoDictionary = GetCsoportCompareHashImportItemCompareCoDictionary();
+            Dictionary<string, ImportItemCompareCo> tantargyfelosztasCompareHashImportItemCompareCoDictionary = null;
+            if (orarendImportFileUploadCo.IsTtfImport)
+            {
+                tantargyfelosztasCompareHashImportItemCompareCoDictionary = GetTantargyfelosztasCompareHashImportItemCompareCoDictionary(importCo.GetBaseImportItemCoList());
+            }
+
+            Dictionary<string, ImportItemCompareCo> teremCompareHashImportItemCompareCoDictionary = GetTeremCompareHashImportItemCompareCoDictionary();
+            foreach (OrarendImportItemCo importItem in importCo.MainImportItemList)
+            {
+                SetOperationTantargy(importItem, tantargyCompareHashImportItemCompareCoDictionary);
+                SetOperationOsztaly(importItem, osztalyCompareHashImportItemCompareCoDictionary);
+                SetOperationCsoport(importItem, csoportCompareHashImportItemCompareCoDictionary);
+                if (orarendImportFileUploadCo.IsTtfImport)
+                {
+                    SetOperationTantargyfelosztas(importItem, tantargyfelosztasCompareHashImportItemCompareCoDictionary, orarendImportFileUploadCo.OrarendImportMuvelet, importCo.OrarendiElemekRogzitesenekElofeltetele);
+                }
+
+                SetOperationTerem(importItem, teremCompareHashImportItemCompareCoDictionary);
+                SetOperationOrarend(importItem);
+            }
+
+            //NOTE: Azokat a sorokat, amelyek bekerültek a NemImportalhatoItemList-be, azokat kiveszzük a MainImportItemList-ből!
+            importCo.MainImportItemList.RemoveRange(importCo.NemImportalhatoItemList);
+
+            List<string> vegzosOsztalyCsoportNevComperableList =
+                new OsztalyCsoportHelper(ConnectionType)
+                    .GetOsztalyCsoportCoList()
+                    .Where(x => x.IsVegzosEvfolyam)
+                    .Select(x => x.NevComparableString)
+                    .ToList();
+
+            int feladatKategoriaId = new FeladatEllatasiHelyHelper(ConnectionType).GetFeladatKategoriaId(orarendImportFileUploadCo.FeladatellatasiHelyId);
+            var tantargyImportJsonItemList = new List<TantargyImportJsonItemCo>();
+            var osztalyCsoportImportJsonItemList = new List<OsztalyCsoportImportJsonItemCo>();
+            var osztalyImportJsonItemList = new List<OsztalyImportJsonItemCo>();
+            var csoportImportJsonItemList = new List<CsoportImportJsonItemCo>();
+            var tantargyfelosztasImportJsonItemList = new List<TantargyfelosztasImportJsonItemCo>();
+            var teremImportJsonItemList = new List<TeremImportJsonItemCo>();
+            var mainImportJsonItemList = new List<OrarendImportJsonItemCo>();
+
+            var csoportTipusOraPercDict = new AdatszotarHelper(ConnectionType).GetCsoportTipusList().ToDictionary(x => x.Id, x => x.OraPerc);
+
+            foreach (OrarendImportItemCo importItem in importCo.MainImportItemList)
+            {
+                if (tantargyImportJsonItemList.All(x => x.Nev.ToComparableString() != importItem.TantargyNev.ToComparableString()) &&
+                    importItem.OperationTantargy == (int)ImportItemOperationEnum.Insert)
+                {
+                    tantargyImportJsonItemList.Add(new TantargyImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
+                }
+
+                var osztalyNevToCompare = importItem.OsztalyNev?.ToComparableString();
+                if (!string.IsNullOrWhiteSpace(osztalyNevToCompare) &&
+                    !osztalyImportJsonItemList.Select(x => x.OsztalyCsoportNev.ToComparableString()).Contains(osztalyNevToCompare) &&
+                    importItem.OperationOsztaly == (int)ImportItemOperationEnum.Insert)
+                {
+                    osztalyImportJsonItemList.Add(new OsztalyImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
+                    osztalyCsoportImportJsonItemList.Add(new OsztalyCsoportImportJsonItemCo(importItem, importItem.OperationOsztaly, importItem.OsztalyNev, importCo.FeladatellatasiHelyId, feladatKategoriaId, TanevId, IntezmenyId, FelhasznaloId));
+                }
+
+                var csoportNevToCompare = importItem.CsoportNev?.ToComparableString();
+                if (!string.IsNullOrWhiteSpace(csoportNevToCompare) &&
+                    !csoportImportJsonItemList.Select(x => x.OsztalyCsoportNev.ToComparableString()).Contains(csoportNevToCompare) &&
+                    importItem.OperationCsoport == (int)ImportItemOperationEnum.Insert)
+                {
+                    csoportImportJsonItemList.Add(new CsoportImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
+                    osztalyCsoportImportJsonItemList.Add(new OsztalyCsoportImportJsonItemCo(importItem, importItem.OperationCsoport, importItem.CsoportNev, importCo.FeladatellatasiHelyId, feladatKategoriaId, TanevId, IntezmenyId, FelhasznaloId));
+                }
+
+                if (orarendImportFileUploadCo.IsTtfImport)
+                {
+                    if (tantargyfelosztasImportJsonItemList.All(x => x.CompareHash != importItem.CompareHashTantargyfelosztas) &&
+                        (importItem.OperationTantargyfelosztas == (int)ImportItemOperationEnum.Insert
+                            || (importItem.OperationTantargyfelosztas == (int)ImportItemOperationEnum.Update && importCo.OrarendiElemekRogzitesenekElofeltetele == SystemSettingsOrarendiElemekRogzitesenekElofelteteleEnum.NemNullasTTF)
+                        ))
+                    {
+                        List<OrarendImportItemCo> ttfhezTartozoOrarendImportItemCoList = importCo.MainImportItemList.Where(x => x.CompareHashTantargyfelosztas == importItem.CompareHashTantargyfelosztas).ToList();
+                        double oraszam = GetOraszam(importItem, ttfhezTartozoOrarendImportItemCoList, csoportTipusOraPercDict);
+                        tantargyfelosztasImportJsonItemList.Add(
+                            new TantargyfelosztasImportJsonItemCo(
+                                importItem,
+                                importItem.CompareHashTantargyfelosztas,
+                                oraszam,
+                                0,
+                                false,
+                                false,
+                                0, TanevId, IntezmenyId, FelhasznaloId
+                            )
+                            {
+                                Operation = importItem.OperationTantargyfelosztas,
+                            }
+                        );
+                    }
+                }
+
+                if (teremImportJsonItemList.All(x => x.Nev.ToComparableString() != importItem.TeremNev.ToComparableString()) &&
+                    importItem.OperationTerem == (int)ImportItemOperationEnum.Insert)
+                {
+                    teremImportJsonItemList.Add(new TeremImportJsonItemCo(importItem, importCo.MukodesiHelyId, TanevId, IntezmenyId, FelhasznaloId));
+                }
+
+                bool isVegzos = !string.IsNullOrWhiteSpace(osztalyNevToCompare) && vegzosOsztalyCsoportNevComperableList.Contains(osztalyNevToCompare) ||
+                                !string.IsNullOrWhiteSpace(csoportNevToCompare) && vegzosOsztalyCsoportNevComperableList.Contains(csoportNevToCompare);
+                mainImportJsonItemList.Add(new OrarendImportJsonItemCo(importItem, orarendImportFileUploadCo, isVegzos, ConnectionType));
+            }
+
+            importCo.TantargyImportJsonItemList = tantargyImportJsonItemList;
+            importCo.OsztalyCsoportImportJsonItemList = osztalyCsoportImportJsonItemList;
+            importCo.OsztalyImportJsonItemList = osztalyImportJsonItemList;
+            importCo.CsoportImportJsonItemList = csoportImportJsonItemList;
+            importCo.TantargyfelosztasImportJsonItemList = tantargyfelosztasImportJsonItemList;
+            importCo.TeremImportJsonItemList = teremImportJsonItemList;
+            importCo.MainImportJsonItemList = mainImportJsonItemList;
+
+            ImportCo = importCo;
+        }
+
+        private static void SetNemImportalhatoSorokByValidation(OrarendImportCo importCo, bool isAktivTanev)
+        {
+            Dictionary<int, List<ValidationResult>> validationResultDictionary = importCo.Validate(isAktivTanev);
+
+            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
+            foreach (OrarendImportItemCo 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 static void SetOperationTantargyfelosztas(OrarendImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int orarendImportMuvelet, SystemSettingsOrarendiElemekRogzitesenekElofelteteleEnum orarendiElemekRogzitesenekElofeltetele)
+        {
+            var compareHash = importItem.CompareHashTantargyfelosztas;
+            //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
+            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+            {
+                importItem.OperationTantargyfelosztas = (int)ImportItemOperationEnum.Insert;
+            }
+            //NOTE: Ha találtunk egyezést, akkor...
+            else
+            {
+                var importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                //NOTE: ...ha az import művelet DeleteAndInsert és a db-ből jövő adat Importalt(a nem importáltakat egyelőre nem töröljük), akkor Insert, mert töröljük a korábbi elemeket és újra be kell szúrni!
+                if (orarendImportMuvelet == (int)OrarendImportMuveletEnum.DeleteAndInsert && importItemCompareCo.Importalt)
+                {
+                    importItem.OperationTantargyfelosztas = (int)ImportItemOperationEnum.Insert;
+                }
+
+                if ((orarendImportMuvelet == (int)OrarendImportMuveletEnum.UpdateAndInsert
+                     || orarendImportMuvelet == (int)OrarendImportMuveletEnum.Insert)
+                    && orarendiElemekRogzitesenekElofeltetele == SystemSettingsOrarendiElemekRogzitesenekElofelteteleEnum.NemNullasTTF)
+                {
+                    importItem.OperationTantargyfelosztas = (int)ImportItemOperationEnum.Update;
+                    importItem.Id = importItemCompareCo.Id;
+                }
+            }
+        }
+
+        private static void SetOperationTerem(OrarendImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary)
+        {
+            var compareHashTerem = importItem.CompareHashTerem;
+            if (!string.IsNullOrWhiteSpace(compareHashTerem))
+            {
+                //NOTE: Ha nem találtunk egyezést, akkor Insert!
+                if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHashTerem))
+                {
+                    importItem.OperationTerem = (int)ImportItemOperationEnum.Insert;
+                }
+            }
+        }
+
+        private static void SetOperationOrarend(OrarendImportItemCo importItem)
+        {
+            //NOTE: Minden esetben Insert!
+            importItem.Operation = (int)ImportItemOperationEnum.Insert;
+        }
+
+        private Dictionary<string, ImportItemCompareCo> GetTeremCompareHashImportItemCompareCoDictionary()
+        {
+            List<TeremItemCo> coList = new TeremHelper(ConnectionType).GetTeremCoList();
+
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (TeremItemCo co in coList)
+            {
+                string md5HashInput = co.NevComparableString;
+                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 OrarendImportCo GetImportCoFromImportData(OrarendImportFileUploadCo orarendImportFileUploadCo, bool isAktivTanev)
+        {
+            List<AlkalmazottItemCo> tanarCoList = null;
+            List<OsztalyItemCo> osztalyCoList = null;
+            List<CsoportItemCo> csoportCoList = null;
+            List<TeremItemCo> teremCoList = null;
+            List<TanevrendOsztalyokkalNaptipusTulajdonsagokkalCO> tanevRendjeNaptipusTulajdonsagokkalCOs = null;
+            List<string> tantargyNincsBeloleOra = null;
+            List<TantargyfelosztasItemCo> tantargyfelosztasCoList = null;
+            SystemSettingsOrarendiElemekRogzitesenekElofelteteleEnum orarendiElemekRogzitesenekElofeltetele = SystemSettingsOrarendiElemekRogzitesenekElofelteteleEnum.NincsTTF;
+            DataSet hetirendTipusDataSet = null;
+            int foglalkozasokRogziteseHetvegereId = 0;
+            int csengetesiRendId = 0;
+            List<CsengetesiRendOraCO> csengetesiRendOraCoList = null;
+            bool isOravegeBeallitasOrahosszAlapjan = false;
+            Dictionary<int, int?> csoportTipusOraPercDict = null;
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                tanarCoList = new AlkalmazottHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetAlkalmazottCoList();
+                osztalyCoList = new OsztalyHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetOsztalyCoList();
+                csoportCoList = new CsoportHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetCsoportCoList();
+                teremCoList = new TeremHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetTeremCoList();
+                tanevRendjeNaptipusTulajdonsagokkalCOs = new TanevrendHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetTanevRendjeNaptipusTulajdonsagokkal();
+                hetirendTipusDataSet = dalHandler.AdatszotarDAL().GetAdatszotarLathatoElemek(GeneratedAdatszotarTipusEnum.HetiRendTipus, TanevId);
+
+                var systemSettingsHelper = new SystemSettingsHelper(new DalHandlerConnectionType(ConnectionType, dalHandler));
+
+                foglalkozasokRogziteseHetvegereId = (int)systemSettingsHelper.GetSystemSettingValue<FoglalkozasokRogziteseHetvegere>(RendszerBeallitasTipusEnum.Foglalkozasok_Rogzitese_Hetvegere);
+                csengetesiRendId = new CsengetesiRendHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetAktivCsengetesiRendId();
+                csengetesiRendOraCoList = new CsengetesiRendOrakHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetCsengetesiRendOraCoList(csengetesiRendId);
+                isOravegeBeallitasOrahosszAlapjan = systemSettingsHelper.GetSystemSettingValue<bool>(RendszerBeallitasTipusEnum.Orarendi_Elem_Hossz);
+                csoportTipusOraPercDict = new AdatszotarHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetCsoportTipusList().ToDictionary(x => x.Id, x => x.OraPerc);
+                tantargyNincsBeloleOra = new TantargyHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetTantargyakNincsBeloleOra();
+                tantargyfelosztasCoList = new TantargyFelosztasHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetTantargyfelosztasCoList();
+                orarendiElemekRogzitesenekElofeltetele = (SystemSettingsOrarendiElemekRogzitesenekElofelteteleEnum)(systemSettingsHelper.GetSystemSettingValue<int>(RendszerBeallitasTipusEnum.orarendi_elemek_rogzitesenek_elofeltetele));
+            });
+
+            var importCo = new OrarendImportCo
+            {
+                OrarendImportTipus = orarendImportFileUploadCo.OrarendImportTipus,
+                IsNapirendImport = orarendImportFileUploadCo.IsNapirendImport,
+                IsTtfImport = orarendImportFileUploadCo.IsTtfImport,
+                OrarendiOraLezarasDateTime = orarendImportFileUploadCo.OrarendiOraLezarasDateTime,
+                TanarCoList = tanarCoList,
+                OsztalyCoList = osztalyCoList,
+                CsoportCoList = csoportCoList,
+                TanevrendOsztalyokkalNaptipusTulajdonsagokkalCOs = tanevRendjeNaptipusTulajdonsagokkalCOs,
+                TantargyNincsBeloleOra = tantargyNincsBeloleOra,
+                TantargyfelosztasCoList = tantargyfelosztasCoList,
+                OrarendiElemekRogzitesenekElofeltetele = orarendiElemekRogzitesenekElofeltetele,
+                TeremCoList = teremCoList
+            };
+
+            Dictionary<int, string> hetirendTipusDictionary = new Dictionary<int, string>();
+            foreach (DataRow dataRow in hetirendTipusDataSet.Tables[0].Rows)
+            {
+                hetirendTipusDictionary.Add(SDAConvert.ToInt32(dataRow["ID"]), SDAConvert.ToString(dataRow["Megnevezes"]));
+            }
+
+            int lineNumber = 1;
+            foreach (List<string> importDataRow in orarendImportFileUploadCo.ImportData.Skip(1))
+            {
+                Dictionary<int, string> importHeaderList = !orarendImportFileUploadCo.IsNapirendImport ? ImportHeaderListOraErvenyessegiIdovel : ImportHeaderListNapirendOraErvenyessegiIdovel;
+                var importItemCo = new OrarendImportItemCo(TanevId, isAktivTanev)
+                {
+                    LineNumber = lineNumber,
+
+                    OraErvenyessegKezdeteImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOraErvenyessegKezdete)],
+                    OraErvenyessegVegeImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOraErvenyessegVege)],
+                    HetirendImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameHetirend)],
+                    NapImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameNap)],
+                    OsztalyNevImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly)],
+                    CsoportNevImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport)],
+                    TantargyNevImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy)],
+                    TanarNevImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTanar)],
+                    HelyisegImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameHelyiseg)],
+
+                    OraErvenyessegMinDate = orarendImportFileUploadCo.OraErvenyessegMinDate,
+                    OraErvenyessegMaxDate = orarendImportFileUploadCo.OraErvenyessegMaxDate,
+                    HetirendTipusDictionary = hetirendTipusDictionary,
+
+                    IsNapirendImport = orarendImportFileUploadCo.IsNapirendImport,
+                    FoglalkozasokRogziteseHetvegereId = foglalkozasokRogziteseHetvegereId
+                };
+
+                var osztalyCsoportId =
+                    importCo.OsztalyCoList.FirstOrDefault(x => x.NevComparableString == importItemCo.OsztalyCsoportNev.ToComparableString())?.Id ??
+                    importCo.CsoportCoList.FirstOrDefault(x => x.NevComparableString == importItemCo.OsztalyCsoportNev.ToComparableString())?.Id;
+                ChangeFoglalkozasokRogziteseHetvegere(importCo, importItemCo, osztalyCsoportId);
+
+                if (!string.IsNullOrWhiteSpace(importItemCo.TanarNev))
+                {
+                    var tanarList = tanarCoList.Where(x =>
+                        x.FelhasznaloNyomtatasiNevComparableString == importItemCo.TanarNev?.ToComparableString() &&
+                        (!importItemCo.TanarSzuletesiIdo.HasValue || importItemCo.TanarSzuletesiIdo == x.FelhasznaloSzuletesiIdo)).ToList();
+                    if (tanarList.Count == 1)
+                    {
+                        importItemCo.TanarId = tanarList.Single().Id;
+                    }
+                }
+
+                importItemCo.HetirendTipusId = importItemCo.HetirendTipusDictionary.SingleOrDefault(x => x.Value == importItemCo.HetirendTipusNev).Key;
+                if (!importItemCo.IsNapirendImport)
+                {
+                    importItemCo.OraImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOra)];
+
+                    importItemCo.CsengetesiRendId = csengetesiRendId;
+                    importItemCo.CsengetesiRendOraCoList = csengetesiRendOraCoList;
+                    importItemCo.CsengetesiRendOraId = csengetesiRendOraCoList.SingleOrDefault(x => x.Oraszam == importItemCo.OraSorszam)?.ID;
+                }
+                else
+                {
+                    importItemCo.FoglalkozasKezdeteImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameFoglalkozasKezdete)];
+                    importItemCo.FoglalkozasVegeImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameFoglalkozasVege)];
+
+                    importItemCo.CsengetesiRendId = null;
+                    importItemCo.CsengetesiRendOraCoList = null;
+                    importItemCo.CsengetesiRendOraId = null;
+                }
+
+                var csoportCo = importCo.CsoportCoList.SingleOrDefault(x => x.NevComparableString == importItemCo.CsoportNev.ToComparableString());
+
+                if (csoportCo != null)
+                {
+                    importItemCo.CsoportTipusId = csoportCo.TipusId ?? (int)CsoportTipusEnum.iskolai_csoport_tanorai_celu_;
+                }
+                else
+                {
+                    importItemCo.CsoportTipusId = orarendImportFileUploadCo.IsOsszefuggoSzakmaiGyakorlat ? (int)CsoportTipusEnum.OsszefuggoSzakmaiGyakorlatiCsoport : (int)CsoportTipusEnum.na;
+                }
+
+                // NOTE: Órarendi óra esetén, rendszerbeállítástól függ az óra végének meghatározása.
+                // NOTE: Ha 'IGEN', órahossz alapján kell, amit a csoport típusa határoz meg.
+                if (importItemCo.OraSorszam == null)
+                {
+                    importItemCo.OraVege = BaseImportItemCo.GetDateTimeValueFromTimeString(importItemCo.FoglalkozasVegeImportData);
+                }
+                else
+                {
+                    if (!importItemCo.IsCsoport || !isOravegeBeallitasOrahosszAlapjan)
+                    {
+                        importItemCo.OraVege = importItemCo.CsengetesiRendOraCoList.SingleOrDefault(x => x.Oraszam == importItemCo.OraSorszam)?.Veg;
+                    }
+                    else
+                    {
+                        // NOTE: Létező csoport esetén kikeressük, milyen csoport típus tartozik hozzá.
+                        if (csoportTipusOraPercDict.TryGetValue(importItemCo.CsoportTipusId.Value, out int? csoportTipusOraPerc) && csoportTipusOraPerc.HasValue)
+                        {
+                            importItemCo.OraVege = importItemCo.OraKezdete?.AddMinutes(csoportTipusOraPerc.Value);
+                        }
+                    }
+                }
+
+                string tantargyMd5HashInput = importItemCo.TantargyNev?.ToComparableString();
+                importItemCo.CompareHashTantargy = ImportExportHelper.GetMd5Hash(tantargyMd5HashInput);
+
+                if (!string.IsNullOrWhiteSpace(importItemCo.OsztalyNev))
+                {
+                    string osztalyMd5HashInput = importItemCo.OsztalyNev.ToComparableString();
+                    importItemCo.CompareHashOsztaly = ImportExportHelper.GetMd5Hash(osztalyMd5HashInput);
+                }
+
+                if (!string.IsNullOrWhiteSpace(importItemCo.CsoportNev))
+                {
+                    string csoportMd5HashInput = importItemCo.CsoportNev.ToComparableString();
+                    importItemCo.CompareHashCsoport = ImportExportHelper.GetMd5Hash(csoportMd5HashInput);
+                }
+
+                string tantargyfelosztasMd5HashInput =
+                    importItemCo.OsztalyCsoportNev?.ToComparableString() +
+                    importItemCo.TantargyNev?.ToComparableString() +
+                    importItemCo.TanarNev?.ToComparableString();
+                if (importItemCo.TanarSzuletesiIdo.HasValue)
+                {
+                    tantargyfelosztasMd5HashInput += importItemCo.TanarSzuletesiIdoString?.ToComparableString();
+                }
+
+                importItemCo.CompareHashTantargyfelosztas = ImportExportHelper.GetMd5Hash(tantargyfelosztasMd5HashInput);
+
+                if (!string.IsNullOrWhiteSpace(importItemCo.TeremNev))
+                {
+                    string teremMd5HashInput = importItemCo.TeremNev.ToComparableString();
+                    importItemCo.CompareHashTerem = ImportExportHelper.GetMd5Hash(teremMd5HashInput);
+                }
+
+                string orarendMd5HashInput = string.Empty;
+                if (importCo.OrarendImportTipus == (int)OrarendImportTipusEnum.ErvenyessegiIdovelImport)
+                {
+                    orarendMd5HashInput += importItemCo.OraErvenyessegKezdeteString?.ToComparableString();
+                    orarendMd5HashInput += importItemCo.OraErvenyessegVegeString?.ToComparableString();
+                }
+
+                orarendMd5HashInput += importItemCo.HetirendTipusNev?.ToComparableString();
+                orarendMd5HashInput += importItemCo.HetNapjaTipusId?.GetDisplayName<HetNapjaTipusEnum>(TanevId)?.ToComparableString();
+                if (!importItemCo.IsNapirendImport)
+                {
+                    orarendMd5HashInput += importItemCo.OraSorszam;
+                }
+                else
+                {
+                    orarendMd5HashInput += importItemCo.OraKezdeteString?.ToComparableString();
+                    orarendMd5HashInput += importItemCo.OraVegeString?.ToComparableString();
+                }
+
+                orarendMd5HashInput += importItemCo.OsztalyCsoportNev?.ToComparableString();
+                orarendMd5HashInput += importItemCo.TantargyNev?.ToComparableString();
+                orarendMd5HashInput += importItemCo.TanarNev?.ToComparableString();
+                if (importItemCo.TanarSzuletesiIdo.HasValue)
+                {
+                    orarendMd5HashInput += importItemCo.TanarSzuletesiIdoString?.ToComparableString();
+                }
+
+                orarendMd5HashInput += importItemCo.TeremNev?.ToComparableString();
+
+                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(orarendMd5HashInput);
+
+                importCo.MainImportItemList.Add(importItemCo);
+
+                lineNumber++;
+            }
+
+            return importCo;
+        }
+
+        public MemoryStream GetTemplate(OrarendImportFileUploadCo orarendImportFileUploadCo, bool isSzakkepzo = false, int? szervezetTipus = null, int? szervezetId = null)
+        {
+            Dictionary<string, IList<string>> dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary(true, isSzakkepzo, szervezetTipus, szervezetId);
+            MemoryStream memoryStream = ImportExportHelper.GetTemplate(orarendImportFileUploadCo.WorksheetName, orarendImportFileUploadCo.ExcelHeaderList, dropDownColumnSourceDictionary);
+            return memoryStream;
+        }
+
+        public MemoryStream GetExport(OrarendImportFileUploadCo orarendImportFileUploadCo, DateTime orarendExportKezdete, DateTime orarendExportVege, bool isIdoszakonKivuliElemekMegjelenitese, bool isEgyediNapOrainakKihagyasa)
+        {
+            bool isOraErvenyessegiIdovel = orarendImportFileUploadCo.OrarendImportTipus == (int)OrarendImportTipusEnum.ErvenyessegiIdovelImport;
+            DataSet dataSet = Dal.CustomConnection.Run(ConnectionType, dalHandler => dalHandler.ImportExportDal().GetOrarendExcelExportData(TanevId, orarendExportKezdete, orarendExportVege, isOraErvenyessegiIdovel, isIdoszakonKivuliElemekMegjelenitese, isEgyediNapOrainakKihagyasa, orarendImportFileUploadCo.IsNapirendImport));
+
+            return GetWorkbook(orarendImportFileUploadCo, dataSet);
+        }
+
+        public MemoryStream GetWorkbook(OrarendImportFileUploadCo orarendImportFileUploadCo, DataSet dataSet)
+        {
+            Dictionary<string, IList<string>> dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary(false);
+            bool isOraErvenyessegiIdovel = orarendImportFileUploadCo.OrarendImportTipus == (int)OrarendImportTipusEnum.ErvenyessegiIdovelImport;
+
+            using (var workbook = new Workbook())
+            {
+                List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos(orarendImportFileUploadCo.ExcelHeaderList, dropDownColumnSourceDictionary);
+                var worksheet = SimpleExportLogic.GetWorksheet(workbook, orarendImportFileUploadCo.WorksheetName, simpleExportColumnCos);
+
+                int rowNumber = 1;
+                foreach (DataRow dataRow in dataSet.Tables[0].AsEnumerable())
+                {
+                    if (isOraErvenyessegiIdovel)
+                    {
+                        var oraErvenyessegKezdete = SDAConvert.ToDateTime(dataRow["OraErvenyessegKezdete"]).Value;
+                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOraErvenyessegKezdete)].Value = oraErvenyessegKezdete.ToString(Constants.ToStringPattern.HungarianDate);
+                        var oraErvenyessegVege = SDAConvert.ToDateTime(dataRow["OraErvenyessegVege"]);
+                        //NOTE: Az OraErvenyessegVege 00:00-t tartalmaz, de aznap napközben még lehet óra, ezért a következő nap 00:00 időpont a jó és azt mentjük a db-be!
+                        DateTime? oraErvenyessegVegeDatum = oraErvenyessegKezdete.Equals(oraErvenyessegVege) ? oraErvenyessegVege : oraErvenyessegVege?.AddDays(-1);
+                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOraErvenyessegVege)].Value = oraErvenyessegVegeDatum?.ToString(Constants.ToStringPattern.HungarianDate) ?? string.Empty;
+                    }
+
+                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameHetirend)].Value = SDAConvert.ToString(dataRow["Hetirend"]) ?? string.Empty;
+                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameNap)].Value = SDAConvert.ToString(dataRow["Nap"]) ?? string.Empty;
+                    if (orarendImportFileUploadCo.IsNapirendImport)
+                    {
+                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameFoglalkozasKezdete)].Value = SDAConvert.ToDateTime(dataRow["FoglalkozasKezdete"]).Value.ToString(Constants.ToStringPattern.HungarianTime);
+                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameFoglalkozasVege)].Value = SDAConvert.ToDateTime(dataRow["FoglalkozasVege"]).Value.ToString(Constants.ToStringPattern.HungarianTime);
+                    }
+                    else
+                    {
+                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOra)].Value = SDAConvert.ToNullableInt32(dataRow["Ora"])?.ToString() ?? string.Empty;
+                    }
+
+                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly)].Value = SDAConvert.ToString(dataRow["Osztaly"]) ?? string.Empty;
+                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport)].Value = SDAConvert.ToString(dataRow["Csoport"]) ?? string.Empty;
+                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy)].Value = SDAConvert.ToString(dataRow["Tantargy"]) ?? string.Empty;
+                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTanar)].Value = SDAConvert.ToString(dataRow["Tanar"]) ?? string.Empty;
+                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameHelyiseg)].Value = SDAConvert.ToString(dataRow["Helyiseg"]) ?? string.Empty;
+
+                    rowNumber++;
+                }
+
+                MemoryStream memoryStream = SimpleExportLogic.GetWorkbookMemoryStream(workbook);
+                return memoryStream;
+            }
+        }
+
+        public MemoryStream GetNemImportalhatoSorokExport(OrarendImportFileUploadCo orarendImportFileUploadCo)
+        {
+            Dictionary<string, IList<string>> dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary(false);
+            using (var workbook = new Workbook())
+            {
+                var worksheet = ImportExportHelper.GetWorksheetsWithDropDownFormula(workbook, orarendImportFileUploadCo.WorksheetName, orarendImportFileUploadCo.ExcelHeaderList, dropDownColumnSourceDictionary);
+
+                int rowNumber = 1;
+                foreach (OrarendImportItemCo co in ImportCo.NemImportalhatoItemList)
+                {
+                    if (orarendImportFileUploadCo.OrarendImportTipus == (int)OrarendImportTipusEnum.ErvenyessegiIdovelImport)
+                    {
+                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOraErvenyessegKezdete)].Value = co.OraErvenyessegKezdeteImportData;
+                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOraErvenyessegVege)].Value = co.OraErvenyessegVegeImportData;
+                    }
+
+                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameHetirend)].Value = co.HetirendImportData;
+                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameNap)].Value = co.NapImportData;
+                    if (orarendImportFileUploadCo.IsNapirendImport)
+                    {
+                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameFoglalkozasKezdete)].Value = co.FoglalkozasKezdeteImportData;
+                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameFoglalkozasVege)].Value = co.FoglalkozasVegeImportData;
+                    }
+                    else
+                    {
+                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOra)].Value = co.OraImportData;
+                    }
+
+                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly)].Value = co.OsztalyNevImportData;
+                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport)].Value = co.CsoportNevImportData;
+                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy)].Value = co.TantargyNevImportData;
+                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTanar)].Value = co.TanarNevImportData;
+                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameHelyiseg)].Value = co.HelyisegImportData;
+
+                    Cell errorCell = worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.Count];
+                    errorCell.Value = string.Join(Environment.NewLine, co.ErrorList);
+                    errorCell.SetTextWrap();
+
+                    rowNumber++;
+                }
+
+                var sheetCodeNameAndColumnsToWrapIndexDictionary = new Dictionary<string, List<int>>
+                {
+                    { workbook.Worksheets[0].CodeName, new List<int> { ImportHeaderList.Count } }
+                };
+                MemoryStream memoryStream = SimpleExportLogic.GetWorkbookMemoryStream(workbook, sheetCodeNameAndColumnsToWrapIndexDictionary);
+                return memoryStream;
+            }
+        }
+
+        public void Import(object importJsonObject, int orarendImportMuvelet, bool isNapirendImport, DateTime? orarendiOraLezarasDateTime)
+        {
+            string importJson = JsonConvert.SerializeObject(importJsonObject);
+            bool isTorles = orarendImportMuvelet == (int)OrarendImportMuveletEnum.DeleteAndInsert;
+            bool isModositas = orarendImportMuvelet == (int)OrarendImportMuveletEnum.UpdateAndInsert;
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                dalHandler.ImportExportDal().OrarendImport(IntezmenyId, TanevId, FelhasznaloId, importJson, isTorles, isModositas, isNapirendImport, orarendiOraLezarasDateTime);
+                dalHandler.OrarendiOra().UpdateOrarend(IntezmenyId, TanevId, null, null, null, null);
+            });
+        }
+
+        private void ChangeFoglalkozasokRogziteseHetvegere(OrarendImportCo importCo, OrarendImportItemCo importItemCo, int? osztalyCsoportId)
+        {
+            if (importItemCo.IsEgyediNap)
+            {
+                var aktualisTanevRendje = importCo.TanevrendOsztalyokkalNaptipusTulajdonsagokkalCOs.Where(tr =>
+                    // globális tanévrendi esemény
+                    !tr.OsztalyCsoportId.IsEntityId()
+                    // osztályra vonatkozó tanévrendi esemény
+                    || (tr.OsztalyCsoportId.IsEntityId() && tr.OsztalyCsoportId == osztalyCsoportId)).ToList();
+
+                var napraTanitasiOratTanoranKivulitLehetRogziteni = aktualisTanevRendje.Where(tr => (tr.Datum == importItemCo.OraErvenyessegKezdete) && (tr.IsTanitasi || tr.IsTanoranKivuli)).ToList();
+                if (napraTanitasiOratTanoranKivulitLehetRogziteni.Any())
+                {
+                    // ha az osztálynak van olyan tanévrendi eseménye az adott napra, ahol lehet rögzíteni tanítási órát vagy tanórán kívüli foglalkozást, akkor
+                    if (napraTanitasiOratTanoranKivulitLehetRogziteni.Any(x => !x.Globalis && !x.OrarendiNap))
+                    {
+                        //ha van benne az osztályra szabott tiltás
+                        return;
+                    }
+
+                    if (napraTanitasiOratTanoranKivulitLehetRogziteni.Any(x => !x.Globalis && x.OrarendiNap))
+                    {
+                        //ha van benne az osztályra szabott engedélyezés, akkor nem érdekes a rendszerbeállítás
+                        importItemCo.FoglalkozasokRogziteseHetvegereId = (int)FoglalkozasokRogziteseHetvegere.Engedelyezett;
+                        return;
+                    }
+
+                    if (napraTanitasiOratTanoranKivulitLehetRogziteni.Any(x => x.Globalis && !x.OrarendiNap))
+                    {
+                        //ha van benne globalis tiltás
+                        return;
+                    }
+
+                    if (napraTanitasiOratTanoranKivulitLehetRogziteni.Any(x => x.Globalis && x.OrarendiNap))
+                    {
+                        //ha van benne globalis engedélyezés, akkor nem érdekes a rendszerbeállítás
+                        importItemCo.FoglalkozasokRogziteseHetvegereId = (int)FoglalkozasokRogziteseHetvegere.Engedelyezett;
+                    }
+                }
+            }
+        }
+
+        private double GetOraszam(OrarendImportItemCo importItem, List<OrarendImportItemCo> orarendImportItemCoList, Dictionary<int, int?> csoportTipusOraPercDict)
+        {
+            int orahosszPerc = 45;
+
+            if (importItem.IsCsoport)
+            {
+                if (csoportTipusOraPercDict.TryGetValue(importItem.CsoportTipusId.Value, out int? csoportTipusOraPerc) && csoportTipusOraPerc.HasValue)
+                {
+                    orahosszPerc = csoportTipusOraPerc.Value;
+                }
+            }
+            else
+            {
+                var ds = new OsztalyCsoportHelper(ConnectionType).GetOsztalyCsoportNev(importItem.OsztalyNev, null);
+
+                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0 && ds.Tables[0].Rows[0].Field<int>("KategoriaId") == (int)OktNevelesiKategoriaEnum.Kollegium)
+                {
+                    orahosszPerc = 60;
+                }
+                else
+                {
+                    orahosszPerc = 45;
+                }
+            }
+
+            double idotartam = 0;
+            double hetirendOszto = importItem.HetirendTipusDictionary.Count(x => x.Key != (int)HetiRendTipusEnum.MindegyikHet);
+            double oraszamHetiAtlag = 1;
+
+            if (hetirendOszto != 0)
+            {
+                oraszamHetiAtlag = 1 / hetirendOszto;
+            }
+
+            foreach (OrarendImportItemCo orarendImportItemCo in orarendImportItemCoList)
+            {
+                if (orarendImportItemCo.HetirendTipusId == (int)HetiRendTipusEnum.MindegyikHet)
+                {
+                    idotartam += orarendImportItemCo.CsengetesiRendId.HasValue ? orahosszPerc : orarendImportItemCo.OraVege.Value.Subtract(orarendImportItemCo.OraKezdete.Value).TotalMinutes;
+                }
+                else
+                {
+                    idotartam += oraszamHetiAtlag * (orarendImportItemCo.CsengetesiRendId.HasValue ? orahosszPerc : orarendImportItemCo.OraVege.Value.Subtract(orarendImportItemCo.OraKezdete.Value).TotalMinutes);
+                }
+            }
+
+            double result = Math.Round(idotartam / orahosszPerc, 2);
+            return result;
+        }
+
+        public Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary(bool filterBySzervezetTipus, bool isSzakkepzo = false, int ? szervezetTipus = null, int? szervezetId = null)
+        {
+            //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(ImportExportOrarendResource.ImportHeaderNameHetirend, helper.GetHetiRendTipusList());
+                dropDownColumnSourceDictionary.Add(ImportExportOrarendResource.ImportHeaderNameNap, helper.GetHetNapjaTipusList());
+                dropDownColumnSourceDictionary.Add(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly, helper.GetOsztalyList());
+                dropDownColumnSourceDictionary.Add(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport, !filterBySzervezetTipus ? helper.GetCsoportList() : helper.GetCsoportListBySzervezet(szervezetTipus, szervezetId));
+                dropDownColumnSourceDictionary.Add(ImportExportTantargyfelosztasResource.ImportHeaderNameTanar, !filterBySzervezetTipus ? helper.GetTanarList(true) : helper.GetTanarListBySzervezet(true, szervezetTipus, szervezetId));
+                dropDownColumnSourceDictionary.Add(ImportExportOrarendResource.ImportHeaderNameHelyiseg, !filterBySzervezetTipus ? helper.GetTeremList() : helper.GetTeremListBySzervezet(szervezetTipus, szervezetId));
+                dropDownColumnSourceDictionary.Add(ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy, !filterBySzervezetTipus ? helper.GetTantargyList() : helper.GetTantargyListBySzervezet(szervezetId == null ? false : true, isSzakkepzo));
+            });
+
+            return dropDownColumnSourceDictionary;
+        }
+    }
+}

Kreta.BusinessLogic/Helpers/ImportExport/OratervImportExportHelper.cs

@@ -0,0 +1,384 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Data;
+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 OratervImportExportHelper : LogicBase
+    {
+        #region Fields
+
+        private readonly string _importObjectCacheKey;
+
+        #endregion Fields
+
+        #region Properties
+
+        public static Dictionary<int, string> ImportHeaderList => new Dictionary<int, string>
+        {
+            { 00, ImportExportOratervResource.ImportHeaderNameTantervNeve },
+            { 01, ImportExportOratervResource.ImportHeaderNameOratervNeve },
+            { 02, ImportExportOratervResource.ImportHeaderNameEvfolyamNeve },
+            { 03, ImportExportOratervResource.ImportHeaderNameTantargyNeve },
+            { 04, ImportExportOratervResource.ImportHeaderNameEvesOraszam }
+        };
+
+        public OratervImportCo ImportCo
+        {
+            get => (OratervImportCo)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 OratervImportExportHelper(IConnectionType connectionType) : base(connectionType)
+        {
+            _importObjectCacheKey = $"{nameof(OratervImportCo)}_{IntezmenyId}_{FelhasznaloId}_ImportObjectCacheKey";
+        }
+
+        #endregion Constructors
+
+        public void SetImportCo(List<List<string>> importData, int importMuvelet)
+        {
+            OratervImportCo importCo = GetImportCoFromImportData(importData);
+            importCo.ImportMuvelet = importMuvelet;
+
+            SetNemImportalhatoSorokByValidation(importCo);
+
+            //NOTE: Azért van szükség Dictionary-kre, mert így sokkal gyorsabb a keresés!
+            Dictionary<string, ImportItemCompareCo> tantargyCompareHashImportItemCompareCoDictionary = GetTantargyCompareHashImportItemCompareCoDictionary(importCo.TantargyCOList);
+            Dictionary<string, ImportItemCompareCo> oratervCompareHashImportItemCompareCoDictionary = GetOratervCompareHashImportItemCompareCoDictionary(importCo.OratervCOList);
+            Dictionary<string, ImportItemCompareCo> oratervTantargyCompareHashImportItemCompareCoDictionary = GetOratervTantargyCompareHashImportItemCompareCoDictionary(importCo.OratervTantargyCOList);
+
+            foreach (OratervImportItemCo importItem in importCo.MainImportItemList)
+            {
+                SetOperationTantargy(importItem, tantargyCompareHashImportItemCompareCoDictionary);
+                SetOperationOraterv(importItem, oratervCompareHashImportItemCompareCoDictionary, importCo.ImportMuvelet);
+                SetOperationOratervTantargy(importItem, oratervTantargyCompareHashImportItemCompareCoDictionary, importCo.ImportMuvelet);
+            }
+
+            //NOTE: Azokat a sorokat, amelyek bekerültek a NemImportalhatoItemList-be, azokat kiveszzük a MainImportItemList-ből!
+            importCo.MainImportItemList.RemoveRange(importCo.NemImportalhatoItemList);
+
+            var tantargyImportJsonItemList = new List<TantargyImportJsonItemCo>();
+            var oratervImportJsonItemList = new List<OratervImportJsonItemCo>();
+            var oratervTantargyJsonItemList = new List<OratervTargyImportJsonItemCo>();
+
+            var tantargyImportJsonItemCoList = importCo.MainImportItemList.GroupBy(x => x.TantargyNeve).Select(x => x.First()).Select(x => new TantargyImportJsonItemCo(x, TanevId, IntezmenyId, FelhasznaloId)).ToList();
+            var oratervImportJsonItemCoList = importCo.MainImportItemList.GroupBy(x => x.OratervNeve).Select(x => x.First()).Select(x => new OratervImportJsonItemCo(x, TanevId, IntezmenyId, FelhasznaloId)).ToList();
+            var oratervTantargyImportJsonItemCoList = importCo.MainImportItemList.Select(x => new OratervTargyImportJsonItemCo(x, TanevId, IntezmenyId, FelhasznaloId)).ToList();
+            tantargyImportJsonItemList.AddRange(tantargyImportJsonItemCoList);
+            oratervImportJsonItemList.AddRange(oratervImportJsonItemCoList);
+            oratervTantargyJsonItemList.AddRange(oratervTantargyImportJsonItemCoList);
+
+            importCo.TantargyImportJsonItemList = tantargyImportJsonItemList;
+            importCo.OratervImportJsonItemList = oratervImportJsonItemList;
+            importCo.OratervTantargyImportJsonItemList = oratervTantargyJsonItemList;
+
+            ImportCo = importCo;
+        }
+
+        private static void SetNemImportalhatoSorokByValidation(OratervImportCo importCo)
+        {
+            Dictionary<int, List<ValidationResult>> validationResultDictionary = importCo.Validate();
+
+            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
+            foreach (OratervImportItemCo 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 OratervImportCo GetImportCoFromImportData(List<List<string>> importData)
+        {
+            List<TantervCO> tantervCoList = null;
+            List<TantargyItemCo> tantargyCoList = null;
+            List<OratervCO> oratervCoList = null;
+            List<OratervTantargyCO> oratervTantargyCoList = null;
+
+            Dal.CustomConnection.Run(ConnectionType, h =>
+            {
+                tantervCoList = new TantervHelper(new DalHandlerConnectionType(ConnectionType, h)).GetAktivTantervDataSet().Tables[0].AsEnumerable().Select(row => new TantervCO()
+                {
+                    ID = SDAConvert.ToInt32(row["ID"]),
+                    Nev = SDAConvert.ToString(row["Nev"]),
+                }).ToList();
+                tantargyCoList = new TantargyHelper(new DalHandlerConnectionType(ConnectionType, h)).GetTantargyCoList();
+                var oratervHelper = new OratervHelper(new DalHandlerConnectionType(ConnectionType, h));
+                oratervCoList = oratervHelper.GetOratervCoList();
+                oratervTantargyCoList = oratervHelper.GetOratervTantargyCoList();
+            });
+
+            var importCo = new OratervImportCo
+            {
+                TantervCOList = tantervCoList,
+                TantargyCOList = tantargyCoList,
+                OratervCOList = oratervCoList,
+                OratervTantargyCOList = oratervTantargyCoList,
+            };
+
+            int lineNumber = 1;
+            foreach (List<string> importDataRow in importData.Skip(1))
+            {
+                var importItemCo = new OratervImportItemCo(TanevId)
+                {
+                    LineNumber = lineNumber,
+
+                    TantervNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportOratervResource.ImportHeaderNameTantervNeve)],
+                    OratervNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportOratervResource.ImportHeaderNameOratervNeve)],
+                    EvfolyamNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportOratervResource.ImportHeaderNameEvfolyamNeve)],
+                    TantargyNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportOratervResource.ImportHeaderNameTantargyNeve)],
+                    EvesOraszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportOratervResource.ImportHeaderNameEvesOraszam)],
+                };
+
+                importItemCo.TantervId = importCo.TantervCOList.SingleOrDefault(x =>
+                    x.Nev?.ToComparableString() == importItemCo.TantervNeve?.ToComparableString())?.ID;
+
+                importItemCo.TantargyId = importCo.TantargyCOList.SingleOrDefault(x => x.Nev?.ToComparableString() == importItemCo.TantargyNeve?.ToComparableString())?.Id;
+
+                importItemCo.OratervId = importCo.OratervCOList.SingleOrDefault(x => x.Nev?.ToComparableString() == importItemCo.OratervNeve?.ToComparableString())?.OratervId;
+
+                string lineMd5HashInput =
+                    importItemCo.OratervId +
+                    importItemCo.OratervNeve?.ToComparableString() +
+                    importItemCo.TantargyId +
+                    importItemCo.TantargyNeve?.ToComparableString();
+                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(lineMd5HashInput);
+
+                string tantargyMd5HashInput =
+                    importItemCo.TantargyId +
+                    importItemCo.TantargyNeve?.ToComparableString();
+                importItemCo.CompareHashTantargy = ImportExportHelper.GetMd5Hash(tantargyMd5HashInput);
+
+                string oratervMd5HashInput =
+                    importItemCo.OratervId +
+                    importItemCo.OratervNeve?.ToComparableString();
+                importItemCo.CompareHashOraterv = ImportExportHelper.GetMd5Hash(oratervMd5HashInput);
+
+                importCo.MainImportItemList.Add(importItemCo);
+
+                lineNumber++;
+            }
+
+            return importCo;
+        }
+
+        #region Template
+
+        public MemoryStream GetTemplate()
+        {
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<OratervTantargyCO>(OratervTantargyCO.OratervTantargyExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
+            return SimpleExportLogic.GetTemplate(ImportExportOratervResource.ImportDefaultSheetName, simpleExportColumnCos);
+        }
+
+        #endregion Template
+
+        #region Export
+
+        public MemoryStream GetExport()
+        {
+            List<OratervTantargyCO> coList = new OratervHelper(ConnectionType).GetOratervTantargyCoList().OrderBy(x => x.TantervNev).ThenBy(x => x.OratervNev).ThenBy(x => x.TantargyNev).ToList();
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<OratervTantargyCO>(OratervTantargyCO.OratervTantargyExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
+            return SimpleExportLogic.GetExport(ImportExportOratervResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        public MemoryStream GetNemImportalhatoSorokExport()
+        {
+            List<OratervImportItemCo> coList = ImportCo.NemImportalhatoItemList;
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<OratervImportItemCo>(OratervImportItemCo.NemImportalhatoSorokExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
+            return ImportExportHelper.NemImportalhatoSorokExport(ImportExportOratervResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        #endregion Export
+
+        private Dictionary<string, ImportItemCompareCo> GetTantargyCompareHashImportItemCompareCoDictionary(List<TantargyItemCo> tantargyItemCoList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (TantargyItemCo tantargyItemCo in tantargyItemCoList)
+            {
+                var md5HashInput =
+                    tantargyItemCo.Id +
+                    tantargyItemCo.Nev?.ToComparableString();
+                string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                var importItemCompareCo = new ImportItemCompareCo
+                {
+                    Id = tantargyItemCo.Id,
+                    CompareHash = compareHash
+                };
+                //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;
+        }
+
+        private Dictionary<string, ImportItemCompareCo> GetOratervTantargyCompareHashImportItemCompareCoDictionary(List<OratervTantargyCO> oratervTantargyCoList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (OratervTantargyCO oratervTantargyItemCo in oratervTantargyCoList)
+            {
+                var md5HashInput =
+                    oratervTantargyItemCo.OratervId +
+                    oratervTantargyItemCo.OratervNev?.ToComparableString() +
+                    oratervTantargyItemCo.Tantargy +
+                    oratervTantargyItemCo.TantargyNev?.ToComparableString();
+                string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                var importItemCompareCo = new ImportItemCompareCo
+                {
+                    Id = oratervTantargyItemCo.OratervTantargyId,
+                    CompareHash = compareHash
+                };
+                //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;
+        }
+
+        private Dictionary<string, ImportItemCompareCo> GetOratervCompareHashImportItemCompareCoDictionary(List<OratervCO> oratervCoList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (OratervCO oratervItemCo in oratervCoList)
+            {
+                var md5HashInput =
+                    oratervItemCo.OratervId +
+                    oratervItemCo.Nev?.ToComparableString();
+                string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                var importItemCompareCo = new ImportItemCompareCo
+                {
+                    Id = oratervItemCo.OratervId,
+                    CompareHash = compareHash
+                };
+                //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;
+        }
+
+        private static void SetOperationTantargy(OratervImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary)
+        {
+            var compareHash = importItem.CompareHashTantargy;
+            //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
+            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+            {
+                importItem.OperationTantargy = (int)ImportItemOperationEnum.Insert;
+            }
+        }
+
+        private static void SetOperationOratervTantargy(OratervImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int importMuvelet)
+        {
+            var 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...
+            else
+            {
+                ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
+                if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                {
+                    importItem.OratervTantargyId = importItemCompareCo.Id;
+                    importItem.Operation = (int)ImportItemOperationEnum.Update;
+                }
+            }
+        }
+
+        private static void SetOperationOraterv(OratervImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int importMuvelet)
+        {
+            var compareHash = importItem.CompareHashOraterv;
+            //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
+            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+            {
+                importItem.OperationOraterv = (int)ImportItemOperationEnum.Insert;
+            }
+            //NOTE: Ha találtunk egyezést, akkor...
+            else
+            {
+                ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
+                if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                {
+                    importItem.OratervId = importItemCompareCo.Id;
+                    importItem.OperationOraterv = (int)ImportItemOperationEnum.Update;
+                }
+                else
+                {
+                    importItem.OratervId = null;
+                }
+            }
+        }
+
+        public void Import(object importJsonObject)
+        {
+            string importJson = JsonConvert.SerializeObject(importJsonObject);
+            Dal.CustomConnection.Run(ConnectionType, dalHandler => dalHandler.ImportExportDal().OratervImport(IntezmenyId, TanevId, FelhasznaloId, importJson));
+        }
+
+        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary()
+        {
+            //NOTE: Create dropdown lists
+            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>();
+
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                var connectionType = new DalHandlerConnectionType(ConnectionType, dalHandler);
+
+                dropDownColumnSourceDictionary.Add(ImportExportOratervResource.ImportHeaderNameEvfolyamNeve, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.EvfolyamTipus));
+
+                var tantervHelper = new TantervHelper(connectionType);
+                var tantargyHelper = new TantargyHelper(connectionType);
+                dropDownColumnSourceDictionary.Add(ImportExportOratervResource.ImportHeaderNameTantervNeve, tantervHelper.GetAktivTantervDataSet().Tables[0].AsEnumerable().Select(t => t.Field<string>("Nev")).ToList());
+                dropDownColumnSourceDictionary.Add(ImportExportOratervResource.ImportHeaderNameTantargyNeve, tantargyHelper.GetTantargyCoList(true).OrderBy(x => x.Rendez0).ThenBy(x => x.Rendez1).ThenBy(x => x.Rendez2).ThenBy(x => x.Rendez3).ThenBy(x => x.Rendez4).ThenBy(x => x.Rendez5).Select(t => t.Nev).ToList());
+            });
+
+            return dropDownColumnSourceDictionary;
+        }
+    }
+}

Kreta.BusinessLogic/Helpers/ImportExport/TanmenetImportExportHelper.cs

@@ -0,0 +1,201 @@
+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.Enums.ManualEnums;
+using Kreta.Enums.ManualEnums.ImportExport;
+using Kreta.Resources;
+using Newtonsoft.Json;
+
+namespace Kreta.BusinessLogic.Helpers.ImportExport
+{
+    public class TanmenetImportExportHelper : LogicBase
+    {
+        #region Fields
+
+        private readonly string _importObjectCacheKey;
+
+        #endregion Fields
+
+        #region Properties
+
+        public static Dictionary<int, string> ImportHeaderList => new Dictionary<int, string>
+        {
+            { 00, ImportExportTanmenetResource.ImportHeaderNameOraszam },
+            { 01, ImportExportTanmenetResource.ImportHeaderNameTema }
+        };
+
+        public TanmenetImportCo ImportCo
+        {
+            get => (TanmenetImportCo)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 TanmenetImportExportHelper(IConnectionType connectionType) : base(connectionType)
+        {
+            _importObjectCacheKey = $"{nameof(TanmenetImportCo)}_{IntezmenyId}_{FelhasznaloId}_ImportObjectCacheKey";
+        }
+
+        #endregion Constructors
+
+        public void SetImportCo(List<List<string>> importData, int tantargyfelosztasId, bool isFromSzervezet)
+        {
+            var importCo = GetImportCoFromImportData(importData, tantargyfelosztasId, isFromSzervezet);
+            importCo.ImportMuvelet = (int)ImportMuveletEnum.DeleteAndInsert;
+
+            SetNemImportalhatoSorokByValidation(importCo);
+
+            SetOperationAndNemImportalhatoSorokByOperation(importCo);
+
+            var mainImportJsonItemList = new List<TanmenetImportJsonItemCo>(importCo.MainImportItemList.Select(x => new TanmenetImportJsonItemCo(x, importCo.Tantargyfelosztas, TanevId, IntezmenyId, FelhasznaloId)));
+            importCo.MainImportJsonItemList = mainImportJsonItemList;
+
+            ImportCo = importCo;
+        }
+
+        private static void SetNemImportalhatoSorokByValidation(TanmenetImportCo importCo)
+        {
+            Dictionary<int, List<ValidationResult>> validationResultDictionary = importCo.Validate();
+
+            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
+            foreach (TanmenetImportItemCo 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(TanmenetImportCo importCo)
+        {
+            foreach (TanmenetImportItemCo importItem in importCo.MainImportItemList)
+            {
+                importItem.Operation = (int)ImportItemOperationEnum.Insert;
+            }
+        }
+
+        private TanmenetImportCo GetImportCoFromImportData(List<List<string>> importData, int tantargyfelosztasId, bool isFromSzervezet)
+        {
+            var tantargyfelosztasCoList = new TantargyFelosztasHelper(ConnectionType).GetTantargyfelosztasCoList(alkalmazottId: FelhasznaloId, isFromSzervezet: isFromSzervezet);
+
+            if (isFromSzervezet)
+            {
+                var szervezetHelper = new SzervezetHelper(ConnectionType);
+                var alkalmazottSzervezetId = szervezetHelper.GetAlkalmazottSzervezetId(FelhasznaloId);
+                var lathatoSzervezetIdList = szervezetHelper.GetLathatoSzervezetIdList(alkalmazottSzervezetId, SzervezetAdatokHalmazaEnum.SzervezetEsAlSzervezetek);
+
+                tantargyfelosztasCoList.RemoveAll(x =>
+                {
+                    if (x.SzervezetId.IsEntityId())
+                    {
+                        return !lathatoSzervezetIdList.Contains(x.SzervezetId.Value);
+                    }
+
+                    return true;
+                });
+            }
+
+            var importCo = new TanmenetImportCo
+            {
+                Tantargyfelosztas = tantargyfelosztasCoList.Single(x => x.Id == tantargyfelosztasId),
+            };
+
+            var tanmenetCoList = new TanmenetHelper(ConnectionType).GetTanmenetCoList(FelhasznaloId).Where(x => x.TantargyfelosztasId == tantargyfelosztasId).ToList();
+
+            var lineNumber = 1;
+            foreach (var importDataRow in importData.Skip(1))
+            {
+                var importItemCo = new TanmenetImportItemCo
+                {
+                    LineNumber = lineNumber,
+
+                    OraszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanmenetResource.ImportHeaderNameOraszam)],
+                    TemaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanmenetResource.ImportHeaderNameTema)]
+                };
+
+                if (importCo.Tantargyfelosztas != null && importItemCo.OraSorszam.IsNotNullAndPositive())
+                {
+                    importItemCo.Tanmenet = tanmenetCoList.SingleOrDefault(x =>
+                        x.TantargyfelosztasId == importCo.Tantargyfelosztas.Id &&
+                        x.OraSorszam == importItemCo.OraSorszam
+                    );
+                }
+
+                var md5HashInput = importItemCo.OraSorszam?.ToString();
+                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                importCo.MainImportItemList.Add(importItemCo);
+
+                lineNumber++;
+            }
+
+            return importCo;
+        }
+
+        #region Template
+
+        public MemoryStream GetTemplate()
+        {
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<TanmenetItemCo>(TanmenetItemCo.TanmenetExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
+            return SimpleExportLogic.GetTemplate(ImportExportTanmenetResource.ImportDefaultSheetName, simpleExportColumnCos);
+        }
+
+        #endregion Template
+
+        #region Export
+
+        public MemoryStream GetExport(int tantargyfelosztasId)
+        {
+            List<TanmenetItemCo> coList = new TanmenetHelper(ConnectionType).GetTanmenetCoList(FelhasznaloId).Where(x => x.TantargyfelosztasId == tantargyfelosztasId).ToList();
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<TanmenetItemCo>(TanmenetItemCo.TanmenetExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
+            return SimpleExportLogic.GetExport(ImportExportTanmenetResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        public MemoryStream GetNemImportalhatoSorokExport()
+        {
+            List<TanmenetImportItemCo> coList = ImportCo.NemImportalhatoItemList;
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<TanmenetImportItemCo>(TanmenetImportItemCo.NemImportalhatoSorokExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
+            return ImportExportHelper.NemImportalhatoSorokExport(ImportExportTanmenetResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        #endregion Export
+
+        public void Import(object importJsonObject, int importMuvelet, int tantargyId, int osztalyCsoportId)
+        {
+            string importJson = JsonConvert.SerializeObject(importJsonObject);
+            bool isTorles = importMuvelet == (int)ImportMuveletEnum.DeleteAndInsert;
+            Dal.CustomConnection.Run(ConnectionType, dalHandler => dalHandler.ImportExportDal().TanmenetImport(IntezmenyId, TanevId, FelhasznaloId, importJson, isTorles, tantargyId, osztalyCsoportId));
+        }
+
+        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary()
+        {
+            //NOTE: Create dropdown lists
+            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>();
+            return dropDownColumnSourceDictionary;
+        }
+    }
+}

Kreta.BusinessLogic/Helpers/ImportExport/TantargyfelosztasImportExportHelper.cs

@@ -0,0 +1,823 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Data;
+using System.IO;
+using System.Linq;
+using System.Runtime.Caching;
+using Aspose.Cells;
+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;
+using Kreta.Enums.ManualEnums.ImportExport;
+using Kreta.Resources;
+using Newtonsoft.Json;
+using OfficeOpenXml;
+
+namespace Kreta.BusinessLogic.Helpers.ImportExport
+{
+    public class TantargyfelosztasImportExportHelper : BaseTantargyfelosztasImportExportHelper
+    {
+        #region Fields
+
+        private readonly string _importObjectCacheKey;
+
+        #endregion Fields
+
+        #region Properties
+
+        public static Dictionary<int, string> ImportHeaderListEgyszeru => new Dictionary<int, string>
+        {
+            { 00, ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly },
+            { 01, ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport },
+            { 02, ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy },
+            { 03, ImportExportTantargyfelosztasResource.ImportHeaderNameOraszam },
+            { 04, ImportExportTantargyfelosztasResource.ImportHeaderNameTanar },
+            { 05, ImportExportTantargyfelosztasResource.ImportHeaderNameTulora },
+            { 06, ImportExportTantargyfelosztasResource.ImportHeaderNameTtfOraszamKorrekcio },
+            { 07, ImportExportTantargyfelosztasResource.ImportHeaderNameNemzetisegiOra },
+            { 08, ImportExportTantargyfelosztasResource.ImportHeaderNameMegbizasiOraszam }
+        };
+
+        public static Dictionary<int, string> ExportHeaderListEgyszeru => new Dictionary<int, string>(ImportHeaderListEgyszeru);
+
+        public static Dictionary<int, string> ImportHeaderListKereszttablas => new Dictionary<int, string>
+        {
+            { 00, ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly },
+            { 01, ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport },
+            { 02, ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy },
+            { 03, ImportExportTantargyfelosztasResource.ImportHeaderNameOsszesen }
+        };
+
+        public static Dictionary<int, string> ImportHeaderListKereszttablasOsztalyOszlopokkal => new Dictionary<int, string>
+        {
+            { 00, ImportExportTantargyfelosztasResource.ImportHeaderNameTanar },
+            { 01, ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy },
+            { 02, ImportExportTantargyfelosztasResource.ImportHeaderNameOsszesen }
+        };
+
+        public static Dictionary<int, string> ImportHeaderListFeladatfelosztasExcel => new Dictionary<int, string>
+        {
+            { 00, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasPedagogusNeve },
+            { 01, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasPedagogusMunkakore },
+            { 02, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasFoglalkoztatasiJogviszony },
+            { 03, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasPedagogusMunkaugyiAdatai },
+            { 04, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasPedagogusLekotottOraszam },
+            { 05, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasSzakkepzettsegTanithatoTantargyak },
+            { 06, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasTantargyEgyebFoglalkozas },
+            { 07, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasOraterviOrakEsEgyebFoglalkozasokSzama },
+            { 08, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasPedagogusOrakedvezmenye },
+            { 09, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasNevelesselOktatassalLekotottOraszam },
+            { 10, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasSzakertoiBizottsagiTevekenyseg },
+            { 11, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasNevelesiTanacsadas },
+            { 12, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasKonduktivPedagogiaiEllatas },
+            { 13, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasIskolapszichologiaiOvodapszichologiaiEllatas },
+            { 14, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasLogopediaiEllatas },
+            { 15, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasGyogytestneveles },
+            { 16, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasGyogypedagogiaiTanacsadas },
+            { 17, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasKiemeltenTehetsegesGyermekekTanulokGondozasa },
+            { 18, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasTovabbtanulasiPalyavalasztasiTanacsadas },
+            { 19, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasOsszesenNemTanoraiCsoportok }
+        };
+
+        public TantargyfelosztasImportCo ImportCo
+        {
+            get => (TantargyfelosztasImportCo)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 TantargyfelosztasImportExportHelper(IConnectionType connectionType) : base(connectionType)
+        {
+            _importObjectCacheKey = $"{nameof(TantargyfelosztasImportCo)}_{IntezmenyId}_{FelhasznaloId}_ImportObjectCacheKey";
+        }
+
+        #endregion Constructors
+
+        public static List<List<string>> GetImportDataFromKereszttablasTantargyfelosztasExcel(Stream uploadedFile, Dictionary<int, string> expectedImportHeaderList, out List<string> errorResult)
+        {
+            errorResult = new List<string>();
+            if (uploadedFile is FileStream fileStream)
+            {
+                var fileInfo = new FileInfo(fileStream.Name);
+                if (fileInfo.Extension != ".xlsx")
+                {
+                    errorResult.Add(ErrorResource.CsakXlsxKiterjesztesuExcelFiletLehetImportalni);
+                    return null;
+                }
+            }
+
+            using (var excelPackage = new ExcelPackage(uploadedFile))
+            {
+                var importData = new List<List<string>>
+                {
+                    ImportHeaderListEgyszeru.Select(x => x.Value).ToList()
+                };
+
+                ExcelWorksheet excelWorksheet = excelPackage.Workbook.Worksheets.First();
+                ExcelCellAddress startExcelCellAddress = excelWorksheet.Dimension.Start;
+                ExcelCellAddress endExcelCellAddress = excelWorksheet.Dimension.End;
+
+                int startColumnIndex = 5;
+                //Tanárok kiolvasása
+                int tanarColumnIndex = startColumnIndex;
+                var tanarList = new List<string>();
+                while (!string.IsNullOrWhiteSpace(excelWorksheet.Cells[1, tanarColumnIndex].Text.ReplaceMultipleSpacesAndTrim()))
+                {
+                    tanarList.Add(excelWorksheet.Cells[1, tanarColumnIndex].Text.ReplaceMultipleSpacesAndTrim());
+                    tanarColumnIndex++;
+                }
+
+                int lastExpectedImportTanarColumnIndex = tanarList.Count + startColumnIndex;
+
+                var excelHeaderList = new Dictionary<int, string>();
+                for (int columnIndex = startExcelCellAddress.Column; columnIndex <= startColumnIndex - 1; columnIndex++)
+                {
+                    excelHeaderList.Add(columnIndex, excelWorksheet.Cells[2, columnIndex].Text.ReplaceMultipleSpacesAndTrim());
+                }
+
+                for (int expectedImportHeaderColumnIndex = 0; expectedImportHeaderColumnIndex < startColumnIndex - 1; expectedImportHeaderColumnIndex++)
+                {
+                    int excelHeaderColumnIndex = expectedImportHeaderColumnIndex + 1;
+                    if (!expectedImportHeaderList[expectedImportHeaderColumnIndex].Equals(excelHeaderList[excelHeaderColumnIndex]))
+                    {
+                        errorResult.Add(string.Format(ErrorResource.RosszImportHeader, excelHeaderColumnIndex, excelHeaderList[excelHeaderColumnIndex], expectedImportHeaderList[expectedImportHeaderColumnIndex]));
+                    }
+                }
+
+                if (errorResult.Count > 0)
+                {
+                    return null;
+                }
+
+                for (int rowIndex = 3; rowIndex <= endExcelCellAddress.Row; rowIndex++)
+                {
+                    string osztalyNev = excelWorksheet.Cells[rowIndex, 1].Text.ReplaceMultipleSpacesAndTrim();
+                    string csoportNev = excelWorksheet.Cells[rowIndex, 2].Text.ReplaceMultipleSpacesAndTrim();
+                    string tantargyNev = excelWorksheet.Cells[rowIndex, 3].Text.ReplaceMultipleSpacesAndTrim();
+                    string tuloraszam = 0.ToString();
+                    string isOsszevontOraString = CommonResource.Nem;
+                    string isNemzetisegiOraString = CommonResource.Nem;
+                    string megbizasiOraszamString = 0.ToString();
+
+                    for (int columnIndex = startColumnIndex; columnIndex <= lastExpectedImportTanarColumnIndex; columnIndex++)
+                    {
+                        var currentTantargyfelosztasDataList = new List<string>();
+                        string oraszam = excelWorksheet.Cells[rowIndex, columnIndex].Text.ReplaceMultipleSpacesAndTrim();
+                        if (!string.IsNullOrWhiteSpace(oraszam))
+                        {
+                            string tanarNev = tanarList.ElementAtOrDefault(columnIndex - startColumnIndex) ?? string.Empty;
+
+                            currentTantargyfelosztasDataList.Add(osztalyNev);
+                            currentTantargyfelosztasDataList.Add(csoportNev);
+                            currentTantargyfelosztasDataList.Add(tantargyNev);
+                            currentTantargyfelosztasDataList.Add(oraszam);
+                            currentTantargyfelosztasDataList.Add(tanarNev);
+                            currentTantargyfelosztasDataList.Add(tuloraszam);
+                            currentTantargyfelosztasDataList.Add(isOsszevontOraString);
+                            currentTantargyfelosztasDataList.Add(isNemzetisegiOraString);
+                            currentTantargyfelosztasDataList.Add(megbizasiOraszamString);
+
+                            importData.Add(currentTantargyfelosztasDataList);
+                        }
+                    }
+                }
+
+                return importData;
+            }
+        }
+
+        public static List<List<string>> GetImportDataFromKereszttablasTantargyfelosztasOsztalyOszlopokkalExcel(Stream uploadedFile, Dictionary<int, string> expectedImportHeaderList, out List<string> errorResult)
+        {
+            errorResult = new List<string>();
+            if (uploadedFile is FileStream fileStream)
+            {
+                var fileInfo = new FileInfo(fileStream.Name);
+                if (fileInfo.Extension != ".xlsx")
+                {
+                    errorResult.Add(ErrorResource.CsakXlsxKiterjesztesuExcelFiletLehetImportalni);
+                    return null;
+                }
+            }
+
+            using (var excelPackage = new ExcelPackage(uploadedFile))
+            {
+                var importData = new List<List<string>>
+                {
+                    ImportHeaderListEgyszeru.Select(x => x.Value).ToList()
+                };
+
+                ExcelWorksheet excelWorksheet = excelPackage.Workbook.Worksheets.First();
+                ExcelCellAddress startExcelCellAddress = excelWorksheet.Dimension.Start;
+                ExcelCellAddress endExcelCellAddress = excelWorksheet.Dimension.End;
+
+                int startColumnIndex = 4;
+                //Osztályok listája
+                int osztalyColumnIndex = startColumnIndex;
+                var osztalyList = new List<string>();
+
+                while (osztalyColumnIndex <= endExcelCellAddress.Column)
+                {
+                    osztalyList.Add(excelWorksheet.Cells[1, osztalyColumnIndex].Text.ReplaceMultipleSpacesAndTrim());
+                    osztalyColumnIndex++;
+                }
+
+                //Csoportok listája
+                int csoportColumnIndex = startColumnIndex;
+                var csoportList = new List<string>();
+                while (csoportColumnIndex <= endExcelCellAddress.Column)
+                {
+                    csoportList.Add(excelWorksheet.Cells[2, csoportColumnIndex].Text.ReplaceMultipleSpacesAndTrim());
+                    csoportColumnIndex++;
+                }
+
+                int lastExpectedImportColumnIndex = osztalyColumnIndex >= csoportColumnIndex ? osztalyColumnIndex : csoportColumnIndex;
+
+                var excelHeaderList = new Dictionary<int, string>();
+                for (int columnIndex = startExcelCellAddress.Column; columnIndex <= startColumnIndex - 1; columnIndex++)
+                {
+                    excelHeaderList.Add(columnIndex, excelWorksheet.Cells[3, columnIndex].Text.ReplaceMultipleSpacesAndTrim());
+                }
+
+                for (int expectedImportHeaderColumnIndex = 0; expectedImportHeaderColumnIndex < startColumnIndex - 1; expectedImportHeaderColumnIndex++)
+                {
+                    int excelHeaderColumnIndex = expectedImportHeaderColumnIndex + 1;
+                    if (!expectedImportHeaderList[expectedImportHeaderColumnIndex].Equals(excelHeaderList[excelHeaderColumnIndex]))
+                    {
+                        errorResult.Add(string.Format(ErrorResource.RosszImportHeader, excelHeaderColumnIndex, excelHeaderList[excelHeaderColumnIndex], expectedImportHeaderList[expectedImportHeaderColumnIndex]));
+                    }
+                }
+
+                if (errorResult.Count > 0)
+                {
+                    return null;
+                }
+
+                for (int rowIndex = 4; rowIndex <= endExcelCellAddress.Row; rowIndex++)
+                {
+                    string tanarNev = excelWorksheet.Cells[rowIndex, 1].Text.ReplaceMultipleSpacesAndTrim();
+                    string tantargyNev = excelWorksheet.Cells[rowIndex, 2].Text.ReplaceMultipleSpacesAndTrim();
+                    string tuloraszam = 0.ToString();
+                    string isOsszevontOraString = CommonResource.Nem;
+                    string isNemzetisegiOraString = CommonResource.Nem;
+                    string megbizasiOraszamString = 0.ToString();
+
+                    for (int columnIndex = startColumnIndex; columnIndex <= lastExpectedImportColumnIndex; columnIndex++)
+                    {
+                        var currentTantargyfelosztasDataList = new List<string>();
+                        string oraszam = excelWorksheet.Cells[rowIndex, columnIndex].Text.ReplaceMultipleSpacesAndTrim();
+                        if (!string.IsNullOrWhiteSpace(oraszam))
+                        {
+                            string osztalyNev = osztalyList.ElementAtOrDefault(columnIndex - startColumnIndex) ?? string.Empty;
+                            string csoportnev = csoportList.ElementAtOrDefault(columnIndex - startColumnIndex) ?? string.Empty;
+
+                            currentTantargyfelosztasDataList.Add(osztalyNev);
+                            currentTantargyfelosztasDataList.Add(csoportnev);
+                            currentTantargyfelosztasDataList.Add(tantargyNev);
+                            currentTantargyfelosztasDataList.Add(oraszam);
+                            currentTantargyfelosztasDataList.Add(tanarNev);
+                            currentTantargyfelosztasDataList.Add(tuloraszam);
+                            currentTantargyfelosztasDataList.Add(isOsszevontOraString);
+                            currentTantargyfelosztasDataList.Add(isNemzetisegiOraString);
+                            currentTantargyfelosztasDataList.Add(megbizasiOraszamString);
+
+                            importData.Add(currentTantargyfelosztasDataList);
+                        }
+                    }
+                }
+
+                return importData;
+            }
+        }
+
+        public static List<List<string>> GetImportDataFromFeladatfelosztasExcel(Stream uploadedFile, Dictionary<int, string> expectedImportHeaderList, out List<string> errorResult)
+        {
+            errorResult = new List<string>();
+            if (uploadedFile is FileStream fileStream)
+            {
+                var fileInfo = new FileInfo(fileStream.Name);
+                if (fileInfo.Extension != ".xlsx")
+                {
+                    errorResult.Add(ErrorResource.CsakXlsxKiterjesztesuExcelFiletLehetImportalni);
+                    return null;
+                }
+            }
+
+            using (var excelPackage = new ExcelPackage(uploadedFile))
+            {
+                var importData = new List<List<string>>
+                {
+                    ImportHeaderListEgyszeru.Select(x => x.Value).ToList()
+                };
+
+                ExcelWorksheet excelWorksheet = excelPackage.Workbook.Worksheets.First();
+                ExcelCellAddress startExcelCellAddress = excelWorksheet.Dimension.Start;
+                ExcelCellAddress endExcelCellAddress = excelWorksheet.Dimension.End;
+                int lastExpectedImportColumnIndex = expectedImportHeaderList.Count;
+
+                var excelHeaderList = new Dictionary<int, string>();
+                for (int columnIndex = startExcelCellAddress.Column; columnIndex <= lastExpectedImportColumnIndex; columnIndex++)
+                {
+                    excelHeaderList.Add(columnIndex, excelWorksheet.Cells[4, columnIndex].Text.ReplaceMultipleSpacesAndTrim());
+                }
+
+                for (int expectedImportHeaderColumnIndex = 0; expectedImportHeaderColumnIndex < lastExpectedImportColumnIndex; expectedImportHeaderColumnIndex++)
+                {
+                    int excelHeaderColumnIndex = expectedImportHeaderColumnIndex + 1;
+                    if (!expectedImportHeaderList[expectedImportHeaderColumnIndex].Equals(excelHeaderList[excelHeaderColumnIndex]))
+                    {
+                        errorResult.Add(string.Format(ErrorResource.RosszImportHeader, excelHeaderColumnIndex, excelHeaderList[excelHeaderColumnIndex], expectedImportHeaderList[expectedImportHeaderColumnIndex]));
+                    }
+                }
+
+                if (errorResult.Count > 0)
+                {
+                    return null;
+                }
+
+                for (int rowIndex = 5; rowIndex <= endExcelCellAddress.Row; rowIndex++)
+                {
+                    string osztalyNev = string.Empty;
+                    string tantargyNev = excelWorksheet.Cells[rowIndex, 7].Text.ReplaceMultipleSpacesAndTrim();
+                    string tanarNev = excelWorksheet.Cells[rowIndex, 1].Text.ReplaceMultipleSpacesAndTrim();
+                    string tuloraszam = 0.ToString();
+                    string isOsszevontOraString = CommonResource.Nem;
+                    string isNemzetisegiOraString = CommonResource.Nem;
+                    string mebizasiOraszamString = 0.ToString();
+
+                    for (int columnIndex = 11; columnIndex <= lastExpectedImportColumnIndex - 1; columnIndex++)
+                    {
+                        var currentTantargyfelosztasDataList = new List<string>();
+                        string oraszam = excelWorksheet.Cells[rowIndex, columnIndex].Text.ReplaceMultipleSpacesAndTrim();
+                        if (!string.IsNullOrWhiteSpace(oraszam))
+                        {
+                            string csoportNev = expectedImportHeaderList[columnIndex - 1];
+
+                            currentTantargyfelosztasDataList.Add(osztalyNev);
+                            currentTantargyfelosztasDataList.Add(csoportNev);
+                            currentTantargyfelosztasDataList.Add(tantargyNev);
+                            currentTantargyfelosztasDataList.Add(oraszam);
+                            currentTantargyfelosztasDataList.Add(tanarNev);
+                            currentTantargyfelosztasDataList.Add(tuloraszam);
+                            currentTantargyfelosztasDataList.Add(isOsszevontOraString);
+                            currentTantargyfelosztasDataList.Add(isNemzetisegiOraString);
+                            currentTantargyfelosztasDataList.Add(mebizasiOraszamString);
+
+                            importData.Add(currentTantargyfelosztasDataList);
+                        }
+                    }
+                }
+
+                return importData;
+            }
+        }
+
+        public void SetImportCo(List<List<string>> importData, int importMuvelet, int feladatellatasiHelyId, int tantargyfelosztasImportTipus)
+        {
+            TantargyfelosztasImportCo importCo = GetImportCoFromImportData(importData, tantargyfelosztasImportTipus, feladatellatasiHelyId);
+            importCo.ImportMuvelet = importMuvelet;
+
+            SetNemImportalhatoSorokByValidation(importCo);
+
+            SetOraszamSumAndRemoveDuplicates(importCo);
+
+            //NOTE: Azért van szükség Dictionary-kre, mert így sokkal gyorsabb a keresés!
+            Dictionary<string, ImportItemCompareCo> tantargyCompareHashImportItemCompareCoDictionary = GetTantargyCompareHashImportItemCompareCoDictionary();
+            Dictionary<string, ImportItemCompareCo> osztalyCompareHashImportItemCompareCoDictionary = GetOsztalyCompareHashImportItemCompareCoDictionary();
+            Dictionary<string, ImportItemCompareCo> csoportCompareHashImportItemCompareCoDictionary = GetCsoportCompareHashImportItemCompareCoDictionary();
+            Dictionary<string, ImportItemCompareCo> tantargyfelosztasCompareHashImportItemCompareCoDictionary = GetTantargyfelosztasCompareHashImportItemCompareCoDictionary(importCo.GetBaseImportItemCoList());
+            foreach (TantargyfelosztasImportItemCo importItem in importCo.MainImportItemList)
+            {
+                SetOperationTantargy(importItem, tantargyCompareHashImportItemCompareCoDictionary);
+                SetOperationOsztaly(importItem, osztalyCompareHashImportItemCompareCoDictionary);
+                SetOperationCsoport(importItem, csoportCompareHashImportItemCompareCoDictionary);
+                SetOperationTantargyfelosztas(importItem, tantargyfelosztasCompareHashImportItemCompareCoDictionary, importCo);
+            }
+
+            //NOTE: Azokat a sorokat, amelyek bekerültek a NemImportalhatoItemList-be, azokat kiveszzük a MainImportItemList-ből!
+            importCo.MainImportItemList.RemoveRange(importCo.NemImportalhatoItemList);
+
+            var tantargyImportJsonItemList = new List<TantargyImportJsonItemCo>();
+            var osztalyCsoportImportJsonItemList = new List<OsztalyCsoportImportJsonItemCo>();
+            var osztalyImportJsonItemList = new List<OsztalyImportJsonItemCo>();
+            var csoportImportJsonItemList = new List<CsoportImportJsonItemCo>();
+            var mainImportJsonItemList = new List<TantargyfelosztasImportJsonItemCo>();
+            foreach (TantargyfelosztasImportItemCo importItem in importCo.MainImportItemList)
+            {
+                if (tantargyImportJsonItemList.All(x => x.Nev.ToComparableString() != importItem.TantargyNev.ToComparableString()) &&
+                    importItem.OperationTantargy == (int)ImportItemOperationEnum.Insert)
+                {
+                    tantargyImportJsonItemList.Add(new TantargyImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
+                }
+
+                var osztalyNevToCompare = importItem.OsztalyNev?.ToComparableString();
+                if (!string.IsNullOrWhiteSpace(osztalyNevToCompare) &&
+                    !osztalyImportJsonItemList.Select(x => x.OsztalyCsoportNev.ToComparableString()).Contains(osztalyNevToCompare) &&
+                    importItem.OperationOsztaly == (int)ImportItemOperationEnum.Insert)
+                {
+                    osztalyImportJsonItemList.Add(new OsztalyImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
+                    osztalyCsoportImportJsonItemList.Add(new OsztalyCsoportImportJsonItemCo(importItem, importItem.OperationOsztaly, importItem.OsztalyNev, importCo.FeladatellatasiHelyId, importCo.FeladatKategoriaId, TanevId, IntezmenyId, FelhasznaloId));
+                }
+
+                var csoportNevToCompare = importItem.CsoportNev?.ToComparableString();
+                if (!string.IsNullOrWhiteSpace(csoportNevToCompare) &&
+                    !csoportImportJsonItemList.Select(x => x.OsztalyCsoportNev.ToComparableString()).Contains(csoportNevToCompare) &&
+                    importItem.OperationCsoport == (int)ImportItemOperationEnum.Insert)
+                {
+                    csoportImportJsonItemList.Add(new CsoportImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
+                    osztalyCsoportImportJsonItemList.Add(new OsztalyCsoportImportJsonItemCo(importItem, importItem.OperationCsoport, importItem.CsoportNev, importCo.FeladatellatasiHelyId, importCo.FeladatKategoriaId, TanevId, IntezmenyId, FelhasznaloId));
+                }
+
+                //NOTE: Az egyik ".Value"-s érték sem lehet null, mert ide már csak olyan elem jön be, aminek jók az értékei!
+                mainImportJsonItemList.Add(
+                    new TantargyfelosztasImportJsonItemCo(
+                        importItem,
+                        importItem.CompareHash,
+                        importItem.OraszamSum,
+                        importItem.Tuloraszam.Value,
+                        importItem.IsOsszevontOra.Value,
+                        importItem.IsNemzetisegiOra.Value,
+                        importItem.MegbizasiOraszam.Value, TanevId, IntezmenyId, FelhasznaloId
+                    )
+                );
+            }
+
+            importCo.TantargyImportJsonItemList = tantargyImportJsonItemList;
+            importCo.OsztalyCsoportImportJsonItemList = osztalyCsoportImportJsonItemList;
+            importCo.OsztalyImportJsonItemList = osztalyImportJsonItemList;
+            importCo.CsoportImportJsonItemList = csoportImportJsonItemList;
+            importCo.MainImportJsonItemList = mainImportJsonItemList;
+
+            ImportCo = importCo;
+        }
+
+        private static void SetNemImportalhatoSorokByValidation(TantargyfelosztasImportCo importCo)
+        {
+            Dictionary<int, List<ValidationResult>> validationResultDictionary = importCo.Validate(importCo.FeladatellatasiHelyCo);
+
+            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
+            foreach (TantargyfelosztasImportItemCo 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 static void SetOraszamSumAndRemoveDuplicates(TantargyfelosztasImportCo importCo)
+        {
+            var mainImportItemList = new List<TantargyfelosztasImportItemCo>();
+            foreach (TantargyfelosztasImportItemCo mainImportItem in importCo.MainImportItemList)
+            {
+                //NOTE: Az Oraszam.Value nem lehet null, mert ide már csak olyan elem jön be, aminek jók az értékei!
+                double oraszam = mainImportItem.Oraszam.Value;
+                if (mainImportItemList.Any(x => x.CompareHash == mainImportItem.CompareHash))
+                {
+                    mainImportItemList.Single(x => x.CompareHash == mainImportItem.CompareHash).OraszamSum += oraszam;
+                }
+                else
+                {
+                    mainImportItem.OraszamSum = oraszam;
+                    mainImportItemList.Add(mainImportItem);
+                }
+            }
+
+            importCo.MainImportItemList = mainImportItemList;
+        }
+
+        private static void SetOperationTantargyfelosztas(TantargyfelosztasImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, TantargyfelosztasImportCo importCo)
+        {
+            int importMuvelet = importCo.ImportMuvelet;
+            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...
+            else
+            {
+                ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                //NOTE: ...ha az import művelet DeleteAndInsert és a db-ből jövő adat Importalt(a nem importáltakat egyelőre nem töröljük), akkor Insert, mert töröljük a korábbi elemeket és újra be kell szúrni!
+                if (importMuvelet == (int)ImportMuveletEnum.DeleteAndInsert && importItemCompareCo.Importalt)
+                {
+                    importItem.Operation = (int)ImportItemOperationEnum.Insert;
+                }
+                //NOTE: ...ha nincs törlés, akkor...
+                else
+                {
+                    //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
+                    if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                    {
+                        importItem.Id = importItemCompareCo.Id;
+                        importItem.Operation = (int)ImportItemOperationEnum.Update;
+                    }
+                    //NOTE: ...ha a művelet nem InsertAndUpdate, akkor hozzá kell adni a nem NemImportalhatoItemList-hez és jelezni, hogy már szerepel az adatbázisban(Insert vagy DeleteAndInsert műveletnél. A DeleteAndInsert csak akkor fut be ide, ha az elem nem importált.)!
+                    else
+                    {
+                        importItem.ErrorList.Add(ImportExportCommonResource.NemImportalhatoMertMarSzerepelAzAdatbazisban);
+                        importCo.NemImportalhatoItemList.Add(importItem);
+                    }
+                }
+            }
+        }
+
+        public TantargyfelosztasImportCo GetImportCoFromImportData(List<List<string>> importData, int tantargyfelosztasImportTipus, int feladatellatasiHelyId)
+        {
+            List<AlkalmazottItemCo> tanarCoList = null;
+            List<OsztalyItemCo> osztalyCoList = null;
+            List<CsoportItemCo> csoportCoList = null;
+            FeladatEllatasiHelyCO feladatellatasiHelyCo = null;
+            int feladatKategoriaId = -1;
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                tanarCoList = new AlkalmazottHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetAlkalmazottCoList();
+                osztalyCoList = new OsztalyHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetOsztalyCoList();
+                csoportCoList = new CsoportHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetCsoportCoList();
+                feladatellatasiHelyCo = new FeladatEllatasiHelyHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetFeladatEllatasiHelyAdatok(feladatellatasiHelyId);
+                feladatKategoriaId = new FeladatEllatasiHelyHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetFeladatKategoriaId(feladatellatasiHelyId);
+            });
+            var importCo = new TantargyfelosztasImportCo
+            {
+                TantargyfelosztasImportTipus = tantargyfelosztasImportTipus,
+                TanarCoList = tanarCoList,
+                OsztalyCoList = osztalyCoList,
+                CsoportCoList = csoportCoList,
+                FeladatellatasiHelyId = feladatellatasiHelyId,
+                FeladatellatasiHelyCo = feladatellatasiHelyCo,
+                FeladatKategoriaId = feladatKategoriaId
+            };
+
+            string csoportNevPrefix = $"{feladatellatasiHelyCo.MukodesiHelyNev} - {feladatellatasiHelyCo.OktatasiNevelesiFeladatNev} - ";
+
+            int lineNumber = 1;
+            foreach (List<string> importDataRow in importData.Skip(1))
+            {
+                var importItemCo = new TantargyfelosztasImportItemCo
+                {
+                    LineNumber = lineNumber,
+
+                    OsztalyNevImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly)],
+                    CsoportNevImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport)],
+                    TantargyNevImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy)],
+                    OraszamImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOraszam)],
+                    TanarNevImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTanar)],
+                    TuloraImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTulora)],
+                    TtfOraszamKorrekcioImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTtfOraszamKorrekcio)],
+                    NemzetisegiOraImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameNemzetisegiOra)],
+                    MegbizasiOraszamImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameMegbizasiOraszam)]
+                };
+                if (!string.IsNullOrWhiteSpace(importItemCo.TanarNev))
+                {
+                    var tanarList = tanarCoList.Where(x =>
+                        x.FelhasznaloNyomtatasiNevComparableString == importItemCo.TanarNev?.ToComparableString() &&
+                        (!importItemCo.TanarSzuletesiIdo.HasValue || importItemCo.TanarSzuletesiIdo == x.FelhasznaloSzuletesiIdo)).ToList();
+                    if (tanarList.Count == 1)
+                    {
+                        importItemCo.TanarId = tanarList.Single().Id;
+                    }
+                }
+
+                int? csoportTipusId;
+                if (tantargyfelosztasImportTipus == (int)TantargyfelosztasImportTipusEnum.FeladatfelosztasImport)
+                {
+                    if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasSzakertoiBizottsagiTevekenyseg)
+                    {
+                        csoportTipusId = (int)CsoportTipusEnum.szakertoi_bizottsagi_tevekenyseg;
+                    }
+                    else if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasNevelesiTanacsadas)
+                    {
+                        csoportTipusId = (int)CsoportTipusEnum.nevelesi_tanacsadas;
+                    }
+                    else if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasKonduktivPedagogiaiEllatas)
+                    {
+                        csoportTipusId = (int)CsoportTipusEnum.konduktiv_pedagogiai_ellatas;
+                    }
+                    else if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasIskolapszichologiaiOvodapszichologiaiEllatas)
+                    {
+                        csoportTipusId = (int)CsoportTipusEnum.iskolapszichologiai_ovodapszichologiai_ellatas;
+                    }
+                    else if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasLogopediaiEllatas)
+                    {
+                        csoportTipusId = (int)CsoportTipusEnum.logopediai_ellatas;
+                    }
+                    else if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasGyogytestneveles)
+                    {
+                        csoportTipusId = (int)CsoportTipusEnum.gyogytestneveles;
+                    }
+                    else if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasGyogypedagogiaiTanacsadas)
+                    {
+                        csoportTipusId = (int)CsoportTipusEnum.gyogypedagogiai_tanacsadas_korai_fejlesztes_es_gondozas;
+                    }
+                    else if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasKiemeltenTehetsegesGyermekekTanulokGondozasa)
+                    {
+                        csoportTipusId = (int)CsoportTipusEnum.kiemelten_tehetseges_gyermekek_tanulok_gondozasa;
+                    }
+                    else if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasTovabbtanulasiPalyavalasztasiTanacsadas)
+                    {
+                        csoportTipusId = (int)CsoportTipusEnum.tovabbtanulasi_palyavalasztasi_tanacsadas;
+                    }
+                    else
+                    {
+                        csoportTipusId = null;
+                    }
+
+                    //NOTE: Beállítjuk a csoportnévnek a feladatellátási hely nevét prefixként, amikor feladatfelosztást importálunk!
+                    importItemCo.CsoportNevImportData = $"{csoportNevPrefix}{importItemCo.CsoportNevImportData}";
+                }
+                else
+                {
+                    csoportTipusId = (int)CsoportTipusEnum.na;
+                }
+
+                importItemCo.CsoportTipusId = csoportTipusId;
+
+                string tantargyMd5HashInput = importItemCo.TantargyNev?.ToComparableString();
+                importItemCo.CompareHashTantargy = ImportExportHelper.GetMd5Hash(tantargyMd5HashInput);
+
+                if (!string.IsNullOrWhiteSpace(importItemCo.OsztalyNev))
+                {
+                    string osztalyMd5HashInput = importItemCo.OsztalyNev.ToComparableString();
+                    importItemCo.CompareHashOsztaly = ImportExportHelper.GetMd5Hash(osztalyMd5HashInput);
+                }
+
+                if (!string.IsNullOrWhiteSpace(importItemCo.CsoportNev))
+                {
+                    string csoportMd5HashInput = importItemCo.CsoportNev.ToComparableString();
+                    importItemCo.CompareHashCsoport = ImportExportHelper.GetMd5Hash(csoportMd5HashInput);
+                }
+
+                string tantargyfelosztasMd5HashInput =
+                    importItemCo.OsztalyCsoportNev?.ToComparableString() +
+                    importItemCo.TantargyNev?.ToComparableString() +
+                    importItemCo.TanarNev?.ToComparableString();
+                if (importItemCo.TanarSzuletesiIdo.HasValue)
+                {
+                    tantargyfelosztasMd5HashInput += importItemCo.TanarSzuletesiIdoString?.ToComparableString();
+                }
+
+                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(tantargyfelosztasMd5HashInput);
+
+                importCo.MainImportItemList.Add(importItemCo);
+
+                lineNumber++;
+            }
+
+            return importCo;
+        }
+
+        public MemoryStream GetTemplate(bool isSzakkepzo = false, bool isDualisEnabled = false)
+        {
+            var dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary(isFromSzervezet: isDualisEnabled, isSzakkepzo: isSzakkepzo);
+
+            MemoryStream memoryStream = ImportExportHelper.GetTemplate(ImportExportTantargyfelosztasResource.ImportDefaultSheetName, ImportHeaderListEgyszeru, dropDownColumnSourceDictionary);
+
+            return memoryStream;
+        }
+
+        public MemoryStream GetExport()
+        {
+            var dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary();
+
+            DataSet tantargyfelosztasDataSet = null;
+            List<AlkalmazottItemCo> tanarCoList = null;
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                tantargyfelosztasDataSet = dalHandler.TantargyFelosztas(GridParameters).GetTantargyFelosztasokKereses(tanevId: TanevId);
+                tanarCoList = new AlkalmazottHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetAlkalmazottCoList();
+            });
+
+            using (var workbook = new Workbook())
+            {
+                var worksheet = ImportExportHelper.GetWorksheetsWithDropDownFormula(workbook, ImportExportTantargyfelosztasResource.ImportDefaultSheetName, ExportHeaderListEgyszeru, dropDownColumnSourceDictionary);
+
+                int rowNumber = 1;
+                foreach (DataRow dataRow in tantargyfelosztasDataSet.Tables[0].AsEnumerable())
+                {
+                    if (SDAConvert.ToBoolean(dataRow["IsOsztaly"], false))
+                    {
+                        worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly)].Value = SDAConvert.ToString(dataRow["OsztalyCsoport"]) ?? string.Empty;
+                        worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport)].Value = string.Empty;
+                    }
+                    else
+                    {
+                        worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly)].Value = SDAConvert.ToBoolean(dataRow["IsOsztalyBontottCsoport"], false) ? SDAConvert.ToString(dataRow["OsztalyBontottCsoportNev"]) : string.Empty;
+                        worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport)].Value = SDAConvert.ToString(dataRow["OsztalyCsoport"]) ?? string.Empty;
+                    }
+
+                    worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy)].Value = SDAConvert.ToString(dataRow["Tantargy"]) ?? string.Empty;
+                    worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOraszam)].Value = SDAConvert.ToDecimal(dataRow["Oraszam"]).ToString();
+
+                    //NOTE: Erre azért van szükség, ha több egyforma nevű tanár szerepel az adatbázisban, akkor zárójelben mögé tesszük a születési dátumát az export-ban, hogy meg tudjuk őket különböztetni!
+                    string tanarNev = SDAConvert.ToString(dataRow["Tanar"]) ?? string.Empty;
+                    DateTime tanarSzuletesiIdo = SDAConvert.ToDateTime(dataRow["TanarSzuletesiIdo"]).Value;
+                    if (tanarCoList.Count(x => x.FelhasznaloNyomtatasiNevComparableString == tanarNev.ToComparableString()) > 1)
+                    {
+                        var tanarSzuletesiIdoString = tanarSzuletesiIdo.ToString(Constants.ToStringPattern.HungarianDate);
+                        tanarNev += $" ({tanarSzuletesiIdoString})";
+                    }
+
+                    worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTanar)].Value = tanarNev;
+
+                    worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTulora)].Value = SDAConvert.ToDecimal(dataRow["TuloraSzam"]).ToString();
+                    worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTtfOraszamKorrekcio)].Value = SDAConvert.ToBooleanFromTF(dataRow["OsszevontOra"]).GetDisplayName();
+                    worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameNemzetisegiOra)].Value = SDAConvert.ToBooleanFromTF(dataRow["NemzetisegiOra"]).GetDisplayName();
+                    worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameMegbizasiOraszam)].Value = SDAConvert.ToDecimal(dataRow["MegbizasiOraszam"]).ToString();
+
+                    rowNumber++;
+                }
+
+                MemoryStream memoryStream = SimpleExportLogic.GetWorkbookMemoryStream(workbook);
+                return memoryStream;
+            }
+        }
+
+        public MemoryStream GetNemImportalhatoSorokExport()
+        {
+            var dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary();
+
+            using (var workbook = new Workbook())
+            {
+                var worksheet = ImportExportHelper.GetWorksheetsWithDropDownFormula(workbook, ImportExportTantargyfelosztasResource.ImportDefaultSheetName, ImportHeaderListEgyszeru, dropDownColumnSourceDictionary);
+
+                int rowNumber = 1;
+                foreach (TantargyfelosztasImportItemCo co in ImportCo.NemImportalhatoItemList)
+                {
+                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly)].Value = co.OsztalyNevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport)].Value = co.CsoportNevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy)].Value = co.TantargyNevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOraszam)].Value = co.OraszamImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTanar)].Value = co.TanarNevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTulora)].Value = co.TuloraImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTtfOraszamKorrekcio)].Value = co.TtfOraszamKorrekcioImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameNemzetisegiOra)].Value = co.NemzetisegiOraImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameMegbizasiOraszam)].Value = co.MegbizasiOraszamImportData;
+
+                    Cell errorCell = worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.Count];
+                    errorCell.Value = string.Join(Environment.NewLine, co.ErrorList);
+                    errorCell.SetTextWrap();
+
+                    rowNumber++;
+                }
+
+                var sheetCodeNameAndColumnsToWrapIndexDictionary = new Dictionary<string, List<int>>
+                {
+                    { workbook.Worksheets[0].CodeName, new List<int> { ImportHeaderListEgyszeru.Count } }
+                };
+                MemoryStream memoryStream = SimpleExportLogic.GetWorkbookMemoryStream(workbook, sheetCodeNameAndColumnsToWrapIndexDictionary);
+                return memoryStream;
+            }
+        }
+
+        public void Import(object importJsonObject, int importMuvelet)
+        {
+            string importJson = JsonConvert.SerializeObject(importJsonObject);
+            bool isTorles = importMuvelet == (int)ImportMuveletEnum.DeleteAndInsert;
+            Dal.CustomConnection.Run(ConnectionType, dalHandler => dalHandler.ImportExportDal().TantargyfelosztasImport(IntezmenyId, TanevId, FelhasznaloId, importJson, isTorles));
+        }
+
+        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary(bool isFromSzervezet = false, bool isSzakkepzo = false)
+        {
+            //NOTE: Create dropdown lists
+            var logicalColumnDictionary = new Dictionary<string, IList<string>>
+            {
+                { ImportExportTantargyfelosztasResource.ImportHeaderNameTtfOraszamKorrekcio, EnumExtensions.GetEnumDisplayNameList<IgenNemEnum>(TanevId) },
+                { ImportExportTantargyfelosztasResource.ImportHeaderNameNemzetisegiOra, EnumExtensions.GetEnumDisplayNameList<IgenNemEnum>(TanevId) }
+            };
+            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>(logicalColumnDictionary);
+
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                var helper = new ImportExportHelper(new DalHandlerConnectionType(ConnectionType, dalHandler));
+
+                dropDownColumnSourceDictionary.Add(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly, helper.GetOsztalyList());
+                dropDownColumnSourceDictionary.Add(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport, helper.GetCsoportList());
+                dropDownColumnSourceDictionary.Add(ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy, helper.GetTantargyList(isFromSzervezet: isFromSzervezet, isSzakkepzo: isSzakkepzo));
+                dropDownColumnSourceDictionary.Add(ImportExportTantargyfelosztasResource.ImportHeaderNameTanar, helper.GetTanarList(true));
+            });
+
+            return dropDownColumnSourceDictionary;
+        }
+    }
+}

Kreta.BusinessLogic/Helpers/ImportExport/TanuloBesorolasImportExportHelper.cs

@@ -0,0 +1,289 @@
+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;
+        }
+    }
+}

Kreta.BusinessLogic/Helpers/ImportExport/TanuloErtekelesMondatbankImportExportHelper.cs

@@ -0,0 +1,339 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.IO;
+using System.Linq;
+using System.Runtime.Caching;
+using Aspose.Cells;
+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;
+using Kreta.Enums.ManualEnums.ImportExport;
+using Kreta.Resources;
+
+namespace Kreta.BusinessLogic.Helpers.ImportExport
+{
+    public class TanuloErtekelesMondatbankImportExportHelper : LogicBase
+    {
+        #region Fields
+
+        private readonly string _importObjectCacheKey;
+
+        #endregion Fields
+
+        #region Properties
+
+        public static Dictionary<int, string> ImportHeaderList => new Dictionary<int, string>
+        {
+            { 00, ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameRovidNev },
+            { 01, ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameSzoveg },
+            { 02, ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameTanuloErtekelesTipus },
+            { 03, ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameEvfolyamTipus },
+            { 04, ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameTantargy }
+        };
+
+        public static Dictionary<int, string> ExportHeaderList => new Dictionary<int, string>(ImportHeaderList);
+
+        public TanuloErtekelesMondatbankImportCo ImportCo
+        {
+            get => (TanuloErtekelesMondatbankImportCo)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 TanuloErtekelesMondatbankImportExportHelper(IConnectionType connectionType) : base(connectionType)
+        {
+            _importObjectCacheKey = $"{nameof(TanuloErtekelesMondatbankImportCo)}_{IntezmenyId}_{FelhasznaloId}_ImportObjectCacheKey";
+        }
+
+        #endregion Constructors
+
+        public void SetImportCo(List<List<string>> importData, int importMuvelet)
+        {
+            TanuloErtekelesMondatbankImportCo importCo = GetImportCoFromImportData(importData);
+            importCo.ImportMuvelet = importMuvelet;
+
+            SetNemImportalhatoSorokByValidation(importCo);
+
+            SetOperationAndNemImportalhatoSorokByOperation(importCo);
+
+            var mainImportJsonItemList = new List<TanuloErtekelesMondatbankImportJsonItemCo>(importCo.MainImportItemList.Select(x => new TanuloErtekelesMondatbankImportJsonItemCo(x, TanevId, IntezmenyId, FelhasznaloId)));
+            importCo.MainImportJsonItemList = mainImportJsonItemList;
+
+            ImportCo = importCo;
+        }
+
+        private static void SetNemImportalhatoSorokByValidation(TanuloErtekelesMondatbankImportCo importCo)
+        {
+            Dictionary<int, List<ValidationResult>> validationResultDictionary = importCo.Validate();
+
+            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
+            foreach (TanuloErtekelesMondatbankImportItemCo 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(TanuloErtekelesMondatbankImportCo importCo)
+        {
+            int importMuvelet = importCo.ImportMuvelet;
+            //NOTE: Azért van szükség Dictionary-re, mert így sokkal gyorsabb a keresés!
+            Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary = GetCompareHashImportItemCompareCoDictionary(importCo.TanuloErtekelesMondatbankCoList);
+            foreach (TanuloErtekelesMondatbankImportItemCo 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...
+                else
+                {
+                    ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                    //NOTE: ...ha az import művelet DeleteAndInsert, akkor Insert, mert töröljük a korábbi elemeket (importált és nem importált) és újra be kell szúrni!
+                    if (importMuvelet == (int)ImportMuveletEnum.DeleteAndInsert)
+                    {
+                        importItem.Operation = (int)ImportItemOperationEnum.Insert;
+                    }
+                    //NOTE: ...ha nincs törlés, akkor...
+                    else
+                    {
+                        //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
+                        if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                        {
+                            importItem.Id = importItemCompareCo.Id;
+                            importItem.Operation = (int)ImportItemOperationEnum.Update;
+                        }
+                        //NOTE: ...ha a művelet nem InsertAndUpdate, akkor hozzá kell adni a nem NemImportalhatoItemList-hez és jelezni, hogy már szerepel az adatbázisban(Insert vagy DeleteAndInsert műveletnél. A DeleteAndInsert csak akkor fut be ide, ha az elem nem importált.)!
+                        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 TanuloErtekelesMondatbankImportCo GetImportCoFromImportData(List<List<string>> importData)
+        {
+            var importCo = new TanuloErtekelesMondatbankImportCo
+            {
+                TanuloErtekelesMondatbankCoList = new TanuloErtekelesMondatbankHelper(ConnectionType).GetTanuloErtekelesMondatbankCoList()
+            };
+
+            int lineNumber = 1;
+            foreach (List<string> importDataRow in importData.Skip(1))
+            {
+                var importItemCo = new TanuloErtekelesMondatbankImportItemCo
+                {
+                    LineNumber = lineNumber,
+
+                    RovidNevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameRovidNev)],
+                    SzovegImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameSzoveg)],
+                    TanuloErtekelesTipusImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameTanuloErtekelesTipus)],
+                    EvfolyamTipusImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameEvfolyamTipus)],
+                    TantargyImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameTantargy)],
+                };
+
+                // NOTE: Az értékelés típus felhasználó által bővíthető, ezért a DB-ből kell lekérdeznünk az értékeket.
+                KeyValuePair<int, string> ertekelesTipus = EnumExtensions.GetAdatszotarDictElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.ErtekelesTipus).SingleOrDefault(x => x.Value == importItemCo.TanuloErtekelesTipusNev);
+                importItemCo.TanuloErtekelesTipusId = !ertekelesTipus.Equals(default(KeyValuePair<int, string>)) ? ertekelesTipus.Key : (int?)null;
+
+                importItemCo.EvfolyamTipusId = EnumExtensions.EnumToDictionary<EvfolyamTipusEnum>(TanevId).SingleOrDefault(x => x.Value == importItemCo.EvfolyamTipusNev).Key.ToNullableInt();
+
+                var tantargyCoList = new TantargyHelper(ConnectionType).GetTantargyCoList();
+                var tantargyNevToCompare = importItemCo.TantargyNev?.ToComparableString();
+                var tantargy = tantargyCoList.SingleOrDefault(x => x.NevComparableString == tantargyNevToCompare);
+                importItemCo.TantargyId = tantargy?.Id;
+
+                if (tantargyNevToCompare == TanuloErtekelesResource.Magatartas.ToComparableString())
+                {
+                    importItemCo.TipusId = (int)ErtMondatbankTipusEnum.Magatartas;
+                }
+                else if (tantargyNevToCompare == TanuloErtekelesResource.Szorgalom.ToComparableString())
+                {
+                    importItemCo.TipusId = (int)ErtMondatbankTipusEnum.Szorgalom;
+                }
+                else
+                {
+                    importItemCo.TipusId = (int)ErtMondatbankTipusEnum.Tantargy;
+                }
+
+                string md5HashInput =
+                    importItemCo.RovidNev?.ToComparableString() +
+                    importItemCo.Szoveg?.ToComparableString() +
+                    importItemCo.TanuloErtekelesTipusNev?.ToComparableString() +
+                    importItemCo.EvfolyamTipusNev?.ToComparableString() +
+                    importItemCo.TantargyNev?.ToComparableString();
+                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                importCo.MainImportItemList.Add(importItemCo);
+
+                lineNumber++;
+            }
+
+            return importCo;
+        }
+
+        public MemoryStream GetTemplate(bool isSzakkepzo = false, bool isFromSzervezet = false)
+        {
+            var dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary(isSzakkepzo: isSzakkepzo, isFromSzervezet: isFromSzervezet);
+
+            MemoryStream memoryStream = ImportExportHelper.GetTemplate(ImportExportTanuloErtekelesMondatbankResource.ImportDefaultSheetName, ImportHeaderList, dropDownColumnSourceDictionary);
+
+            return memoryStream;
+        }
+
+        public MemoryStream GetExport(bool isSzakkepzo = false)
+        {
+            var dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary(isSzakkepzo: isSzakkepzo);
+
+            List<TanuloErtekelesMondatbankItemCo> coList = new TanuloErtekelesMondatbankHelper(ConnectionType).GetTanuloErtekelesMondatbankCoList();
+            using (var workbook = new Workbook())
+            {
+                var worksheet = ImportExportHelper.GetWorksheetsWithDropDownFormula(workbook, ImportExportTanuloErtekelesMondatbankResource.ImportDefaultSheetName, ExportHeaderList, dropDownColumnSourceDictionary);
+
+                var columnToWrapIndexList = new List<int>();
+                int rowNumber = 1;
+                foreach (TanuloErtekelesMondatbankItemCo co in coList.OrderBy(d => d.RovidNev).ThenBy(d => d.Szoveg))
+                {
+                    worksheet.Cells[rowNumber, ExportHeaderList.GetKeyByUniqueValue(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameRovidNev)].Value = co.RovidNev;
+
+                    int szovegCellColumnIndex = ExportHeaderList.GetKeyByUniqueValue(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameSzoveg);
+                    Cell szovegCell = worksheet.Cells[rowNumber, szovegCellColumnIndex];
+                    szovegCell.HtmlString = co.Szoveg;
+                    szovegCell.SetTextWrap();
+                    columnToWrapIndexList.Add(szovegCellColumnIndex);
+
+                    worksheet.Cells[rowNumber, ExportHeaderList.GetKeyByUniqueValue(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameTanuloErtekelesTipus)].Value = co.TanuloErtekelesTipusNev;
+                    worksheet.Cells[rowNumber, ExportHeaderList.GetKeyByUniqueValue(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameEvfolyamTipus)].Value = co.EvfolyamTipusNev;
+                    worksheet.Cells[rowNumber, ExportHeaderList.GetKeyByUniqueValue(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameTantargy)].Value = co.TantargyNev;
+
+                    rowNumber++;
+                }
+
+                var sheetCodeNameAndColumnsToWrapIndexDictionary = new Dictionary<string, List<int>>
+                {
+                    { workbook.Worksheets[0].CodeName, columnToWrapIndexList }
+                };
+                MemoryStream memoryStream = SimpleExportLogic.GetWorkbookMemoryStream(workbook, sheetCodeNameAndColumnsToWrapIndexDictionary);
+                return memoryStream;
+            }
+        }
+
+        public MemoryStream GetNemImportalhatoSorokExport()
+        {
+            using (var workbook = new Workbook())
+            {
+                var worksheet = ImportExportHelper.GetWorksheetsWithDropDownFormula(workbook, ImportExportTanuloErtekelesMondatbankResource.ImportDefaultSheetName, ImportHeaderList);
+
+                var columnToWrapIndexList = new List<int>();
+                int rowNumber = 1;
+                foreach (TanuloErtekelesMondatbankImportItemCo co in ImportCo.NemImportalhatoItemList)
+                {
+                    worksheet.Cells[rowNumber, ExportHeaderList.GetKeyByUniqueValue(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameRovidNev)].Value = co.RovidNev;
+
+                    int szovegCellColumnIndex = ExportHeaderList.GetKeyByUniqueValue(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameSzoveg);
+                    Cell szovegCell = worksheet.Cells[rowNumber, szovegCellColumnIndex];
+                    szovegCell.Value = co.Szoveg;
+                    szovegCell.SetTextWrap();
+                    columnToWrapIndexList.Add(szovegCellColumnIndex);
+
+                    worksheet.Cells[rowNumber, ExportHeaderList.GetKeyByUniqueValue(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameTanuloErtekelesTipus)].Value = co.TanuloErtekelesTipusNev;
+                    worksheet.Cells[rowNumber, ExportHeaderList.GetKeyByUniqueValue(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameEvfolyamTipus)].Value = co.EvfolyamTipusNev;
+                    worksheet.Cells[rowNumber, ExportHeaderList.GetKeyByUniqueValue(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameTantargy)].Value = co.TantargyNev;
+
+                    int errorCellColumnIndex = ImportHeaderList.Count;
+                    Cell errorCell = worksheet.Cells[rowNumber, ImportHeaderList.Count];
+                    errorCell.Value = string.Join(Environment.NewLine, co.ErrorList);
+                    errorCell.SetTextWrap();
+                    columnToWrapIndexList.Add(errorCellColumnIndex);
+
+                    rowNumber++;
+                }
+
+                var sheetCodeNameAndColumnsToWrapIndexDictionary = new Dictionary<string, List<int>>
+                {
+                    { workbook.Worksheets[0].CodeName, columnToWrapIndexList }
+                };
+                MemoryStream memoryStream = SimpleExportLogic.GetWorkbookMemoryStream(workbook, sheetCodeNameAndColumnsToWrapIndexDictionary);
+                return memoryStream;
+            }
+        }
+
+        private Dictionary<string, ImportItemCompareCo> GetCompareHashImportItemCompareCoDictionary(List<TanuloErtekelesMondatbankItemCo> coList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (TanuloErtekelesMondatbankItemCo co in coList)
+            {
+                string md5HashInput =
+                    co.RovidNevComparableString +
+                    co.SzovegComparableString +
+                    co.TanuloErtekelesTipusNevComparableString +
+                    co.EvfolyamTipusNevComparableString +
+                    co.TantargyNevComparableString;
+                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;
+        }
+
+        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary(bool isSzakkepzo = false, bool isFromSzervezet = false)
+        {
+            //NOTE: Create dropdown lists
+            var logicalColumnDictionary = new Dictionary<string, IList<string>>();
+            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>(logicalColumnDictionary);
+
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                var helper = new ImportExportHelper(new DalHandlerConnectionType(ConnectionType, dalHandler));
+
+                dropDownColumnSourceDictionary.Add(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameTanuloErtekelesTipus, helper.GetTanuloErtekelesTipusList());
+                dropDownColumnSourceDictionary.Add(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameEvfolyamTipus, helper.GetEvfolyamTipusList());
+                dropDownColumnSourceDictionary.Add(ImportExportTanuloErtekelesMondatbankResource.ImportHeaderNameTantargy, helper.GetTantargyList(true, isFromSzervezet: isFromSzervezet, isSzakkepzo: isSzakkepzo));
+            });
+
+            return dropDownColumnSourceDictionary;
+        }
+    }
+}

Kreta.BusinessLogic/Helpers/ImportExport/TanuloKifirImportExportHelper.cs

@@ -0,0 +1,502 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Data;
+using System.IO;
+using System.Linq;
+using System.Runtime.Caching;
+using Aspose.Cells;
+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.Enums;
+using Kreta.Enums.ManualEnums.ImportExport;
+using Kreta.Framework.Util;
+using Kreta.Resources;
+using Newtonsoft.Json;
+using Cache = Kreta.Core.Cache;
+
+namespace Kreta.BusinessLogic.Helpers.ImportExport
+{
+    public class TanuloKifirImportExportHelper : LogicBase
+    {
+        #region Fields
+
+        private readonly string _importObjectCacheKey;
+
+        #endregion Fields
+
+        #region Properties
+
+        public static Dictionary<int, string> ImportHeaderList => new Dictionary<int, string>
+        {
+            { 00, ImportExportTanuloKifirResource.ImportHeaderNameNev },
+            { 01, ImportExportTanuloKifirResource.ImportHeaderNameOktatasiAzonosito },
+            { 02, ImportExportTanuloKifirResource.ImportHeaderNameKilencedikEvfolyamnalAlacsonyabb },
+            { 03, ImportExportTanuloKifirResource.ImportHeaderNameSzuletesiHely },
+            { 04, ImportExportTanuloKifirResource.ImportHeaderNameSzuletesiDatum },
+            { 05, ImportExportTanuloKifirResource.ImportHeaderNameAnyjaNeve },
+            { 06, ImportExportTanuloKifirResource.ImportHeaderNameAllandoLakcimIranyitoszam },
+            { 07, ImportExportTanuloKifirResource.ImportHeaderNameAllandoLakcimTelepules },
+            { 08, ImportExportTanuloKifirResource.ImportHeaderNameAllandoLakcimKozterulet },
+            { 09, ImportExportTanuloKifirResource.ImportHeaderNameErtesitesiCimNev },
+            { 10, ImportExportTanuloKifirResource.ImportHeaderNameErtesitesiCimIranyitoszam },
+            { 11, ImportExportTanuloKifirResource.ImportHeaderNameErtesitesiCimTelepules },
+            { 12, ImportExportTanuloKifirResource.ImportHeaderNameErtesitesiCimKozterulet },
+            { 13, ImportExportTanuloKifirResource.ImportHeaderNameAllampolgarsag },
+            { 14, ImportExportTanuloKifirResource.ImportHeaderNameEmailCim },
+            { 15, ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaOmKodja },
+            { 16, ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaNeve },
+            { 17, ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaIranyitoszam },
+            { 18, ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaCim },
+            { 19, ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaTelepules },
+            { 20, ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaTelefonszam },
+            { 21, ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaEmailCim },
+            { 22, ImportExportTanuloKifirResource.ImportHeaderNameFelveteltNyertTanulmanyiKeruletNeve },
+            { 23, ImportExportTanuloKifirResource.ImportHeaderNameFelveteltNyertTanulmanyiKeruletKodszama },
+            { 24, ImportExportTanuloKifirResource.ImportHeaderNameFelveteltNyertTanulmanyiKeruletSzovege },
+            { 25, ImportExportTanuloKifirResource.ImportHeaderNameNemNyertFelveteltElobbreNertFelvetelt },
+            { 26, ImportExportTanuloKifirResource.ImportHeaderNameNemNyertFelveteltBetelt },
+            { 27, ImportExportTanuloKifirResource.ImportHeaderNameNemNyertFelveteltElutasitas }
+        };
+
+        public TanuloKifirImportCo ImportCo
+        {
+            get => (TanuloKifirImportCo)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 TanuloKifirImportExportHelper(IConnectionType connectionType) : base(connectionType)
+        {
+            _importObjectCacheKey = $"{nameof(TanuloKifirImportCo)}_{IntezmenyId}_{FelhasznaloId}_ImportObjectCacheKey";
+        }
+
+        #endregion Constructors
+
+        public void SetImportCo(List<List<string>> importData, int importMuvelet)
+        {
+            TanuloKifirImportCo importCo = GetImportCoFromImportData(importData);
+            importCo.ImportMuvelet = importMuvelet;
+
+            SetNemImportalhatoSorokByValidation(importCo);
+
+            List<TanuloItemCo> coList = importCo.TanuloCoList;
+            //NOTE: Azért van szükség Dictionary-kre, mert így sokkal gyorsabb a keresés!
+            Dictionary<string, ImportItemCompareCo> cimCompareHashImportItemCompareCoDictionary = GetCimCompareHashImportItemCompareCoDictionary(coList);
+            Dictionary<string, ImportItemCompareCo> emailCompareHashImportItemCompareCoDictionary = GetEmailCompareHashImportItemCompareCoDictionary(coList);
+            Dictionary<string, ImportItemCompareCo> tanuloKifirCompareHashImportItemCompareCoDictionary = GetTanuloKifirCompareHashImportItemCompareCoDictionary(coList);
+            foreach (TanuloKifirImportItemCo importItem in importCo.MainImportItemList)
+            {
+                SetOperationAllandoLakcim(importItem, cimCompareHashImportItemCompareCoDictionary, importCo.ImportMuvelet);
+                SetOperationIdeiglenesLakcim(importItem, cimCompareHashImportItemCompareCoDictionary, importCo.ImportMuvelet);
+                if (!string.IsNullOrWhiteSpace(importItem.EmailCim))
+                {
+                    SetOperationEmail(importItem, emailCompareHashImportItemCompareCoDictionary);
+                }
+
+                SetOperationTanuloKifir(importItem, tanuloKifirCompareHashImportItemCompareCoDictionary, importCo);
+            }
+
+            //NOTE: Azokat a sorokat, amelyek bekerültek a NemImportalhatoItemList-be, azokat kiveszzük a MainImportItemList-ből!
+            importCo.MainImportItemList.RemoveRange(importCo.NemImportalhatoItemList);
+
+            var cimImportJsonItemList = new List<CimKifirImportJsonItemCo>();
+            var emailImportJsonItemList = new List<EmailKifirImportJsonItemCo>();
+            var tanuloImportJsonItemList = new List<TanuloKifirImportJsonItemCo>();
+            var tantervId = new TantervHelper(ConnectionType).GetAktivTantervDataSet().Tables[0].AsEnumerable().Select(x => SDAConvert.ToInt32(x["ID"])).Max();
+            var mainImportJsonItemList = new List<FelhasznaloKifirImportJsonItemCo>();
+            foreach (TanuloKifirImportItemCo importItem in importCo.MainImportItemList)
+            {
+                cimImportJsonItemList.Add(new CimKifirImportJsonItemCo(importItem, (int)CimTipusEnum.allando_lakcim, TanevId, IntezmenyId, FelhasznaloId));
+                cimImportJsonItemList.Add(new CimKifirImportJsonItemCo(importItem, (int)CimTipusEnum.ideiglenes_lakcim, TanevId, IntezmenyId, FelhasznaloId));
+                if (!string.IsNullOrWhiteSpace(importItem.EmailCim) &&
+                    importItem.OperationEmail == (int)ImportItemOperationEnum.Insert)
+                {
+                    emailImportJsonItemList.Add(new EmailKifirImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
+                }
+
+                tanuloImportJsonItemList.Add(new TanuloKifirImportJsonItemCo(importItem, tantervId, TanevId, IntezmenyId, FelhasznaloId));
+                mainImportJsonItemList.Add(new FelhasznaloKifirImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
+            }
+
+            importCo.CimKifirImportJsonItemList = cimImportJsonItemList;
+            importCo.EmailKifirImportJsonItemList = emailImportJsonItemList;
+            importCo.TanuloKifirImportJsonItemList = tanuloImportJsonItemList;
+            importCo.MainImportJsonItemList = mainImportJsonItemList;
+
+            ImportCo = importCo;
+        }
+
+        private static void SetNemImportalhatoSorokByValidation(TanuloKifirImportCo importCo)
+        {
+            Dictionary<int, List<ValidationResult>> validationResultDictionary = importCo.Validate();
+
+            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
+            foreach (TanuloKifirImportItemCo 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 static void SetOperationTanuloKifir(TanuloKifirImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, TanuloKifirImportCo importCo)
+        {
+            int importMuvelet = importCo.ImportMuvelet;
+            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...
+            else
+            {
+                ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
+                if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                {
+                    importItem.Id = importItemCompareCo.Id;
+                    importItem.Operation = (int)ImportItemOperationEnum.Update;
+                }
+                //NOTE: ...ha a művelet nem InsertAndUpdate, akkor hozzá kell adni a nem NemImportalhatoItemList-hez és jelezni, hogy már szerepel az adatbázisban(Insert műveletnél)!
+                else
+                {
+                    importItem.ErrorList.Add(ImportExportCommonResource.NemImportalhatoMertMarSzerepelAzAdatbazisban);
+                    importCo.NemImportalhatoItemList.Add(importItem);
+                }
+            }
+        }
+
+        private static void SetOperationAllandoLakcim(TanuloKifirImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int importMuvelet)
+        {
+            var compareHash = importItem.CompareHashAllandoLakcim;
+            //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
+            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+            {
+                importItem.OperationAllandoLakcim = (int)ImportItemOperationEnum.Insert;
+            }
+            //NOTE: Ha találtunk egyezést, akkor...
+            else
+            {
+                ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
+                if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                {
+                    importItem.AllandoLakcimId = importItemCompareCo.Id;
+                    importItem.OperationAllandoLakcim = (int)ImportItemOperationEnum.Update;
+                }
+            }
+        }
+
+        private static void SetOperationIdeiglenesLakcim(TanuloKifirImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int importMuvelet)
+        {
+            var compareHash = importItem.CompareHashIdeiglenesLakcim;
+            //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
+            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+            {
+                importItem.OperationIdeiglenesLakcim = (int)ImportItemOperationEnum.Insert;
+            }
+            //NOTE: Ha találtunk egyezést, akkor...
+            else
+            {
+                ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
+                if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                {
+                    importItem.IdeiglenesLakcimId = importItemCompareCo.Id;
+                    importItem.OperationIdeiglenesLakcim = (int)ImportItemOperationEnum.Update;
+                }
+            }
+        }
+
+        private static void SetOperationEmail(TanuloKifirImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary)
+        {
+            var compareHash = importItem.CompareHashEmail;
+            //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
+            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+            {
+                importItem.OperationEmail = (int)ImportItemOperationEnum.Insert;
+            }
+        }
+
+        private Dictionary<string, ImportItemCompareCo> GetTanuloKifirCompareHashImportItemCompareCoDictionary(List<TanuloItemCo> tanuloItemCoList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (TanuloItemCo co in tanuloItemCoList)
+            {
+                var md5HashInput =
+                    $"{co.FelhasznaloVezeteknevComparableString} {co.FelhasznaloKeresztnevComparableString}" +
+                    co.FelhasznaloSzuletesiHelyComparableString +
+                    co.FelhasznaloSzuletesiIdoComparableString +
+                    co.FelhasznaloOktatasiAzonositoComparableString;
+
+                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;
+        }
+
+        private Dictionary<string, ImportItemCompareCo> GetCimCompareHashImportItemCompareCoDictionary(List<TanuloItemCo> tanuloItemCoList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (TanuloItemCo tanuloItemCo in tanuloItemCoList)
+            {
+                foreach (CimItemCo cimItemCo in tanuloItemCo.CimList)
+                {
+                    var md5HashInput =
+                        $"{tanuloItemCo.FelhasznaloVezeteknevComparableString} {tanuloItemCo.FelhasznaloKeresztnevComparableString}" +
+                        tanuloItemCo.FelhasznaloSzuletesiHelyComparableString +
+                        tanuloItemCo.FelhasznaloSzuletesiIdoComparableString +
+                        tanuloItemCo.FelhasznaloOktatasiAzonositoComparableString +
+                        cimItemCo.TipusId;
+
+                    string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                    var importItemCompareCo = new ImportItemCompareCo
+                    {
+                        Id = cimItemCo.Id,
+                        CompareHash = compareHash
+                    };
+                    //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;
+        }
+
+        private Dictionary<string, ImportItemCompareCo> GetEmailCompareHashImportItemCompareCoDictionary(List<TanuloItemCo> tanuloItemCoList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (TanuloItemCo tanuloItemCo in tanuloItemCoList)
+            {
+                foreach (EmailItemCo emailItemCo in tanuloItemCo.EmailList)
+                {
+                    var md5HashInput =
+                        $"{tanuloItemCo.FelhasznaloVezeteknevComparableString} {tanuloItemCo.FelhasznaloKeresztnevComparableString}" +
+                        tanuloItemCo.FelhasznaloSzuletesiHelyComparableString +
+                        tanuloItemCo.FelhasznaloSzuletesiIdoComparableString +
+                        tanuloItemCo.FelhasznaloOktatasiAzonositoComparableString +
+                        emailItemCo.EmailCimComparableString;
+
+                    string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                    var importItemCompareCo = new ImportItemCompareCo
+                    {
+                        Id = emailItemCo.Id,
+                        CompareHash = compareHash
+                    };
+                    //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;
+        }
+
+        private TanuloKifirImportCo GetImportCoFromImportData(List<List<string>> importData)
+        {
+            var importCo = new TanuloKifirImportCo
+            {
+                TanuloCoList = new TanuloHelper(ConnectionType).GetTanuloCoList()
+            };
+
+            IDictionary<int, string> kozteruletJellegIdNevDictionary = ((int)GeneratedAdatszotarTipusEnum.KozteruletJelleg).GetItemsByType(TanevId, true).ToDictionary(x => x.Id, x => x.Name);
+            kozteruletJellegIdNevDictionary.Remove((int)KozteruletJellegEnum.Ures);
+
+            int lineNumber = 1;
+            foreach (List<string> importDataRow in importData.Skip(1))
+            {
+                var allandoLakcimKozteruletImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAllandoLakcimKozterulet)];
+                var ertesitesiCimKozteruletImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameErtesitesiCimKozterulet)];
+                var importItemCo = new TanuloKifirImportItemCo(TanevId)
+                {
+                    LineNumber = lineNumber,
+
+                    NevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameNev)],
+                    OktatasiAzonositoImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameOktatasiAzonosito)],
+                    SzuletesiHelyImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameSzuletesiHely)],
+                    SzuletesiDatumImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameSzuletesiDatum)],
+                    AnyjaNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAnyjaNeve)],
+                    AllandoLakcimIranyitoszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAllandoLakcimIranyitoszam)],
+                    AllandoLakcimTelepulesImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAllandoLakcimTelepules)],
+                    AllandoLakcimKozteruletImportData = allandoLakcimKozteruletImportData,
+                    ErtesitesiCimIranyitoszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameErtesitesiCimIranyitoszam)],
+                    ErtesitesiCimTelepulesImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameErtesitesiCimTelepules)],
+                    ErtesitesiCimKozteruletImportData = ertesitesiCimKozteruletImportData,
+                    AllampolgarsagImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAllampolgarsag)],
+                    EmailCimImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameEmailCim)],
+
+                    KilencedikEvfolyamnalAlacsonyabbImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameKilencedikEvfolyamnalAlacsonyabb)],
+                    ErtesitesiCimNevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameErtesitesiCimNev)],
+                    AltalanosIskolaOmKodjaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaOmKodja)],
+                    AltalanosIskolaNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaNeve)],
+                    AltalanosIskolaIranyitoszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaIranyitoszam)],
+                    AltalanosIskolaCimImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaCim)],
+                    AltalanosIskolaTelepulesImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaTelepules)],
+                    AltalanosIskolaTelefonszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaTelefonszam)],
+                    AltalanosIskolaEmailCimImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaEmailCim)],
+                    FelveteltNyertTanulmanyiKeruletNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameFelveteltNyertTanulmanyiKeruletNeve)],
+                    FelveteltNyertTanulmanyiKeruletKodszamaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameFelveteltNyertTanulmanyiKeruletKodszama)],
+                    FelveteltNyertTanulmanyiKeruletSzovegeImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameFelveteltNyertTanulmanyiKeruletSzovege)],
+                    NemNyertFelveteltElutasitasImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameNemNyertFelveteltElutasitas)],
+                    NemNyertFelveteltBeteltImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameNemNyertFelveteltBetelt)],
+                    NemNyertFelveteltElobbreNertFelveteltImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameNemNyertFelveteltElobbreNertFelvetelt)],
+
+                    AllandoLakcimSplittedCim = TanuloKifirImportItemCo.GetTanuloKifirSplittedCim(kozteruletJellegIdNevDictionary, allandoLakcimKozteruletImportData),
+                    IdeiglenesLakcimSplittedCim = TanuloKifirImportItemCo.GetTanuloKifirSplittedCim(kozteruletJellegIdNevDictionary, ertesitesiCimKozteruletImportData)
+                };
+
+                string allandoLakcimMd5HashInput =
+                    $"{importItemCo.Vezeteknev?.ToComparableString()} {importItemCo.Keresztnev?.ToComparableString()}" +
+                    importItemCo.SzuletesiHely?.ToComparableString() +
+                    importItemCo.SzuletesiIdoString?.ToComparableString() +
+                    importItemCo.OktatasiAzonosito?.ToComparableString() +
+                    (int)CimTipusEnum.allando_lakcim;
+                importItemCo.CompareHashAllandoLakcim = ImportExportHelper.GetMd5Hash(allandoLakcimMd5HashInput);
+
+                string ideiglenesLakcimMd5HashInput =
+                    $"{importItemCo.Vezeteknev?.ToComparableString()} {importItemCo.Keresztnev?.ToComparableString()}" +
+                    importItemCo.SzuletesiHely?.ToComparableString() +
+                    importItemCo.SzuletesiIdoString?.ToComparableString() +
+                    importItemCo.OktatasiAzonosito?.ToComparableString() +
+                    (int)CimTipusEnum.ideiglenes_lakcim;
+                importItemCo.CompareHashIdeiglenesLakcim = ImportExportHelper.GetMd5Hash(ideiglenesLakcimMd5HashInput);
+
+                string emailMd5HashInput =
+                    $"{importItemCo.Vezeteknev?.ToComparableString()} {importItemCo.Keresztnev?.ToComparableString()}" +
+                    importItemCo.SzuletesiHely?.ToComparableString() +
+                    importItemCo.SzuletesiIdoString?.ToComparableString() +
+                    importItemCo.OktatasiAzonosito?.ToComparableString() +
+                    importItemCo.EmailCim?.ToComparableString();
+                importItemCo.CompareHashEmail = ImportExportHelper.GetMd5Hash(emailMd5HashInput);
+
+                string tanuloKifirMd5HashInput =
+                    $"{importItemCo.Vezeteknev?.ToComparableString()} {importItemCo.Keresztnev?.ToComparableString()}" +
+                    importItemCo.SzuletesiHely?.ToComparableString() +
+                    importItemCo.SzuletesiIdoString?.ToComparableString() +
+                    importItemCo.OktatasiAzonosito?.ToComparableString();
+                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(tanuloKifirMd5HashInput);
+
+                importCo.MainImportItemList.Add(importItemCo);
+
+                lineNumber++;
+            }
+
+            return importCo;
+        }
+
+        public MemoryStream GetNemImportalhatoSorokExport()
+        {
+            var dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary();
+
+            using (var workbook = new Workbook())
+            {
+                var worksheet = ImportExportHelper.GetWorksheetsWithDropDownFormula(workbook, ImportExportTanuloKifirResource.ImportDefaultSheetName, ImportHeaderList, dropDownColumnSourceDictionary);
+
+                int rowNumber = 1;
+                foreach (TanuloKifirImportItemCo co in ImportCo.NemImportalhatoItemList)
+                {
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameNev)].Value = co.NevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameOktatasiAzonosito)].Value = co.OktatasiAzonositoImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameKilencedikEvfolyamnalAlacsonyabb)].Value = co.KilencedikEvfolyamnalAlacsonyabbImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameSzuletesiHely)].Value = co.SzuletesiHelyImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameSzuletesiDatum)].Value = co.SzuletesiDatumImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAnyjaNeve)].Value = co.AnyjaNeveImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAllandoLakcimIranyitoszam)].Value = co.AllandoLakcimIranyitoszamImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAllandoLakcimTelepules)].Value = co.AllandoLakcimTelepulesImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAllandoLakcimKozterulet)].Value = co.AllandoLakcimKozteruletImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameErtesitesiCimNev)].Value = co.ErtesitesiCimNevImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameErtesitesiCimIranyitoszam)].Value = co.ErtesitesiCimIranyitoszamImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameErtesitesiCimTelepules)].Value = co.ErtesitesiCimTelepulesImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameErtesitesiCimKozterulet)].Value = co.ErtesitesiCimKozteruletImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAllampolgarsag)].Value = co.AllampolgarsagImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameEmailCim)].Value = co.EmailCimImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaOmKodja)].Value = co.AltalanosIskolaOmKodjaImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaNeve)].Value = co.AltalanosIskolaNeveImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaIranyitoszam)].Value = co.AltalanosIskolaIranyitoszamImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaCim)].Value = co.AltalanosIskolaCimImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaTelepules)].Value = co.AltalanosIskolaTelepulesImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaTelefonszam)].Value = co.AltalanosIskolaTelefonszamImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameAltalanosIskolaEmailCim)].Value = co.AltalanosIskolaEmailCimImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameFelveteltNyertTanulmanyiKeruletNeve)].Value = co.FelveteltNyertTanulmanyiKeruletNeveImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameFelveteltNyertTanulmanyiKeruletKodszama)].Value = co.FelveteltNyertTanulmanyiKeruletKodszamaImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameFelveteltNyertTanulmanyiKeruletSzovege)].Value = co.FelveteltNyertTanulmanyiKeruletSzovegeImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameNemNyertFelveteltElutasitas)].Value = co.NemNyertFelveteltElutasitasImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameNemNyertFelveteltBetelt)].Value = co.NemNyertFelveteltBeteltImportData;
+                    worksheet.Cells[rowNumber, ImportHeaderList.GetKeyByUniqueValue(ImportExportTanuloKifirResource.ImportHeaderNameNemNyertFelveteltElobbreNertFelvetelt)].Value = co.NemNyertFelveteltElobbreNertFelveteltImportData;
+
+                    Cell errorCell = worksheet.Cells[rowNumber, ImportHeaderList.Count];
+                    errorCell.Value = string.Join(Environment.NewLine, co.ErrorList);
+                    errorCell.SetTextWrap();
+
+                    rowNumber++;
+                }
+
+                var sheetCodeNameAndColumnsToWrapIndexDictionary = new Dictionary<string, List<int>>
+                {
+                    { workbook.Worksheets[0].CodeName, new List<int> { ImportHeaderList.Count } }
+                };
+                MemoryStream memoryStream = SimpleExportLogic.GetWorkbookMemoryStream(workbook, sheetCodeNameAndColumnsToWrapIndexDictionary);
+                return memoryStream;
+            }
+        }
+
+        public void Import(object importJsonObject)
+        {
+            string importJson = JsonConvert.SerializeObject(importJsonObject);
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                dalHandler.ImportExportDal().TanuloKifirImport(IntezmenyId, TanevId, FelhasznaloId, importJson);
+                dalHandler.Felhasznalo().UpdateAllEgyediAzonosito();
+            });
+        }
+
+        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary()
+        {
+            //NOTE: Create dropdown lists
+            var logicalColumnDictionary = new Dictionary<string, IList<string>>();
+            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>(logicalColumnDictionary);
+
+            return dropDownColumnSourceDictionary;
+        }
+    }
+}

Kreta.BusinessLogic/Helpers/ImportExport/TanulokElerhetosegiAdataikImportExportHelper.cs

@@ -0,0 +1,355 @@
+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;
+using Kreta.Enums.ManualEnums.ImportExport;
+using Kreta.Resources;
+using Newtonsoft.Json;
+
+namespace Kreta.BusinessLogic.Helpers.ImportExport
+{
+    public class TanulokElerhetosegiAdataikImportExportHelper : LogicBase
+    {
+        #region Fields
+
+        private readonly string _importObjectCacheKey;
+
+        #endregion Fields
+
+        #region Properties
+
+        public static Dictionary<int, string> ImportHeaderList => new Dictionary<int, string>
+        {
+            { 00, ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameTanuloNeve },
+            { 01, ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameTanuloOktatasiAzonosito },
+            { 02, ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameTanuloTelefonszam },
+            { 03, ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameTelefonszamAlapertelmezett },
+            { 04, ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameTelefonszamTipusa },
+            { 05, ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameTanuloEmailCim },
+            { 06, ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameEmailAlapertelmezett },
+            { 07, ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameEmailTipus }
+        };
+
+        public TanulokElerhetosegiAdataikImportCo ImportCo
+        {
+            get => (TanulokElerhetosegiAdataikImportCo)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 TanulokElerhetosegiAdataikImportExportHelper(IConnectionType connectionType) : base(connectionType)
+        {
+            _importObjectCacheKey = $"{nameof(TanulokElerhetosegiAdataikImportCo)}_{IntezmenyId}_{FelhasznaloId}_ImportObjectCacheKey";
+        }
+
+        #endregion Constructors
+
+        public void SetImportCo(List<List<string>> importData, int importMuvelet, bool isSzakkepzoIntezmeny)
+        {
+            TanulokElerhetosegiAdataikImportCo importCo = GetImportCoFromImportData(importData, isSzakkepzoIntezmeny);
+            importCo.ImportMuvelet = importMuvelet;
+
+            SetNemImportalhatoSorokByValidation(importCo);
+
+            List<TanuloItemCo> coList = importCo.TanuloCoList;
+            Dictionary<string, ImportItemCompareCo> telefonCompareHashImportItemCompareCoDictionary = GetTelefonCompareHashImportItemCompareCoDictionary(coList);
+            Dictionary<string, ImportItemCompareCo> emailCompareHashImportItemCompareCoDictionary = GetEmailCompareHashImportItemCompareCoDictionary(coList);
+            foreach (TanulokElerhetosegiAdataikImportItemCo importItem in importCo.MainImportItemList)
+            {
+                if (!string.IsNullOrWhiteSpace(importItem.Telefonszam))
+                {
+                    SetOperationTelefon(importItem, telefonCompareHashImportItemCompareCoDictionary, importCo.ImportMuvelet);
+                }
+
+                if (!string.IsNullOrWhiteSpace(importItem.EmailCim))
+                {
+                    SetOperationEmail(importItem, emailCompareHashImportItemCompareCoDictionary, importCo.ImportMuvelet);
+                }
+            }
+
+            importCo.MainImportItemList.RemoveRange(importCo.NemImportalhatoItemList);
+            var telefonImportJsonItemList = new List<TelefonTanuloImportJsonItemCo>();
+            var emailImportJsonItemList = new List<EmailTanuloImportJsonItemCo>();
+            foreach (TanulokElerhetosegiAdataikImportItemCo importItem in importCo.MainImportItemList)
+            {
+                if (!string.IsNullOrWhiteSpace(importItem.Telefonszam))
+                {
+                    telefonImportJsonItemList.Add(new TelefonTanuloImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
+                }
+
+                if (!string.IsNullOrWhiteSpace(importItem.EmailCim))
+                {
+                    emailImportJsonItemList.Add(new EmailTanuloImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
+                }
+            }
+
+            importCo.TelefonTanuloImportJsonItemList = telefonImportJsonItemList;
+            importCo.EmailTanuloImportJsonItemList = emailImportJsonItemList;
+
+            ImportCo = importCo;
+        }
+
+        private static void SetNemImportalhatoSorokByValidation(TanulokElerhetosegiAdataikImportCo importCo)
+        {
+            Dictionary<int, List<ValidationResult>> validationResultDictionary = importCo.Validate();
+
+            foreach (TanulokElerhetosegiAdataikImportItemCo 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);
+            }
+
+            importCo.MainImportItemList.RemoveRange(importCo.NemImportalhatoItemList);
+        }
+
+        private static void SetOperationTelefon(TanulokElerhetosegiAdataikImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int importMuvelet)
+        {
+            var compareHash = importItem.CompareHashTelefon;
+            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+            {
+                importItem.OperationTelefon = (int)ImportItemOperationEnum.Insert;
+            }
+            else
+            {
+                ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                {
+                    importItem.TelefonId = importItemCompareCo.Id;
+                    importItem.OperationTelefon = (int)ImportItemOperationEnum.Update;
+                }
+            }
+        }
+
+        private static void SetOperationEmail(TanulokElerhetosegiAdataikImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int importMuvelet)
+        {
+            var compareHash = importItem.CompareHashEmail;
+            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+            {
+                importItem.OperationEmail = (int)ImportItemOperationEnum.Insert;
+            }
+            else
+            {
+                ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                {
+                    importItem.EmailId = importItemCompareCo.Id;
+                    importItem.OperationEmail = (int)ImportItemOperationEnum.Update;
+                }
+            }
+        }
+
+        private TanulokElerhetosegiAdataikImportCo GetImportCoFromImportData(List<List<string>> importData, bool isSzakkepzoIntezmeny)
+        {
+            var importCo = new TanulokElerhetosegiAdataikImportCo
+            {
+                TanuloCoList = new TanuloHelper(ConnectionType).GetTanuloCoList()
+            };
+
+            var lineNumber = 1;
+            foreach (var importDataRow in importData.Skip(1))
+            {
+                var importItemCo = new TanulokElerhetosegiAdataikImportItemCo(TanevId, isSzakkepzoIntezmeny)
+                {
+                    LineNumber = lineNumber,
+                    TanuloNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameTanuloNeve)],
+                    TanuloOktatasiAzonositoImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameTanuloOktatasiAzonosito)],
+                    TanuloTelefonszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameTanuloTelefonszam)],
+                    TelefonszamAlapertelmezettImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameTelefonszamAlapertelmezett)],
+                    TelefonszamTipusaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameTelefonszamTipusa)],
+                    TanuloEmailCimImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameTanuloEmailCim)],
+                    EmailAlapertelmezettImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameEmailAlapertelmezett)],
+                    EmailTipusImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameEmailTipus)]
+                };
+
+                importItemCo.FelhasznaloId = importCo.TanuloCoList.FirstOrDefault(x =>
+                    x.FelhasznaloNyomtatasiNevComparableString == importItemCo.TanuloNeveImportData?.ToComparableString() &&
+                    x.FelhasznaloOktatasiAzonositoComparableString == importItemCo.FelhasznaloOktatasiAzonosito?.ToComparableString())?.Id;
+
+                var telefonMd5HashInput = importItemCo.FelhasznaloId.ToString() + importItemCo.Telefonszam?.ToComparableString();
+                importItemCo.CompareHashTelefon = ImportExportHelper.GetMd5Hash(telefonMd5HashInput);
+
+                var emailMd5HashInput = importItemCo.FelhasznaloId.ToString() + importItemCo.EmailCim?.ToComparableString();
+                importItemCo.CompareHashEmail = ImportExportHelper.GetMd5Hash(emailMd5HashInput);
+
+                var tanuloMd5HashInput = importItemCo.FelhasznaloId.ToString();
+                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(tanuloMd5HashInput);
+
+                if (importItemCo.FelhasznaloId.IsEntityId())
+                {
+                    var tanuloHelper = new TanuloHelper(ConnectionType);
+                    importItemCo.IsVanAlapertelmezettEmail = tanuloHelper.IsTanulonakVanAlapertelmezettEmailCime(importItemCo.FelhasznaloId.Value);
+                    importItemCo.IsVanAlapertelmezettTelefonszam = tanuloHelper.IsTanulonakVanAlapertelmezettTelefonszama(importItemCo.FelhasznaloId.Value);
+                }
+
+                importCo.MainImportItemList.Add(importItemCo);
+
+                lineNumber++;
+            }
+
+            return importCo;
+        }
+
+        #region Template
+
+        public MemoryStream GetTemplate()
+        {
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<TanuloItemCo>(TanuloItemCo.TanulokElerhetosegiAdataikTemplateExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
+            return SimpleExportLogic.GetTemplate(ImportExportTanulokElerhetosegiAdataikResource.ImportDefaultSheetName, simpleExportColumnCos);
+        }
+
+        #endregion Template
+
+        #region Export
+
+        public MemoryStream GetExport()
+        {
+            List<TanuloItemCo> coList = new TanuloHelper(ConnectionType).GetTanuloCoList().OrderBy(t => t.FelhasznaloNyomtatasiNev).ToList();
+            SetTelefonszamEsEmail(coList);
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<TanuloItemCo>(TanuloItemCo.TanulokElerhetosegiAdataikTemplateExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
+            return SimpleExportLogic.GetExport(ImportExportTanulokElerhetosegiAdataikResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        private void SetTelefonszamEsEmail(List<TanuloItemCo> tanuloItemCoList)
+        {
+            foreach (var tanuloItemCo in tanuloItemCoList)
+            {
+                if (tanuloItemCo.TelefonList != null && tanuloItemCo.TelefonList.Any())
+                {
+                    var telefon = tanuloItemCo.TelefonList.FirstOrDefault(x => x.IsAlapertelmezett) ?? tanuloItemCo.TelefonList.FirstOrDefault();
+                    tanuloItemCo.Telefonszam = telefon?.Telefonszam ?? string.Empty;
+                    tanuloItemCo.IsAlapertelmezettTelefonszam = telefon?.IsAlapertelmezett == true ? Enum.GetName(typeof(IgenNemEnum), IgenNemEnum.Igen) : Enum.GetName(typeof(IgenNemEnum), IgenNemEnum.Nem);
+                    tanuloItemCo.TelefonszamTipusNev = telefon?.TipusNev ?? TelefonTipusEnum.Ismeretlen.GetDisplayName(TanevId);
+                }
+
+                if (tanuloItemCo.EmailList != null && tanuloItemCo.EmailList.Any())
+                {
+                    var email = tanuloItemCo.EmailList.FirstOrDefault(x => x.IsAlapertelmezett) ?? tanuloItemCo.EmailList.FirstOrDefault();
+                    tanuloItemCo.EmailCim = email?.EmailCim ?? string.Empty;
+                    tanuloItemCo.IsAlapertelmezettEmailCim = email?.IsAlapertelmezett == true ? Enum.GetName(typeof(IgenNemEnum), IgenNemEnum.Igen) : Enum.GetName(typeof(IgenNemEnum), IgenNemEnum.Nem);
+                    tanuloItemCo.EmailCimTipusNev = email?.TipusNev ?? EmailTipusEnum.Na.GetDisplayName(TanevId);
+                }
+            }
+        }
+
+        public MemoryStream GetNemImportalhatoSorokExport()
+        {
+            List<TanulokElerhetosegiAdataikImportItemCo> coList = ImportCo.NemImportalhatoItemList;
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<TanulokElerhetosegiAdataikImportItemCo>(TanulokElerhetosegiAdataikImportItemCo.NemImportalhatoSorokExportAttributeId);
+            return ImportExportHelper.NemImportalhatoSorokExport(ImportExportTanulokElerhetosegiAdataikResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        #endregion Export
+
+        private Dictionary<string, ImportItemCompareCo> GetTelefonCompareHashImportItemCompareCoDictionary(List<TanuloItemCo> tanuloItemCoList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (TanuloItemCo tanuloItemCo in tanuloItemCoList)
+            {
+                foreach (TelefonItemCo telefonItemCo in tanuloItemCo.TelefonList)
+                {
+                    string telefonMd5HashInput = tanuloItemCo.FelhasznaloId.ToString() + telefonItemCo.Telefonszam?.ToComparableString();
+                    string compareHash = ImportExportHelper.GetMd5Hash(telefonMd5HashInput);
+
+                    var importItemCompareCo = new ImportItemCompareCo
+                    {
+                        Id = telefonItemCo.Id,
+                        CompareHash = compareHash
+                    };
+
+                    if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+                    {
+                        compareHashImportItemCompareCoDictionary.Add(compareHash, importItemCompareCo);
+                    }
+                }
+            }
+
+            return compareHashImportItemCompareCoDictionary;
+        }
+
+        private Dictionary<string, ImportItemCompareCo> GetEmailCompareHashImportItemCompareCoDictionary(List<TanuloItemCo> tanuloItemCoList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (TanuloItemCo tanuloItemCo in tanuloItemCoList)
+            {
+                foreach (EmailItemCo emailItemCo in tanuloItemCo.EmailList)
+                {
+                    string emailMd5HashInput = tanuloItemCo.FelhasznaloId.ToString() + emailItemCo.EmailCim?.ToComparableString();
+                    string compareHash = ImportExportHelper.GetMd5Hash(emailMd5HashInput);
+
+                    var importItemCompareCo = new ImportItemCompareCo
+                    {
+                        Id = emailItemCo.Id,
+                        CompareHash = compareHash
+                    };
+
+                    if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
+                    {
+                        compareHashImportItemCompareCoDictionary.Add(compareHash, importItemCompareCo);
+                    }
+                }
+            }
+
+            return compareHashImportItemCompareCoDictionary;
+        }
+
+        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary()
+        {
+            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>()
+            {
+                {
+                    ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameTelefonszamAlapertelmezett,
+                    EnumExtensions.GetEnumDisplayNameList<IgenNemEnum>(TanevId)
+                },
+            };
+
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                var connectionType = new DalHandlerConnectionType(ConnectionType, dalHandler);
+
+                dropDownColumnSourceDictionary.Add(ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameTelefonszamTipusa, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.TelefonTipus, new List<int> { (int)TelefonTipusEnum.PublikusTelefonszam }));
+
+                dropDownColumnSourceDictionary.Add(ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameEmailAlapertelmezett, EnumExtensions.GetEnumDisplayNameList<IgenNemEnum>(TanevId));
+
+                dropDownColumnSourceDictionary.Add(ImportExportTanulokElerhetosegiAdataikResource.ImportHeaderNameEmailTipus, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.EmailTipus, new List<int> { (int)EmailTipusEnum.PublikusEmailcim }));
+            });
+
+            return dropDownColumnSourceDictionary;
+        }
+
+        public void Import(object importJsonObject, int importMuvelet, string tableNameList, IEnumerable<int> alapertelmezettEmailFelhasznaloIds, IEnumerable<int> alapertelmezettTelefonFelhasznaloIds, bool isSubTable = false)
+        {
+            string importJson = JsonConvert.SerializeObject(importJsonObject);
+            bool isTorles = importMuvelet == (int)ImportMuveletEnum.DeleteAndInsert;
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                var importExportDal = dalHandler.ImportExportDal();
+                importExportDal.UpdateTanulokElerhetosegeiAlapertelmezett(FelhasznaloId, alapertelmezettEmailFelhasznaloIds, alapertelmezettTelefonFelhasznaloIds);
+                importExportDal.TanulokElerhetosegiAdataikImport(IntezmenyId, TanevId, FelhasznaloId, importJson, isTorles, isSubTable, tableNameList);
+            });
+        }
+    }
+}

Kreta.BusinessLogic/Helpers/ImportExport/TeremImportExportHelper.cs

@@ -0,0 +1,294 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Data;
+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;
+
+namespace Kreta.BusinessLogic.Helpers.ImportExport
+{
+    public class TeremImportExportHelper : LogicBase
+    {
+        #region Fields
+
+        private readonly string _importObjectCacheKey;
+
+        #endregion Fields
+
+        #region Properties
+
+        public static Dictionary<int, string> ImportHeaderList => new Dictionary<int, string>
+        {
+            { 00, ImportExportTeremResource.ImportHeaderNameHelyisegNev },
+            { 01, ImportExportTeremResource.ImportHeaderNameJelleg },
+            { 02, ImportExportTeremResource.ImportHeaderNameBefogadokepesseg },
+            { 03, ImportExportTeremResource.ImportHeaderNameAlapterulet }
+        };
+
+        public TeremImportCo ImportCo
+        {
+            get => (TeremImportCo)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 TeremImportExportHelper(IConnectionType connectionType) : base(connectionType)
+        {
+            _importObjectCacheKey = $"{nameof(TeremImportCo)}_{IntezmenyId}_{FelhasznaloId}_ImportObjectCacheKey";
+        }
+
+        #endregion Constructors
+
+        public void SetImportCo(List<List<string>> importData, int importMuvelet, int mukodesiHelyId)
+        {
+            TeremImportCo importCo = GetImportCoFromImportData(importData);
+            importCo.ImportMuvelet = importMuvelet;
+
+            SetNemImportalhatoSorokByValidation(importCo);
+
+            SetOperationAndNemImportalhatoSorokByOperation(importCo);
+
+            var mainImportJsonItemList = new List<TeremImportJsonItemCo>(importCo.MainImportItemList.Select(x => new TeremImportJsonItemCo(x, mukodesiHelyId, TanevId, IntezmenyId, FelhasznaloId)));
+            importCo.MainImportJsonItemList = mainImportJsonItemList;
+
+            ImportCo = importCo;
+        }
+
+        private static void SetNemImportalhatoSorokByValidation(TeremImportCo importCo)
+        {
+            Dictionary<int, List<ValidationResult>> validationResultDictionary = importCo.Validate();
+
+            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
+            foreach (TeremImportItemCo 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(TeremImportCo importCo)
+        {
+            int importMuvelet = importCo.ImportMuvelet;
+            //NOTE: Azért van szükség Dictionary-re, mert így sokkal gyorsabb a keresés!
+            Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary = GetCompareHashImportItemCompareCoDictionary(importCo.TeremCoList);
+            foreach (TeremImportItemCo 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...
+                else
+                {
+                    ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
+                    //NOTE: ...ha az import művelet DeleteAndInsert és a db-ből jövő adat Importalt(a nem importáltakat egyelőre nem töröljük), akkor Insert, mert töröljük a korábbi elemeket és újra be kell szúrni!
+                    if (importMuvelet == (int)ImportMuveletEnum.DeleteAndInsert && importItemCompareCo.Importalt)
+                    {
+                        importItem.Operation = (int)ImportItemOperationEnum.Insert;
+                    }
+                    //NOTE: ...ha nincs törlés, akkor...
+                    else
+                    {
+                        //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
+                        if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
+                        {
+                            importItem.Id = importItemCompareCo.Id;
+                            importItem.Operation = (int)ImportItemOperationEnum.Update;
+                        }
+                        //NOTE: ...ha a művelet nem InsertAndUpdate, akkor hozzá kell adni a nem NemImportalhatoItemList-hez és jelezni, hogy már szerepel az adatbázisban(Insert vagy DeleteAndInsert műveletnél. A DeleteAndInsert csak akkor fut be ide, ha az elem nem importált.)!
+                        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 TeremImportCo GetImportCoFromImportData(List<List<string>> importData)
+        {
+            var importCo = new TeremImportCo
+            {
+                TeremCoList = new TeremHelper(ConnectionType).GetTeremCoList()
+            };
+
+            int lineNumber = 1;
+            foreach (List<string> importDataRow in importData.Skip(1))
+            {
+                var importItemCo = new TeremImportItemCo(TanevId)
+                {
+                    LineNumber = lineNumber,
+
+                    HelyisegNevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTeremResource.ImportHeaderNameHelyisegNev)],
+                    JellegImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTeremResource.ImportHeaderNameJelleg)],
+                    BefogadokepessegImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTeremResource.ImportHeaderNameBefogadokepesseg)],
+                    AlapteruletImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTeremResource.ImportHeaderNameAlapterulet)]
+                };
+
+                string md5HashInput = importItemCo.Nev?.ToComparableString();
+                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(md5HashInput);
+
+                importCo.MainImportItemList.Add(importItemCo);
+
+                lineNumber++;
+            }
+
+            return importCo;
+        }
+
+        #region Template
+
+        public MemoryStream GetTemplate()
+        {
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<TeremItemCo>(TeremItemCo.TeremTemplateExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
+            return SimpleExportLogic.GetTemplate(ImportExportTeremResource.ImportDefaultSheetName, simpleExportColumnCos);
+        }
+
+        #endregion Template
+
+        #region Export
+
+        public MemoryStream GetExport(bool isTermekAdataiExport)
+        {
+            string simpleExportColumnAttributeId;
+            Dictionary<string, IList<string>> dropDownColumnSourceDictionary;
+            if (isTermekAdataiExport)
+            {
+                simpleExportColumnAttributeId = TeremItemCo.TermekAdataiExportAttributeId;
+                dropDownColumnSourceDictionary = GetTermekAdataiExportDropDownColumnSourceDictionary();
+            }
+            else
+            {
+                simpleExportColumnAttributeId = TeremItemCo.TeremExportAttributeId;
+                dropDownColumnSourceDictionary = GetExportDropDownColumnSourceDictionary();
+            }
+
+            List<TeremItemCo> coList = new TeremHelper(ConnectionType).GetTeremCoList().OrderBy(x => x.Nev).ToList();
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<TeremItemCo>(simpleExportColumnAttributeId, dropDownColumnSourceDictionary);
+            return SimpleExportLogic.GetExport(ImportExportTeremResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        public MemoryStream GetNemImportalhatoSorokExport()
+        {
+            List<TeremImportItemCo> coList = ImportCo.NemImportalhatoItemList;
+            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<TeremImportItemCo>(TeremImportItemCo.NemImportalhatoSorokExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
+            return ImportExportHelper.NemImportalhatoSorokExport(ImportExportTeremResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
+        }
+
+        #endregion Export
+
+        private Dictionary<string, ImportItemCompareCo> GetCompareHashImportItemCompareCoDictionary(List<TeremItemCo> coList)
+        {
+            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
+            foreach (TeremItemCo co in coList)
+            {
+                string md5HashInput = co.NevComparableString;
+                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;
+        }
+
+        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary()
+        {
+            //NOTE: Create dropdown lists
+            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>();
+
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                var connectionType = new DalHandlerConnectionType(ConnectionType, dalHandler);
+
+                dropDownColumnSourceDictionary.Add(ImportExportTeremResource.ImportHeaderNameJelleg, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.TeremTipus));
+
+            });
+
+            return dropDownColumnSourceDictionary;
+        }
+
+        private Dictionary<string, IList<string>> GetExportDropDownColumnSourceDictionary()
+        {
+            //NOTE: Create dropdown lists
+            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>();
+
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                var connectionType = new DalHandlerConnectionType(ConnectionType, dalHandler);
+
+                dropDownColumnSourceDictionary.Add(ImportExportTeremResource.ImportHeaderNameJelleg, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.TeremTipus));
+
+                var helper = new ImportExportHelper(connectionType);
+                DataSet feladatellatasiHelyDataSet = dalHandler.FeladatEllatasiHelyDal().GetFeladatellatasiHelyDataSet(TanevId);
+
+                dropDownColumnSourceDictionary.Add(ImportExportTeremResource.ExportHeaderNameMukodesiHely, helper.GetMukodesiHelyList(feladatellatasiHelyDataSet));
+            });
+
+            return dropDownColumnSourceDictionary;
+        }
+
+        private Dictionary<string, IList<string>> GetTermekAdataiExportDropDownColumnSourceDictionary()
+        {
+            //NOTE: Create dropdown lists
+            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>();
+
+            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
+            {
+                var connectionType = new DalHandlerConnectionType(ConnectionType, dalHandler);
+
+                dropDownColumnSourceDictionary.Add(ImportExportTeremResource.ImportHeaderNameJelleg, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.TeremTipus));
+
+                var helper = new ImportExportHelper(connectionType);
+                DataSet feladatellatasiHelyDataSet = dalHandler.FeladatEllatasiHelyDal().GetFeladatellatasiHelyDataSet(TanevId);
+
+                dropDownColumnSourceDictionary.Add(ImportExportTeremResource.ExportHeaderNameMukodesiHely, helper.GetMukodesiHelyList(feladatellatasiHelyDataSet));
+                dropDownColumnSourceDictionary.Add(ImportExportTeremResource.ExportHeaderNameTeremfelelos, helper.GetTanarList());
+            });
+
+            return dropDownColumnSourceDictionary;
+        }
+    }
+}