protected override async Task HandleSupervisionEvent(SupervisionEvent @event, IIccOutput outputSettings)
        {
            Configure(outputSettings);

            var mapping = outputSettings.WeekMapping;
            var weeks   = mapping.Weeks;

            if (mapping.UseWeekModulo)
            {
                weeks = weekMappingHelper.ComputeMapping(mapping.Weeks);
            }

            var supervisions = new List <TimetableSupervisionData>();

            foreach (var supervision in @event.Supervisions)
            {
                var supervisionWeeks = supervision.Weeks ?? Enumerable.Range(1, outputSettings.WeekMapping.Weeks.Count);

                if (string.IsNullOrEmpty(supervision.Teacher))
                {
                    logger.LogDebug("Skipping supervision with empty teacher.");
                    continue;
                }

                var namedWeeks = supervisionWeeks
                                 .Select(x => weeks.ContainsKey(x) ? weeks[x] : null)
                                 .Where(x => x != null)
                                 .Distinct();

                foreach (var week in namedWeeks)
                {
                    supervisions.Add(new TimetableSupervisionData
                    {
                        Id       = Guid.NewGuid().ToString(),
                        Lesson   = supervision.Lesson,
                        Day      = supervision.WeekDay,
                        Location = supervision.Location,
                        Teacher  = supervision.Teacher,
                        IsBefore = true,
                        Week     = week
                    });
                }
            }

            var response = await iccImporter.ImportSupervisionsAsync(outputSettings.SupervisionPeriod, supervisions.ToList());

            await HandleResponseAsync(response);
        }
Exemple #2
0
        public async Task <ImportResult> ImportSupervisionsAsync(UntisExportResult result, Period period)
        {
            ConfigureImporter();

            var supervisions = new List <TimetableSupervisionData>();

            var weeks       = WeekResolver.SchoolWeekToCalendarWeek(result);
            var periodWeeks = ComputePeriodWeeks(result, weeks, period);

            foreach (var floor in result.SupervisionFloors)
            {
                foreach (var supervision in floor.Supervisions)
                {
                    var supervisionWeeks = weeks
                                           .Where(x => supervision.Weeks.Contains(x.SchoolYearWeek))
                                           .Select(x => x.CalendarWeek)
                                           .Where(x => periodWeeks.Contains(x))
                                           .ToList();

                    if (supervisionWeeks.Any())
                    {
                        var data = new TimetableSupervisionData
                        {
                            Id       = Guid.NewGuid().ToString(),
                            Day      = supervision.Day,
                            Weeks    = supervisionWeeks,
                            IsBefore = true,
                            Lesson   = supervision.Lesson,
                            Teacher  = supervision.Teacher,
                            Location = floor.Name
                        };

                        supervisions.Add(data);
                    }
                }
            }

            var response = await importer.ImportSupervisionsAsync(period.Name, supervisions);

            return(HandleResponse(response));
        }