init

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; }
+    }
+}