Beispiel #1
0
        private async Task <int> ExportSubjects(UntisDocument untisDocument, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.Code,
                    EcfHeaders.Name,
                    EcfHeaders.Description,
                    EcfHeaders.Color);
            }

            foreach (var subject in untisDocument.Subjects)
            {
                ecfTableWriter.TrySetValue(EcfHeaders.Id, subject.Id);
                ecfTableWriter.TrySetValue(EcfHeaders.Code, subject.ShortName);
                ecfTableWriter.TrySetValue(EcfHeaders.Name, subject.LongName);
                ecfTableWriter.TrySetValue(EcfHeaders.Description, subject.GetEcfDescription(untisDocument.Descriptions));
                ecfTableWriter.TrySetValue(EcfHeaders.Color, subject.BackgroundColor);

                await ecfTableWriter.WriteAsync();

                ecfRecordCounter++;
            }

            return(ecfRecordCounter);
        }
        private async Task <int> ExportSchoolClasses(XlsReader xlsReader, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfCache         = new HashSet <string>();
            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.Code);
            }

            while (xlsReader.ReadLine())
            {
                var schoolClass = new ExportSchoolClass(_config, xlsReader);

                if (!string.IsNullOrEmpty(schoolClass.Id) && !ecfCache.Contains(schoolClass.Id))
                {
                    ecfTableWriter.SetValue(EcfHeaders.Id, schoolClass.Id);
                    ecfTableWriter.SetValue(EcfHeaders.Code, schoolClass.Code);

                    await ecfTableWriter.WriteAsync();

                    ecfCache.Add(schoolClass.Id);
                    ecfRecordCounter++;
                }
            }

            return(ecfRecordCounter);
        }
Beispiel #3
0
        private async Task <int> ExportVaccations(UntisDocument untisDocument, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.Title,
                    EcfHeaders.Description,
                    EcfHeaders.TemporalExpressions);
            }

            foreach (var holiday in untisDocument.Holidays)
            {
                ecfTableWriter.TrySetValue(EcfHeaders.Id, holiday.Id);
                ecfTableWriter.TrySetValue(EcfHeaders.Title, holiday.ShortName);
                ecfTableWriter.TrySetValue(EcfHeaders.Description, holiday.LongName);
                ecfTableWriter.TrySetValue(EcfHeaders.TemporalExpressions, holiday.GetEcfTemporalExpressions());

                await ecfTableWriter.WriteAsync();

                ecfRecordCounter++;
            }

            return(ecfRecordCounter);
        }
Beispiel #4
0
        private async Task <int> ExportDepartments(UntisDocument untisDocument, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.Code,
                    EcfHeaders.Name);
            }

            foreach (var department in untisDocument.Departments)
            {
                ecfTableWriter.TrySetValue(EcfHeaders.Id, department.Id);
                ecfTableWriter.TrySetValue(EcfHeaders.Code, department.ShortName);
                ecfTableWriter.TrySetValue(EcfHeaders.Name, department.LongName);

                await ecfTableWriter.WriteAsync();

                ecfRecordCounter++;
            }

            return(ecfRecordCounter);
        }
Beispiel #5
0
        private async Task Execute(string ecfTableName, FbConnection fbConnection, Func <FbConnection, EcfTableWriter, string[], Task <int> > action)
        {
            if (ShouldExportTable(ecfTableName, out var ecfFile))
            {
                // Report status
                Console.WriteLine($"[Extracting] [{ecfTableName}] Start...");

                // Init CSV file stream
                using var ecffileStream = new FileStream(Path.ChangeExtension(Path.Combine(_config.EcfExport?.TargetFolderName, ecfTableName), "csv"), FileMode.Create, FileAccess.ReadWrite, FileShare.None);

                // Init CSV Writer
                using var csvWriter = new CsvWriter(ecffileStream, Encoding.UTF8);

                // Init ECF Writer
                var ecfTablefWriter = new EcfTableWriter(csvWriter);

                if (_version < 7)
                {
                    ecfTablefWriter.AddConverter <object>(new CsvWin1251Converter());
                }

                // Call table specific action
                var ecfRecordCounter = await action(fbConnection, ecfTablefWriter, ecfFile?.Headers);

                // Inc counters
                _recordCounter += ecfRecordCounter;
                _tableCounter++;

                // Report status
                Console.WriteLine($"[Extracting] [{ecfTableName}] {ecfRecordCounter} record(s) extracted");
            }
        }
Beispiel #6
0
        private async Task <int> ExportSchoolClassTypes(EcfTableWriter ecfTableWriter)
        {
            await ecfTableWriter.WriteHeadersAsync(
                EcfHeaders.Id,
                EcfHeaders.Code,
                EcfHeaders.StatisticalCode,
                EcfHeaders.InternalCode,
                EcfHeaders.Name);

            await ecfTableWriter.WriteAsync("0", "STANDARD", "00", "00", "Standardklasse");

            await ecfTableWriter.WriteAsync("1", "GANZTAGS", "01", "01", "Ganztagsklasse");

            await ecfTableWriter.WriteAsync("2", "KURSE", "02", "02", "Oberstufenjahrgang (Nur Kurse)");

            await ecfTableWriter.WriteAsync("3", "LK+GK", "03", "03", "Oberstufenjahrgang (LK und GK)");

            await ecfTableWriter.WriteAsync("4", "ABSCHLUSS", "04", "04", "Abschlussklasse");

            await ecfTableWriter.WriteAsync("5", "KOMBI", "05", "05", "Kombinationsklasse");

            await ecfTableWriter.WriteAsync("6", "KINDER", "06", "06", "Schulkindergarten");

            await ecfTableWriter.WriteAsync("7", "STANDARD+O", "07", "07", "Standardklasse mit Oberstufensynchronisation");

            return(await Task.FromResult(8));
        }
Beispiel #7
0
        private async Task <int> ExportAbsenceReasons(CsvReader csvReader, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.Code,
                    EcfHeaders.Name,
                    EcfHeaders.StatisticalCode);
            }

            var gpuReader = new GpuReader <GpuAbsenceReason>(csvReader);

            await foreach (var reason in gpuReader.ReadAsync())
            {
                ecfTableWriter.TrySetValue(EcfHeaders.Id, reason.ShortName);
                ecfTableWriter.TrySetValue(EcfHeaders.Code, reason.ShortName);
                ecfTableWriter.TrySetValue(EcfHeaders.Name, reason.LongName);
                ecfTableWriter.TrySetValue(EcfHeaders.StatisticalCode, reason.StatisticalCode);

                await ecfTableWriter.WriteAsync();

                ecfRecordCounter++;
            }

            return(ecfRecordCounter);
        }
Beispiel #8
0
        private async Task <int> ExportStudents(UntisDocument untisDocument, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.LastName,
                    EcfHeaders.FirstName,
                    EcfHeaders.Gender,
                    EcfHeaders.Birthdate);
            }

            foreach (var student in untisDocument.Students)
            {
                ecfTableWriter.TrySetValue(EcfHeaders.Id, student.Id);
                ecfTableWriter.TrySetValue(EcfHeaders.LastName, student.LastName);
                ecfTableWriter.TrySetValue(EcfHeaders.FirstName, student.FirstName);
                ecfTableWriter.TrySetValue(EcfHeaders.Gender, student.GetEcfGender());
                ecfTableWriter.TrySetValue(EcfHeaders.Birthdate, student.GetEcfBirthdate());

                await ecfTableWriter.WriteAsync();

                ecfRecordCounter++;
            }

            return(ecfRecordCounter);
        }
Beispiel #9
0
        private async Task <int> ExportTimeframes(UntisDocument untisDocument, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.Code,
                    EcfHeaders.Name,
                    EcfHeaders.TimeSlots);
            }

            foreach (var timeGrid in untisDocument.TimeGrids)
            {
                ecfTableWriter.TrySetValue(EcfHeaders.Id, timeGrid.GetEcfCode());
                ecfTableWriter.TrySetValue(EcfHeaders.Code, timeGrid.GetEcfCode());
                ecfTableWriter.TrySetValue(EcfHeaders.Name, timeGrid.GetEcfCode());
                ecfTableWriter.TrySetValue(EcfHeaders.TimeSlots, timeGrid.GetEcfTimeSlots());

                await ecfTableWriter.WriteAsync();

                ecfRecordCounter++;
            }

            return(ecfRecordCounter);
        }
        private async Task <int> ExportTeachers(CsvTableReader csvTableReader, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfCache         = new HashSet <string>();
            var ecfRecordCounter = 0;

            await csvTableReader.ReadHeadersAsync();

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.Code);
            }

            while (await csvTableReader.ReadAsync() > 0)
            {
                if (csvTableReader.TryGetValue("Alle Lehrkräfte (Kürzel) mit Fach", out var value))
                {
                    var csvLineParser = new CsvLineParser(',');

                    var subValues = csvLineParser.Read(value);

                    csvLineParser.Configuration.Separator = ' ';

                    foreach (var subValue in subValues)
                    {
                        if (!string.IsNullOrEmpty(subValue))
                        {
                            var subValueParts = csvLineParser.Read(subValue.Trim());
                            if (subValueParts.Length == 2)
                            {
                                var teacherCode = subValueParts[0];

                                if (!string.IsNullOrEmpty(teacherCode) && !ecfCache.Contains(teacherCode))
                                {
                                    ecfTableWriter.TrySetValue(EcfHeaders.Id, teacherCode);
                                    ecfTableWriter.TrySetValue(EcfHeaders.Code, teacherCode);

                                    await ecfTableWriter.WriteAsync();

                                    ecfCache.Add(teacherCode);
                                    ecfRecordCounter++;
                                }
                            }
                        }
                    }
                }
            }

            return(ecfRecordCounter);
        }
        private async Task <int> ExportStudents(CsvTableReader csvTableReader, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfCache         = new HashSet <string>();
            var ecfRecordCounter = 0;

            await csvTableReader.ReadHeadersAsync();

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.LastName,
                    EcfHeaders.FirstName,
                    EcfHeaders.MiddleName,
                    EcfHeaders.NickName,
                    EcfHeaders.Salutation,
                    EcfHeaders.Gender,
                    EcfHeaders.Birthdate);
            }

            while (await csvTableReader.ReadAsync() > 0)
            {
                var student = new ExportStudent(_config, csvTableReader);

                if (!ecfCache.Contains(student.Id))
                {
                    ecfTableWriter.SetValue(EcfHeaders.Id, student.Id);
                    ecfTableWriter.SetValue(EcfHeaders.LastName, student.LastName);
                    ecfTableWriter.SetValue(EcfHeaders.FirstName, student.FirstName);
                    ecfTableWriter.SetValue(EcfHeaders.MiddleName, student.MiddleName);
                    ecfTableWriter.SetValue(EcfHeaders.NickName, student.NickName);
                    ecfTableWriter.SetValue(EcfHeaders.Salutation, student.Salutation);
                    ecfTableWriter.SetValue(EcfHeaders.Gender, student.Gender);
                    ecfTableWriter.SetValue(EcfHeaders.Birthdate, student.BirthDate);

                    await ecfTableWriter.WriteAsync();

                    ecfCache.Add(student.Id);
                    ecfRecordCounter++;
                }
            }

            return(ecfRecordCounter);
        }
Beispiel #12
0
        private async Task <int> ExportSubjects(FbConnection fbConnection, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            string sql = $"select * from \"Faecher\" where \"Mandant\" = @tenantId";

            using var fbTransaction = fbConnection.BeginTransaction();
            using var fbCommand     = new FbCommand(sql, fbConnection, fbTransaction);

            fbCommand.Parameters.Add("@tenantId", _tenantId);

            using var reader = await fbCommand.ExecuteReaderAsync();

            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.Code,
                    EcfHeaders.StatisticalCode,
                    EcfHeaders.InternalCode,
                    EcfHeaders.Name,
                    EcfHeaders.SubjectTypeId,
                    EcfHeaders.SubjectCategoryId,
                    EcfHeaders.SubjectGroupId);
            }

            while (await reader.ReadAsync())
            {
                ecfTableWriter.SetValue(EcfHeaders.Id, reader["ID"]);
                ecfTableWriter.SetValue(EcfHeaders.Code, reader["Kuerzel"]);
                ecfTableWriter.SetValue(EcfHeaders.StatisticalCode, reader["StatistikID"]);
                ecfTableWriter.SetValue(EcfHeaders.InternalCode, reader["Schluessel"]);
                ecfTableWriter.SetValue(EcfHeaders.Name, reader["Bezeichnung"]);
                ecfTableWriter.SetValue(EcfHeaders.SubjectTypeId, reader["Kategorie"]);
                ecfTableWriter.SetValue(EcfHeaders.SubjectCategoryId, reader["Aufgabenbereich"]);
                ecfTableWriter.SetValue(EcfHeaders.SubjectGroupId, reader["Gruppe"]);

                await ecfTableWriter.WriteAsync();

                ecfRecordCounter++;
            }

            return(ecfRecordCounter);
        }
        private async Task <int> ExportTeachers(EdoosysDbReader edoosysDbReader, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            if ((_config.EcfExport?.SchoolNo != null) && (_config.EcfExport?.SchoolYearCode != null))
            {
                var ecfRecordCounter = 0;

                if (ecfHeaders != null && ecfHeaders.Length > 0)
                {
                    await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
                }
                else
                {
                    await ecfTableWriter.WriteHeadersAsync(
                        EcfHeaders.Id,
                        EcfHeaders.Code,
                        EcfHeaders.LastName,
                        EcfHeaders.FirstName,
                        EcfHeaders.Gender,
                        EcfHeaders.Birthdate);
                }

                await foreach (var teacher in edoosysDbReader.TeachersAsync(_config.EcfExport.SchoolNo, _config.EcfExport.SchoolYearCode))
                {
                    if (_ecfTeacherCache.Contains(teacher.Id))
                    {
                        ecfTableWriter.TrySetValue(EcfHeaders.Id, teacher.Id);
                        ecfTableWriter.TrySetValue(EcfHeaders.Code, teacher.Code);
                        ecfTableWriter.TrySetValue(EcfHeaders.LastName, teacher.Lastname);
                        ecfTableWriter.TrySetValue(EcfHeaders.FirstName, teacher.Firstname);
                        ecfTableWriter.TrySetValue(EcfHeaders.Gender, Converter.GetGender(teacher.Gender));
                        ecfTableWriter.TrySetValue(EcfHeaders.Birthdate, Converter.GetDate(teacher.Birthdate));

                        await ecfTableWriter.WriteAsync();

                        ecfRecordCounter++;
                    }
                }

                return(ecfRecordCounter);
            }
            else
            {
                throw new Exception("No school no and/or no school year for edoo.sys database defined");
            }
        }
Beispiel #14
0
        private async Task <int> ExportSubstituteLessons(CsvReader csvReader, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.CourseId,
                    EcfHeaders.RoomIdList,
                    EcfHeaders.SchoolClassIdList,
                    EcfHeaders.TeacherIdList,
                    EcfHeaders.TemporalExpressions);
            }

            var gpuReader = new GpuReader <GpuSubstitution>(csvReader);

            await foreach (var substitution in gpuReader.ReadAsync())
            {
                if (substitution.Date >= _untisDocument.GeneralSettings.TermBeginDate &&
                    substitution.Date <= _untisDocument.GeneralSettings.TermEndDate &&
                    substitution.Type != GpuSubstitutionType.Cancellation &&
                    substitution.Type != GpuSubstitutionType.Exemption &&
                    substitution.GetEcfCourseId(_untisDocument.Lessons) != null)
                {
                    ecfTableWriter.TrySetValue(EcfHeaders.Id, substitution.GetEcfId());
                    ecfTableWriter.TrySetValue(EcfHeaders.CourseId, substitution.GetEcfCourseId(_untisDocument.Lessons));
                    ecfTableWriter.TrySetValue(EcfHeaders.RoomIdList, substitution.GetEcfRoomIdList());
                    ecfTableWriter.TrySetValue(EcfHeaders.SchoolClassIdList, substitution.GetEcfSchoolClassIdList());
                    ecfTableWriter.TrySetValue(EcfHeaders.TeacherIdList, substitution.GetEcfTeacherIdList());
                    ecfTableWriter.TrySetValue(EcfHeaders.TemporalExpressions, substitution.GetEcfTemporalExpressions(_untisDocument.TimeGrids, _untisDocument.Lessons));

                    await ecfTableWriter.WriteAsync();

                    ecfRecordCounter++;
                }
            }

            return(ecfRecordCounter);
        }
Beispiel #15
0
        private async Task <int> ExportTeacherAbsences(CsvReader csvReader, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.TeacherId,
                    EcfHeaders.StartTimepoint,
                    EcfHeaders.EndTimepoint,
                    EcfHeaders.ReasonId,
                    EcfHeaders.Description);
            }

            var gpuReader = new GpuReader <GpuAbsence>(csvReader);

            await foreach (var absence in gpuReader.ReadAsync())
            {
                if (absence.Type == GpuAbsenceType.Teacher)
                {
                    if (absence.IsInsideTerm(_untisDocument.GeneralSettings) && absence.GetEcfTeacherId(_untisDocument.Teachers) != null)
                    {
                        ecfTableWriter.TrySetValue(EcfHeaders.Id, absence.Id);
                        ecfTableWriter.TrySetValue(EcfHeaders.TeacherId, absence.GetUntisTeacherId());
                        ecfTableWriter.TrySetValue(EcfHeaders.StartTimepoint, absence.StartDate);
                        ecfTableWriter.TrySetValue(EcfHeaders.EndTimepoint, absence.EndDate);
                        ecfTableWriter.TrySetValue(EcfHeaders.ReasonId, absence.Reason);
                        ecfTableWriter.TrySetValue(EcfHeaders.Description, absence.Text);

                        await ecfTableWriter.WriteAsync();

                        _untisAbsencesCache.Add(absence.Id);
                        ecfRecordCounter++;
                    }
                }
            }

            return(ecfRecordCounter);
        }
Beispiel #16
0
        private async Task <int> ExportCourses(UntisDocument untisDocument, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.Title,
                    EcfHeaders.BlockNo,
                    EcfHeaders.Description,
                    EcfHeaders.SubjectId,
                    EcfHeaders.SchoolClassIdList,
                    EcfHeaders.TeacherIdList,
                    EcfHeaders.ValidFrom,
                    EcfHeaders.ValidTo);
            }

            foreach (var lesson in untisDocument.Lessons)
            {
                if (!string.IsNullOrEmpty(lesson.SubjectId))
                {
                    ecfTableWriter.TrySetValue(EcfHeaders.Id, lesson.Id);
                    ecfTableWriter.TrySetValue(EcfHeaders.Title, lesson.GetEcfCourseTitle(_untisDocument.Subjects));
                    ecfTableWriter.TrySetValue(EcfHeaders.BlockNo, lesson.Block);
                    ecfTableWriter.TrySetValue(EcfHeaders.Description, lesson.Text);
                    ecfTableWriter.TrySetValue(EcfHeaders.SubjectId, lesson.SubjectId);
                    ecfTableWriter.TrySetValue(EcfHeaders.SchoolClassIdList, lesson.ClassIds);
                    ecfTableWriter.TrySetValue(EcfHeaders.TeacherIdList, lesson.GetEcfTeacherIdList());
                    ecfTableWriter.TrySetValue(EcfHeaders.ValidFrom, lesson.ValidFrom);
                    ecfTableWriter.TrySetValue(EcfHeaders.ValidTo, lesson.ValidTo);

                    await ecfTableWriter.WriteAsync();

                    ecfRecordCounter++;
                }
            }

            return(ecfRecordCounter);
        }
        private async Task <int> ExportStudentSubjects(XlsReader xlsReader, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.StudentId,
                    EcfHeaders.SchoolClassId,
                    EcfHeaders.SubjectId);
            }

            while (xlsReader.ReadLine())
            {
                var student     = new ExportStudent(_config, xlsReader);
                var schoolClass = new ExportSchoolClass(_config, xlsReader);

                if (!string.IsNullOrEmpty(schoolClass.Id))
                {
                    for (int i = 1; i < 20; i++)
                    {
                        var subject = new ExportSubject(_config, xlsReader, $"Fach{i}");

                        if (!string.IsNullOrEmpty(subject.Id))
                        {
                            ecfTableWriter.SetValue(EcfHeaders.StudentId, student.Id);
                            ecfTableWriter.SetValue(EcfHeaders.SchoolClassId, schoolClass.Id);
                            ecfTableWriter.SetValue(EcfHeaders.SubjectId, subject.Id);

                            await ecfTableWriter.WriteAsync();

                            ecfRecordCounter++;
                        }
                    }
                }
            }

            return(ecfRecordCounter);
        }
Beispiel #18
0
        private async Task <int> ExportScheduledLessons(UntisDocument untisDocument, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.CourseId,
                    EcfHeaders.SubjectId,
                    EcfHeaders.SchoolClassIdList,
                    EcfHeaders.TeacherIdList,
                    EcfHeaders.RoomIdList,
                    EcfHeaders.TemporalExpressions);
            }

            foreach (var lesson in untisDocument.Lessons)
            {
                if (!string.IsNullOrEmpty(lesson.SubjectId))
                {
                    foreach (var lessonTime in lesson.Times.FindAll(x => x.SlotGroupFirstSlot == null))
                    {
                        ecfTableWriter.TrySetValue(EcfHeaders.Id, lessonTime.GetEcfId(lesson));
                        ecfTableWriter.TrySetValue(EcfHeaders.CourseId, lesson.Id);
                        ecfTableWriter.TrySetValue(EcfHeaders.SubjectId, lesson.SubjectId);
                        ecfTableWriter.TrySetValue(EcfHeaders.SchoolClassIdList, lesson.ClassIds);
                        ecfTableWriter.TrySetValue(EcfHeaders.TeacherIdList, lesson.GetEcfTeacherIdList());
                        ecfTableWriter.TrySetValue(EcfHeaders.RoomIdList, lessonTime.RoomIds);
                        ecfTableWriter.TrySetValue(EcfHeaders.TemporalExpressions, lesson.GetEcfTemporalExpressions(lessonTime, untisDocument.GeneralSettings));

                        await ecfTableWriter.WriteAsync();

                        ecfRecordCounter++;
                    }
                }
            }

            return(ecfRecordCounter);
        }
Beispiel #19
0
        private async Task <int> ExportLessonGaps(CsvReader csvReader, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.LessonId,
                    EcfHeaders.Reasons,
                    EcfHeaders.Resolutions,
                    EcfHeaders.Description,
                    EcfHeaders.TemporalExpressions);
            }

            var gpuReader = new GpuReader <GpuSubstitution>(csvReader);

            await foreach (var substitution in gpuReader.ReadAsync())
            {
                if (substitution.Date >= _untisDocument.GeneralSettings.TermBeginDate &&
                    substitution.Date <= _untisDocument.GeneralSettings.TermEndDate &&
                    substitution.GetEcfLessonId(_untisDocument.Lessons) != null)
                {
                    ecfTableWriter.TrySetValue(EcfHeaders.Id, substitution.GetEcfLessonGapId());
                    ecfTableWriter.TrySetValue(EcfHeaders.LessonId, substitution.GetEcfLessonId(_untisDocument.Lessons));
                    ecfTableWriter.TrySetValue(EcfHeaders.Reasons, substitution.GetEcfReasons(_untisAbsencesCache));
                    ecfTableWriter.TrySetValue(EcfHeaders.Resolutions, substitution.GetEcfResolutions());
                    ecfTableWriter.TrySetValue(EcfHeaders.Description, substitution.Remark);
                    ecfTableWriter.TrySetValue(EcfHeaders.TemporalExpressions, substitution.GetEcfTemporalExpressions(_untisDocument.TimeGrids, _untisDocument.Lessons));

                    await ecfTableWriter.WriteAsync();

                    ecfRecordCounter++;
                }
            }

            return(ecfRecordCounter);
        }
Beispiel #20
0
        private async Task <int> ExportSubjectCategories(EcfTableWriter ecfTableWriter)
        {
            await ecfTableWriter.WriteHeadersAsync(
                EcfHeaders.Id,
                EcfHeaders.Code,
                EcfHeaders.StatisticalCode,
                EcfHeaders.InternalCode,
                EcfHeaders.Name);

            await ecfTableWriter.WriteAsync("0", "SLK", "00", "00", "sprachl.-lit.-künstlerisch");

            await ecfTableWriter.WriteAsync("1", "GES", "01", "01", "gesellschaftswiss.");

            await ecfTableWriter.WriteAsync("2", "MNT", "02", "02", "mathem.-nat.-technisch");

            await ecfTableWriter.WriteAsync("3", "REL", "03", "03", "Religion");

            await ecfTableWriter.WriteAsync("4", "SP", "04", "04", "Sport");

            return(await Task.FromResult(5));
        }
Beispiel #21
0
        private async Task <int> ExportMaritalStatuses(EcfTableWriter ecfTableWriter)
        {
            await ecfTableWriter.WriteHeadersAsync(
                EcfHeaders.Id,
                EcfHeaders.Code,
                EcfHeaders.StatisticalCode,
                EcfHeaders.InternalCode,
                EcfHeaders.Name);

            await ecfTableWriter.WriteAsync("0", "VH", "00", "00", "Verheiratet");

            await ecfTableWriter.WriteAsync("1", "NV", "01", "01", "Nicht Verheiratet");

            await ecfTableWriter.WriteAsync("2", "LE", "02", "02", "Ledig");

            await ecfTableWriter.WriteAsync("3", "GE", "03", "03", "Geschieden");

            await ecfTableWriter.WriteAsync("4", "VW", "04", "04", "Verwitwet");

            return(await Task.FromResult(5));
        }
        private async Task <int> ExportSubjects(CsvTableReader csvTableReader, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfCache         = new HashSet <string>();
            var ecfRecordCounter = 0;

            await csvTableReader.ReadHeadersAsync();

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.Code);
            }

            while (await csvTableReader.ReadAsync() > 0)
            {
                for (int i = 1; i < 20; i++)
                {
                    var subject = new ExportSubject(_config, csvTableReader, $"Fach{i}");

                    if (!string.IsNullOrEmpty(subject.Id) && !ecfCache.Contains(subject.Id))
                    {
                        ecfTableWriter.SetValue(EcfHeaders.Id, subject.Id);
                        ecfTableWriter.SetValue(EcfHeaders.Code, subject.Code);

                        await ecfTableWriter.WriteAsync();

                        ecfCache.Add(subject.Id);
                        ecfRecordCounter++;
                    }
                }
            }

            return(ecfRecordCounter);
        }
Beispiel #23
0
        private async Task <int> ExportSchoolClasses(UntisDocument untisDocument, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.Code,
                    EcfHeaders.Name1,
                    EcfHeaders.Description,
                    EcfHeaders.DepartmentId,
                    EcfHeaders.Color,
                    EcfHeaders.ValidFrom,
                    EcfHeaders.ValidTo);
            }

            foreach (var schoolClass in untisDocument.Classes)
            {
                ecfTableWriter.TrySetValue(EcfHeaders.Id, schoolClass.Id);
                ecfTableWriter.TrySetValue(EcfHeaders.Code, schoolClass.ShortName);
                ecfTableWriter.TrySetValue(EcfHeaders.Name1, schoolClass.LongName);
                ecfTableWriter.TrySetValue(EcfHeaders.Description, schoolClass.GetEcfDescription(untisDocument.Descriptions));
                ecfTableWriter.TrySetValue(EcfHeaders.DepartmentId, schoolClass.DepartmentId);
                ecfTableWriter.TrySetValue(EcfHeaders.Color, schoolClass.BackgroundColor);
                ecfTableWriter.TrySetValue(EcfHeaders.ValidFrom, schoolClass.ValidFrom);
                ecfTableWriter.TrySetValue(EcfHeaders.ValidTo, schoolClass.ValidTo);

                await ecfTableWriter.WriteAsync();

                ecfRecordCounter++;
            }

            return(ecfRecordCounter);
        }
Beispiel #24
0
        private async Task <int> ExportDepartments(FbConnection fbConnection, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            string sql = $"select * from \"Abteilungen\" where \"Mandant\" = @tenantId";

            using var fbTransaction = fbConnection.BeginTransaction();
            using var fbCommand     = new FbCommand(sql, fbConnection, fbTransaction);

            fbCommand.Parameters.Add("@tenantId", _tenantId);

            using var reader = await fbCommand.ExecuteReaderAsync();

            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.Code,
                    EcfHeaders.Name);
            }

            while (await reader.ReadAsync())
            {
                ecfTableWriter.SetValue(EcfHeaders.Id, reader["Kuerzel"]);
                ecfTableWriter.SetValue(EcfHeaders.Code, reader["Kuerzel"]);
                ecfTableWriter.SetValue(EcfHeaders.Name, reader["Bezeichnung"]);

                await ecfTableWriter.WriteAsync();

                ecfRecordCounter++;
            }

            return(ecfRecordCounter);
        }
Beispiel #25
0
        private async Task <int> ExportTeachers(UntisDocument untisDocument, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.Code,
                    EcfHeaders.LastName,
                    EcfHeaders.FirstName,
                    EcfHeaders.Gender,
                    EcfHeaders.Email,
                    EcfHeaders.Color);
            }

            foreach (var teacher in untisDocument.Teachers)
            {
                ecfTableWriter.TrySetValue(EcfHeaders.Id, teacher.Id);
                ecfTableWriter.TrySetValue(EcfHeaders.Code, teacher.ShortName);
                ecfTableWriter.TrySetValue(EcfHeaders.LastName, teacher.LastName);
                ecfTableWriter.TrySetValue(EcfHeaders.FirstName, teacher.FirstName);
                ecfTableWriter.TrySetValue(EcfHeaders.Gender, teacher.GetEcfGender());
                ecfTableWriter.TrySetValue(EcfHeaders.Email, teacher.Email);
                ecfTableWriter.TrySetValue(EcfHeaders.Color, teacher.BackgroundColor);

                await ecfTableWriter.WriteAsync();

                ecfRecordCounter++;
            }

            return(ecfRecordCounter);
        }
Beispiel #26
0
        private async Task <int> ExportRooms(UntisDocument untisDocument, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.Code,
                    EcfHeaders.Name,
                    EcfHeaders.Description,
                    EcfHeaders.DepartmentId,
                    EcfHeaders.Capacity,
                    EcfHeaders.Color);
            }

            foreach (var room in untisDocument.Rooms)
            {
                ecfTableWriter.TrySetValue(EcfHeaders.Id, room.Id);
                ecfTableWriter.TrySetValue(EcfHeaders.Code, room.ShortName);
                ecfTableWriter.TrySetValue(EcfHeaders.Name, room.LongName);
                ecfTableWriter.TrySetValue(EcfHeaders.Description, room.GetEcfDescription(untisDocument.Descriptions));
                ecfTableWriter.TrySetValue(EcfHeaders.DepartmentId, room.DepartmentId);
                ecfTableWriter.TrySetValue(EcfHeaders.Capacity, room.Capacity);
                ecfTableWriter.TrySetValue(EcfHeaders.Color, room.BackgroundColor);

                await ecfTableWriter.WriteAsync();

                ecfRecordCounter++;
            }

            return(ecfRecordCounter);
        }
        private async Task <int> ExportSubjects(EdoosysDbReader edoosysDbReader, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            if ((_config.EcfExport?.SchoolNo != null) && (_config.EcfExport?.SchoolYearCode != null))
            {
                var ecfRecordCounter = 0;

                if (ecfHeaders != null && ecfHeaders.Length > 0)
                {
                    await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
                }
                else
                {
                    await ecfTableWriter.WriteHeadersAsync(
                        EcfHeaders.Id,
                        EcfHeaders.Code,
                        EcfHeaders.Name);
                }

                await foreach (var subject in edoosysDbReader.SubjectsAsync(_config.EcfExport.SchoolNo, _config.EcfExport.SchoolYearCode))
                {
                    ecfTableWriter.TrySetValue(EcfHeaders.Id, subject.Id);
                    ecfTableWriter.TrySetValue(EcfHeaders.Code, subject.Code);
                    ecfTableWriter.TrySetValue(EcfHeaders.Name, subject.Name);

                    await ecfTableWriter.WriteAsync();

                    ecfRecordCounter++;
                }

                return(ecfRecordCounter);
            }
            else
            {
                throw new Exception("No school no and/or no school year for edoo.sys database defined");
            }
        }
Beispiel #28
0
        private async Task <int> ExportTeachers(FbConnection fbConnection, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            string sql = $"select * from \"Lehrer\" where \"Mandant\" = @tenantId and \"Status\" = 1";

            using var fbTransaction = fbConnection.BeginTransaction();
            using var fbCommand     = new FbCommand(sql, fbConnection, fbTransaction);

            fbCommand.Parameters.Add("@tenantId", _tenantId);

            using var reader = await fbCommand.ExecuteReaderAsync();

            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.Code,
                    EcfHeaders.LastName,
                    EcfHeaders.FirstName,
                    EcfHeaders.MiddleName,
                    EcfHeaders.Salutation,
                    EcfHeaders.Gender,
                    EcfHeaders.Birthdate,
                    EcfHeaders.Birthname,
                    EcfHeaders.PlaceOfBirth,
                    EcfHeaders.MaritalStatusId,
                    EcfHeaders.AddressLines,
                    EcfHeaders.PostalCode,
                    EcfHeaders.Locality,
                    //EcfHeaders.CountryId,
                    EcfHeaders.HomePhoneNumber,
                    EcfHeaders.OfficePhoneNumber,
                    EcfHeaders.EmailAddress,
                    EcfHeaders.MobileNumber,
                    //EcfHeaders.Nationality1Id,
                    //EcfHeaders.Nationality2Id,
                    EcfHeaders.NativeLanguageId,
                    EcfHeaders.CorrespondenceLanguageId);

                //EcfHeaders.ReligionId);
            }

            while (await reader.ReadAsync())
            {
                ecfTableWriter.SetValue(EcfHeaders.Id, reader["ID"]);
                ecfTableWriter.SetValue(EcfHeaders.Code, reader["Kuerzel"]);
                ecfTableWriter.SetValue(EcfHeaders.LastName, reader["Nachname"]);
                ecfTableWriter.SetValue(EcfHeaders.FirstName, reader["Vorname"]);
                ecfTableWriter.SetValue(EcfHeaders.MiddleName, reader["Vorname2"]);
                ecfTableWriter.SetValue(EcfHeaders.Salutation, reader.GetSalutation("Anrede"));
                ecfTableWriter.SetValue(EcfHeaders.Gender, reader.GetGender("Geschlecht"));
                ecfTableWriter.SetValue(EcfHeaders.Birthdate, reader.GetDate("Geburtsdatum"));
                ecfTableWriter.SetValue(EcfHeaders.Birthname, reader["Geburtsname"]);
                ecfTableWriter.SetValue(EcfHeaders.PlaceOfBirth, reader["Geburtsort"]);
                ecfTableWriter.SetValue(EcfHeaders.MaritalStatusId, reader["Ehestand"]);
                ecfTableWriter.SetValue(EcfHeaders.AddressLines, reader["Strasse"]);
                ecfTableWriter.SetValue(EcfHeaders.PostalCode, reader["PLZ"]);
                ecfTableWriter.SetValue(EcfHeaders.Locality, reader["Ort"]);
                //ecfTableWriter.SetValue(EcfHeaders.CountryId, reader["Land"]);
                ecfTableWriter.SetValue(EcfHeaders.HomePhoneNumber, reader["Telefon"]);
                ecfTableWriter.SetValue(EcfHeaders.OfficePhoneNumber, reader["TelefonDienst"]);
                ecfTableWriter.SetValue(EcfHeaders.EmailAddress, reader["Email"]);
                ecfTableWriter.SetValue(EcfHeaders.MobileNumber, reader["Mobil"]);
                //ecfTableWriter.SetValue(EcfHeaders.Nationality1Id, reader["Staatsangeh"]);
                //ecfTableWriter.SetValue(EcfHeaders.Nationality2Id, reader["Staatsangeh2"]);
                ecfTableWriter.SetValue(EcfHeaders.NativeLanguageId, reader["Muttersprache"]);
                ecfTableWriter.SetValue(EcfHeaders.CorrespondenceLanguageId, reader["Verkehrssprache"]);
                //ecfTableWriter.SetValue(EcfHeaders.ReligionId, reader["Konfession"]);

                await ecfTableWriter.WriteAsync();

                ecfRecordCounter++;
            }

            return(ecfRecordCounter);
        }
Beispiel #29
0
        private async Task <int> ExportSubjectTypes(EcfTableWriter ecfTableWriter)
        {
            await ecfTableWriter.WriteHeadersAsync(
                EcfHeaders.Id,
                EcfHeaders.Code,
                EcfHeaders.StatisticalCode,
                EcfHeaders.InternalCode,
                EcfHeaders.Name);

            await ecfTableWriter.WriteAsync("0", "FS", "00", "00", "Fremdsprache");

            await ecfTableWriter.WriteAsync("1", "REL", "01", "01", "Religion / Ethik");

            await ecfTableWriter.WriteAsync("2", "DEU", "02", "02", "Deutsch");

            await ecfTableWriter.WriteAsync("3", "MAT", "03", "03", "Mathematik");

            await ecfTableWriter.WriteAsync("4", "KUN", "04", "04", "Kunst");

            await ecfTableWriter.WriteAsync("5", "MUS", "05", "05", "Musik");

            await ecfTableWriter.WriteAsync("6", "SP", "06", "06", "Sport");

            await ecfTableWriter.WriteAsync("9", "INF", "09", "09", "Informatik");

            await ecfTableWriter.WriteAsync("10", "PHI", "10", "10", "Philosophie");

            await ecfTableWriter.WriteAsync("11", "GES", "11", "11", "Geschichte");

            await ecfTableWriter.WriteAsync("12", "PHY", "12", "12", "Physik");

            await ecfTableWriter.WriteAsync("13", "CHE", "13", "13", "Chemie");

            await ecfTableWriter.WriteAsync("14", "BIO", "14", "14", "Biologie");

            await ecfTableWriter.WriteAsync("15", "ERD", "15", "15", "Erdkunde");

            await ecfTableWriter.WriteAsync("16", "SOZ", "16", "16", "Sozialkunde");

            await ecfTableWriter.WriteAsync("17", "WIR", "17", "17", "Wirtschaft");

            await ecfTableWriter.WriteAsync("18", "POL", "18", "18", "Politik");

            await ecfTableWriter.WriteAsync("19", "DSP", "19", "19", "Darstellendes Spiel");

            await ecfTableWriter.WriteAsync("20", "EREL", "20", "20", "Evangelische Religion");

            await ecfTableWriter.WriteAsync("21", "KREL", "21", "21", "Katholische Religion");

            await ecfTableWriter.WriteAsync("26", "TECH", "26", "26", "Technik");

            await ecfTableWriter.WriteAsync("27", "PÄD", "27", "27", "Pädagogik");

            await ecfTableWriter.WriteAsync("28", "SPT", "28", "28", "Sport - Theorie");

            await ecfTableWriter.WriteAsync("29", "BWL/RW", "29", "29", "BWL / RW");

            await ecfTableWriter.WriteAsync("30", "BWL/VWL", "30", "30", "BWL / VWL");

            await ecfTableWriter.WriteAsync("31", "VWL", "31", "31", "VWL");

            await ecfTableWriter.WriteAsync("32", "SEM", "32", "32", "Seminar");

            await ecfTableWriter.WriteAsync("33", "GSU", "33", "33", "Gesundheit");

            await ecfTableWriter.WriteAsync("34", "PSY", "34", "34", "Psychologie");

            await ecfTableWriter.WriteAsync("35", "RECH", "35", "35", "Recht");

            return(await Task.FromResult(30));
        }
Beispiel #30
0
        private async Task <int> ExportStudentSubjects(FbConnection fbConnection, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            string sql;

            if (_version >= 7)
            {
                sql =
                    $"select F.\"ID\", F.\"Klasse\", S.\"ID\" as \"Schueler\", F.\"KursNr\", F.\"Unterrichtsart\", F.\"Fachstatus\", F.\"Fach\", " +
                    $"F.\"Niveau\", F.\"Schwerpunkt\", K.\"Zugang\", K.\"Abgang\", L.\"ID\" as \"Lehrer\" from \"SchuelerFachdaten\" as F " +
                    $"join \"SchuelerZeitraeume\" as Z " +
                    $"on Z.\"ID\" = F.\"SchuelerZeitraumID\" " +
                    $"join \"SchuelerKlassen\" as K " +
                    $"on Z.\"ID\" = K.\"SchuelerZeitraumID\" " +
                    $"join \"Schueler\" as S " +
                    $"on Z.\"Schueler\" = S.\"ID\" " +
                    $"left join \"Lehrer\" as L " +
                    $"on F.\"Lehrer\" = L.\"ID\" " +
                    $"where Z.\"Mandant\" = @tenantId and Z.\"Zeitraum\" = @schoolTermId and S.\"Status\" in (2, 3) and (S.\"IDIntern\" is NULL) " +
                    $"union all " +
                    $"select F.\"ID\", F.\"Klasse\", S.\"IDIntern\" as \"Schueler\", F.\"KursNr\", F.\"Unterrichtsart\", F.\"Fachstatus\", F.\"Fach\", " +
                    $"F.\"Niveau\", F.\"Schwerpunkt\", K.\"Zugang\", K.\"Abgang\", L.\"ID\" as \"Lehrer\" from \"SchuelerFachdaten\" as F " +
                    $"join \"SchuelerZeitraeume\" as Z " +
                    $"on Z.\"ID\" = F.\"SchuelerZeitraumID\" " +
                    $"join \"SchuelerKlassen\" as K " +
                    $"on Z.\"ID\" = K.\"SchuelerZeitraumID\" " +
                    $"join \"Schueler\" as S " +
                    $"on Z.\"Schueler\" = S.\"IDIntern\" " +
                    $"join \"Schueler\" as I " +
                    $"on I.\"ID\" = S.\"IDIntern\" " +
                    $"left join \"Lehrer\" as L " +
                    $"on F.\"Lehrer\" = L.\"ID\" and L.\"Status\" = 1 " +
                    $"where Z.\"Mandant\" = @tenantId and Z.\"Zeitraum\" = @schoolTermId and I.\"Status\" in (2, 3) and not (S.\"IDIntern\" is NULL)";
            }
            else
            {
                sql =
                    $"select F.\"ID\", F.\"Klasse\", F.\"Schueler\", F.\"KursNr\", F.\"Unterrichtsart\", F.\"Fachstatus\", F.\"Fach\", " +
                    $"F.\"Niveau\", F.\"Schwerpunkt\", K.\"Zugang\", K.\"Abgang\", L.\"ID\" as \"Lehrer\" from \"SchuelerFachdaten\" as F " +
                    $"join \"SchuelerZeitraeume\" as Z " +
                    $"on Z.\"Mandant\" = F.\"Mandant\" and Z.\"Klasse\" = F.\"Klasse\" and Z.\"Schueler\" = F.\"Schueler\" and Z.\"Zeitraum\" = F.\"Zeitraum\" " +
                    $"join \"SchuelerKlassen\" as K " +
                    $"on Z.\"Mandant\" = K.\"Mandant\" and Z.\"Klasse\" = K.\"Klasse\" and Z.\"Schueler\" = K.\"Schueler\" " +
                    $"join \"Schueler\" as S " +
                    $"on Z.\"Mandant\" = S.\"Mandant\" and Z.\"Schueler\" = S.\"ID\" " +
                    $"left join \"Lehrer\" as L " +
                    $"on F.\"Mandant\" = L.\"Mandant\" and F.\"Lehrer\" = L.\"ID\" and L.\"Status\" = 1 " +
                    $"where Z.\"Mandant\" = @tenantId and Z.\"Zeitraum\" = @schoolTermId and S.\"Status\" in (2, 3)";
            }

            using var fbTransaction = fbConnection.BeginTransaction();
            using var fbCommand     = new FbCommand(sql, fbConnection, fbTransaction);

            fbCommand.Parameters.Add("@tenantId", _tenantId);
            fbCommand.Parameters.Add("@schoolTermId", _schoolTermId);

            using var reader = await fbCommand.ExecuteReaderAsync();

            var ecfRecordCounter = 0;

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.SchoolClassId,
                    EcfHeaders.StudentId,
                    EcfHeaders.CourseNo,
                    EcfHeaders.CourseTypeId,
                    EcfHeaders.CourseCategoryId,
                    EcfHeaders.SubjectId,
                    EcfHeaders.SubjectLevelId,
                    EcfHeaders.SubjectFocusId,
                    EcfHeaders.TeacherId,
                    EcfHeaders.EntryDate,
                    EcfHeaders.ExitDate);
            }

            while (await reader.ReadAsync())
            {
                ecfTableWriter.SetValue(EcfHeaders.Id, reader["ID"]);
                ecfTableWriter.SetValue(EcfHeaders.SchoolClassId, reader["Klasse"]);
                ecfTableWriter.SetValue(EcfHeaders.StudentId, reader["Schueler"]);
                ecfTableWriter.SetValue(EcfHeaders.CourseNo, reader.GetShortOrDefault("KursNr", 0));
                ecfTableWriter.SetValue(EcfHeaders.CourseTypeId, reader["Unterrichtsart"]);
                ecfTableWriter.SetValue(EcfHeaders.CourseCategoryId, reader["Fachstatus"]);
                ecfTableWriter.SetValue(EcfHeaders.SubjectId, reader["Fach"]);
                ecfTableWriter.SetValue(EcfHeaders.SubjectLevelId, reader["Niveau"]);
                ecfTableWriter.SetValue(EcfHeaders.SubjectFocusId, reader["Schwerpunkt"]);
                ecfTableWriter.SetValue(EcfHeaders.TeacherId, reader["Lehrer"]);
                ecfTableWriter.SetValue(EcfHeaders.EntryDate, reader.GetDate("Zugang"));
                ecfTableWriter.SetValue(EcfHeaders.ExitDate, reader.GetDate("Abgang"));

                await ecfTableWriter.WriteAsync();

                ecfRecordCounter++;
            }

            return(ecfRecordCounter);
        }