Exemplo n.º 1
0
 public Result UpdateLocation(Location location, RoomAssignment roomAssignment)
 {
     try
     {
         databaseContext.Locations.Update(location);
         if (roomAssignment != null)
         {
             databaseContext.RoomAssignments.Update(roomAssignment);
         }
         else
         {
             Log.Warning("Error updating room assignment for location id {0} because there is no assignment created! Creating assignment...", location.Id);
             databaseContext.RoomAssignments.Add(new RoomAssignment()
             {
                 LocationId = location.Id,
                 RoomIds    = ""
             });
         }
         databaseContext.SaveChanges();
         return(new Result());
     }
     catch (Exception ex)
     {
         return(new Result(ex));
     }
 }
Exemplo n.º 2
0
        internal void AddAssignment(string roomNumber, string orgName, bool needInternal, bool needExternal)
        {
            var room = _db.Rooms.SingleOrDefault(r => r.Number.Trim().Equals(roomNumber));

            if (room == null)
            {
                return;
            }

            var org = _db.Organisers.SingleOrDefault(o => o.ShortName.Equals(orgName));

            if (org == null)
            {
                return;
            }

            var assignment = _db.RoomAssignments.SingleOrDefault(a => a.Organiser.Id == org.Id && a.Room.Id == room.Id);

            if (assignment == null)
            {
                assignment = new RoomAssignment
                {
                    Room      = room,
                    Organiser = org
                };

                _db.RoomAssignments.Add(assignment);
            }

            assignment.InternalNeedConfirmation = needInternal;
            assignment.ExternalNeedConfirmation = needExternal;

            _db.SaveChanges();
        }
Exemplo n.º 3
0
        public PartialViewResult LinkOrganiser(Guid roomId, Guid orgId)
        {
            var room = Db.Rooms.SingleOrDefault(x => x.Id == roomId);
            var org  = Db.Organisers.SingleOrDefault(x => x.Id == orgId);

            if (room != null && org != null)
            {
                var assign = room.Assignments.FirstOrDefault(x => x.Organiser.Id == org.Id);
                if (assign == null)
                {
                    assign = new RoomAssignment
                    {
                        ExternalNeedConfirmation = true,
                        InternalNeedConfirmation = true,
                        Room      = room,
                        Organiser = org
                    };
                    Db.RoomAssignments.Add(assign);
                    Db.SaveChanges();
                }


                return(PartialView("_LinkRow", assign));
            }



            return(PartialView("_EmptyRow"));
        }
Exemplo n.º 4
0
        public PartialViewResult AddAssignment(ICollection <Guid> roomIds, string orgName, bool needExternal, bool needInternal)
        {
            var org = Db.Organisers.SingleOrDefault(o => o.ShortName.Equals(orgName));

            if (org != null && roomIds != null)
            {
                foreach (var roomId in roomIds)
                {
                    var room = Db.Rooms.SingleOrDefault(r => r.Id == roomId);
                    if (room != null)
                    {
                        var assignment = room.Assignments.SingleOrDefault(a => a.Organiser.Id == org.Id);
                        if (assignment == null)
                        {
                            assignment           = new RoomAssignment();
                            assignment.Organiser = org;
                            room.Assignments.Add(assignment);
                        }
                        assignment.ExternalNeedConfirmation = needExternal;
                        assignment.InternalNeedConfirmation = needInternal;
                    }
                }
                Db.SaveChanges();
            }


            var model = Db.Rooms.OrderBy(r => r.Number).ToList();

            ViewBag.UserRight = GetUserRight(User.Identity.Name, "FK 09");


            return(PartialView("_RoomInfoList", model));
        }
 public RoomControl(RoomPlan roomPlan, ProjectFile assignedProject, Point insertPoint)
 {
     InitializeComponent();
     RoomAssignment = new RoomAssignment(roomPlan, assignedProject, (int)insertPoint.X, (int)insertPoint.Y);
     if (RoomAssignment.RoomPlan.RoomPlanImage == null)
     {
         RoomAssignment.RoomPlan.SaveRoomPlanImage();
     }
 }
 public RoomControl(RoomAssignment roomAssignment, bool showNoteIcon = true)
 {
     InitializeComponent();
     RoomAssignment = roomAssignment;
     if (RoomAssignment.RoomPlan.RoomPlanImage == null)
     {
         RoomAssignment.RoomPlan.SaveRoomPlanImage();
     }
     if (!showNoteIcon)
     {
         noteIcon.Source = null;
     }
 }
        private RoomAssignment GetUpdatedRoomAssignment(LocationDto location)
        {
            RoomAssignment target = locationRepository.GetRoomAssignmentForLocation(location.Id);

            if (target != null)
            {
                string roomIds = "";
                foreach (RoomDto room in location.Rooms)
                {
                    roomIds += roomIds != "" ? string.Format(";{0}", room.Id) : room.Id.ToString();
                }
                target.RoomIds = roomIds;
            }

            return(target);
        }
        private void RoomControl_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            roomControlClicked = true;
            FloorPlanViewModel vm = DataContext as FloorPlanViewModel;

            if (selectedRoomControl != null)
            {
                selectedRoomControl.Background = Brushes.Transparent;
            }
            RoomControl roomControl = sender as RoomControl;

            RoomAssignment roomAssignment = vm.FloorPlan.RoomAssignments.FirstOrDefault(x => x.Control.Tag == roomControl.Tag);

            vm.SelectedRoomAssignment = roomAssignment;

            roomControl.Background = new SolidColorBrush(Color.FromArgb(64, 255, 128, 0));
            selectedRoomControl    = roomControl;
            vm.SelectedTabIndex    = 1;
        }
Exemplo n.º 9
0
        public ActionResult Create(Room model)
        {
            if (ModelState.IsValid)
            {
                Db.Entry(model).State = EntityState.Added;

                // Verknüpfung anlegen
                var assign = new RoomAssignment
                {
                    ExternalNeedConfirmation = true,
                    InternalNeedConfirmation = true,
                    Room      = model,
                    Organiser = GetMyOrganisation()
                };
                Db.RoomAssignments.Add(assign);
                Db.SaveChanges();
            }

            return(RedirectToAction("Rooms", "Organiser"));
        }
Exemplo n.º 10
0
        private Room InitRoom(TimeTableDbContext db, Raum raum, ActivityOrganiser organiser)
        {
            var room = db.Rooms.FirstOrDefault(r => r.Number.Equals(raum.Nummer));

            if (room == null)
            {
                room = new Room
                {
                    Number      = raum.Nummer,
                    Capacity    = raum.Kapazitaet,
                    Description = raum.Beschreibung,
                    Owner       = raum.Nutzer,
                };
                db.Rooms.Add(room);
                db.SaveChanges();

                _numRooms++;
            }


            var assignment = db.RoomAssignments.SingleOrDefault(x =>
                                                                x.Room.Id == room.Id &&
                                                                x.Organiser.Id == organiser.Id);

            if (assignment == null)
            {
                assignment = new RoomAssignment
                {
                    Organiser = organiser,
                    InternalNeedConfirmation = false,   // offen für interne
                    ExternalNeedConfirmation = true     // geschlossen für externe
                };

                room.Assignments.Add(assignment);
                db.RoomAssignments.Add(assignment);
                db.SaveChanges();
            }

            return(room);
        }
Exemplo n.º 11
0
        public List <RoomDto> GetAssignedRoomsForLocation(int locationId)
        {
            List <RoomDto> assignedRooms  = new List <RoomDto>();
            RoomAssignment roomAssignment = locationRepository.GetRoomAssignmentForLocation(locationId);

            if (roomAssignment != null)
            {
                string[] roomIdsRaw = roomAssignment.RoomIds.Split(';');
                foreach (string roomIdRaw in roomIdsRaw)
                {
                    if (int.TryParse(roomIdRaw, out int roomId))
                    {
                        RoomDto room = ToRoomDto(roomRepository.GetRoomById(roomId));
                        if (room != null)
                        {
                            assignedRooms.Add(room);
                        }
                    }
                }
            }

            return(assignedRooms.OrderBy(x => x.Name).ToList());
        }
Exemplo n.º 12
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="roomId"></param>
        /// <param name="orgName"></param>
        /// <returns></returns>
        public ActionResult AddLink(Guid roomId, string orgName)
        {
            var room = Db.Rooms.SingleOrDefault(x => x.Id == roomId);
            var org  = Db.Organisers.SingleOrDefault(x => x.ShortName.Equals(orgName));

            if (room != null && org != null)
            {
                var assign = room.Assignments.FirstOrDefault(x => x.Organiser.Id == org.Id);
                if (assign == null)
                {
                    assign = new RoomAssignment
                    {
                        ExternalNeedConfirmation = false,
                        InternalNeedConfirmation = false,
                        Room      = room,
                        Organiser = org
                    };
                    Db.RoomAssignments.Add(assign);
                    Db.SaveChanges();
                }
            }

            return(RedirectToAction("Links", new { id = roomId }));
        }
Exemplo n.º 13
0
        public string ImportReservation(ScheduleCourse scheduleCourse)
        {
            string msg;

            _Logger.DebugFormat("Importiere Raumreservierung: {0}", scheduleCourse.Name);
            _report.AppendFormat("<h1>Erzeuge LV \"{0} ({1})\" - [{2}]</h1>", scheduleCourse.Name, scheduleCourse.ShortName,
                                 scheduleCourse.CourseId);
            _report.AppendLine();

            var db = new TimeTableDbContext();

            var organiser = db.Organisers.SingleOrDefault(s => s.Id == _orgId);
            var sem       = db.Semesters.SingleOrDefault(s => s.Id == _semId);

            long msStart = sw.ElapsedMilliseconds;
            var  course  = new Reservation
            {
                ExternalSource = "JSON",
                ExternalId     = scheduleCourse.CourseId,
                Organiser      = organiser,
                ShortName      = scheduleCourse.ShortName,
                Name           = scheduleCourse.Name,
                Description    = scheduleCourse.Description,
                Occurrence     = null,
                IsInternal     = true,
            };

            // Kurs sofort speichern, damit die ID gesichert ist
            db.Activities.Add(course);
            db.SaveChanges();
            long msEnd = sw.ElapsedMilliseconds;

            _Logger.DebugFormat("Dauer: {0}ms", msEnd - msStart);
            msStart = msEnd;

            _report.AppendLine("<h2>Bezeichnungen</h2>");
            _report.AppendLine("<table>");
            _report.AppendFormat("<tr><td>Name</td><td>{0}</td></tr>", course.Name);
            _report.AppendFormat("<tr><td>Kurzname</td><td>{0}</td></tr>", course.ShortName);
            _report.AppendFormat("<tr><td>Beschreibung</td><td>{0}</td></tr>", course.Description);
            _report.AppendLine("</table>");


            // jetzt die Gruppen
            // Eine Raumreservierung hat keine Gruppen

            db.SaveChanges();

            // zum Schluss die Termine
            _report.AppendLine("<h2>Neue Termine</h2>");
            _report.AppendLine("<table>");

            foreach (var scheduleDate in scheduleCourse.Dates)
            {
                // Der Tag
                var occDate = scheduleDate.Begin.Date;

                bool isVorlesung = true;
                foreach (var sd in _semester.Dates)
                {
                    // Wenn der Termin in eine vorlesungsfreie Zeit fällt, dann nicht importieren
                    if (sd.From.Date <= occDate.Date &&
                        occDate.Date <= sd.To.Date &&
                        sd.HasCourses == false)
                    {
                        isVorlesung = false;
                    }
                }

                if (isVorlesung)
                {
                    var occ = new ActivityDate
                    {
                        Begin      = scheduleDate.Begin,
                        End        = scheduleDate.End,
                        Activity   = course,
                        Occurrence = null,
                    };
                    _report.AppendLine("<tr>");
                    _report.AppendFormat("<td>{0}</td><td>{1}</td><td>{2}</td>", occ.Begin.ToShortDateString(), occ.Begin.ToShortTimeString(), occ.End.ToShortTimeString());

                    _report.AppendFormat("<td>");
                    foreach (var scheduleDateRoom in scheduleDate.Rooms)
                    {
                        _report.AppendFormat("<p>{0}", scheduleDateRoom.RoomNumber);
                        if (!string.IsNullOrEmpty(scheduleDateRoom.RoomNumber))
                        {
                            var room = db.Rooms.SingleOrDefault(r => r.Number.Equals(scheduleDateRoom.RoomNumber));
                            if (room == null)
                            {
                                room = new Room
                                {
                                    Number      = scheduleDateRoom.RoomNumber,
                                    Capacity    = 0,
                                    Description = string.Empty,
                                    Owner       = string.Empty,
                                };
                                db.Rooms.Add(room);
                                db.SaveChanges();

                                _numRooms++;
                                _report.AppendFormat(" !!!NEUER RAUM!!!");
                            }


                            var assignment = db.RoomAssignments.SingleOrDefault(x =>
                                                                                x.Room.Id == room.Id &&
                                                                                x.Organiser.Id == organiser.Id);
                            if (assignment == null)
                            {
                                assignment = new RoomAssignment
                                {
                                    Organiser = organiser,
                                    InternalNeedConfirmation = false, // offen für interne
                                    ExternalNeedConfirmation = true   // geschlossen für externe
                                };

                                room.Assignments.Add(assignment);
                                db.RoomAssignments.Add(assignment);
                                db.SaveChanges();
                            }

                            occ.Rooms.Add(room);
                            _report.AppendFormat("</p>");
                        }
                    }
                    _report.AppendFormat("</td>");

                    _report.AppendFormat("<td>");
                    foreach (var scheduleDateLecturer in scheduleDate.Lecturers)
                    {
                        _report.AppendFormat("<p>{0} ({1})", scheduleDateLecturer.Name, scheduleDateLecturer.ShortName);

                        var lecturer = organiser.Members.SingleOrDefault(l => l.ShortName.Equals(scheduleDateLecturer.ShortName));
                        if (lecturer == null)
                        {
                            lecturer = new OrganiserMember
                            {
                                ShortName   = scheduleDateLecturer.ShortName,
                                Name        = scheduleDateLecturer.Name,
                                Role        = String.Empty,
                                Description = String.Empty
                            };
                            organiser.Members.Add(lecturer);
                            db.Members.Add(lecturer);
                            db.SaveChanges();
                            _numLecturers++;
                            _report.AppendFormat(" !!!NEUER DOZENT!!!");
                        }

                        occ.Hosts.Add(lecturer);
                        _report.AppendFormat("</p>");
                    }
                    _report.AppendFormat("</td>");

                    db.ActivityDates.Add(occ);

                    _report.AppendLine();
                    _report.AppendLine("</tr>");
                }
            }

            _report.AppendLine("</table>");
            db.SaveChanges();

            msEnd = sw.ElapsedMilliseconds;
            _Logger.DebugFormat("Dauer {0}ms", msEnd - msStart);

            msg = $"Raumreservierung {course.ShortName} mit Terminen importiert";

            return(msg);
        }
 partial void InsertRoomAssignment(RoomAssignment instance);
 partial void UpdateRoomAssignment(RoomAssignment instance);
 partial void DeleteRoomAssignment(RoomAssignment instance);
 private void detach_RoomAssignments(RoomAssignment entity)
 {
     this.SendPropertyChanging();
     entity.Staff = null;
 }
 private void detach_RoomAssignments(RoomAssignment entity)
 {
     this.SendPropertyChanging();
     entity.ExaminationRoom = null;
 }
Exemplo n.º 19
0
        public string ImportCourse(ScheduleCourse scheduleCourse)
        {
            string msg;

            _Logger.DebugFormat("Importiere Fach: {0}", scheduleCourse.Name);
            _report.AppendFormat("<h1>Erzeuge LV \"{0} ({1})\" - [{2}]</h1>", scheduleCourse.Name, scheduleCourse.ShortName,
                                 scheduleCourse.CourseId);
            _report.AppendLine();

            var db = new TimeTableDbContext();

            var organiser = db.Organisers.SingleOrDefault(s => s.Id == _orgId);
            var sem       = db.Semesters.SingleOrDefault(s => s.Id == _semId);

            long msStart = sw.ElapsedMilliseconds;
            var  course  = new Course
            {
                ExternalSource = "JSON",
                ExternalId     = scheduleCourse.CourseId,
                Organiser      = organiser,
                ShortName      = scheduleCourse.ShortName,
                Name           = scheduleCourse.Name,
                Description    = scheduleCourse.Description,
                Occurrence     = CreateDefaultOccurrence(scheduleCourse.SeatRestriction ?? 0),
                IsInternal     = true,
            };

            // Kurs sofort speichern, damit die ID gesichert ist
            db.Activities.Add(course);
            db.SaveChanges();
            long msEnd = sw.ElapsedMilliseconds;

            _Logger.DebugFormat("Dauer: {0}ms", msEnd - msStart);
            msStart = msEnd;

            _report.AppendLine("<h2>Bezeichnungen</h2>");
            _report.AppendLine("<table>");
            _report.AppendFormat("<tr><td>Name</td><td>{0}</td></tr>", course.Name);
            _report.AppendFormat("<tr><td>Kurzname</td><td>{0}</td></tr>", course.ShortName);
            _report.AppendFormat("<tr><td>Beschreibung</td><td>{0}</td></tr>", course.Description);
            _report.AppendLine("</table>");


            // jetzt die Gruppen
            foreach (var scheduleGroup in scheduleCourse.Groups)
            {
                // Fakultät ermitteln
                var org = db.Organisers.SingleOrDefault(x => x.ShortName.Equals(scheduleGroup.FacultyName));

                // Studiengang innerhalb der Fakultät ermitteln
                var curr = org.Curricula.SingleOrDefault(x => x.ShortName.Equals(scheduleGroup.CurriculumShortName));
                if (curr == null)
                {
                    curr = new TimeTable.Data.Curriculum
                    {
                        ShortName = scheduleGroup.CurriculumShortName,
                        Name      = scheduleGroup.CurriculumName,
                        Organiser = org
                    };
                    db.Curricula.Add(curr);
                    db.SaveChanges();
                }

                // Studiengruppe innerhalb des Studiengangs ermitteln
                var groupName = scheduleGroup.GroupName;

                // Sonderlocke FK 11
                // aus der LV-Nummer das Semester raussuchen

                /* OHI 20180720: wieder ausgebaut, weil Schnittstelle jetzt sauber befüllt ist
                 * if (org.ShortName.Equals("FK 11"))
                 * {
                 *  if (!string.IsNullOrEmpty(course.ShortName))
                 *  {
                 *      groupName = course.ShortName[1].ToString();
                 *
                 *  }
                 *  else
                 *  {
                 *      groupName = "#N.V.";
                 *  }
                 * }
                 */

                var currGroup = curr.CurriculumGroups.SingleOrDefault(x => x.Name.Equals(groupName));
                if (currGroup == null)
                {
                    currGroup = new CurriculumGroup
                    {
                        Curriculum     = curr,
                        Name           = groupName,
                        IsSubscribable = true,
                    };
                    db.CurriculumGroups.Add(currGroup);
                    db.SaveChanges();
                }

                // Kapazitätsgruppe innerhalb der Studiengruppe ermitteln
                CapacityGroup capGroup = null;
                if (string.IsNullOrEmpty(scheduleGroup.SubGroupName))
                {
                    capGroup = currGroup.CapacityGroups.SingleOrDefault(x => string.IsNullOrEmpty(x.Name));
                    if (capGroup == null)
                    {
                        capGroup = new CapacityGroup
                        {
                            CurriculumGroup = currGroup,
                            Name            = string.Empty,
                            InSS            = scheduleGroup.SemesterName.StartsWith("SS"),
                            InWS            = scheduleGroup.SemesterName.StartsWith("WS")
                        };
                        db.CapacityGroups.Add(capGroup);
                        db.SaveChanges();
                    }
                }
                else
                {
                    capGroup = currGroup.CapacityGroups.SingleOrDefault(x => !string.IsNullOrEmpty(x.Name) && x.Name.Equals(scheduleGroup.SubGroupName));
                    if (capGroup == null)
                    {
                        capGroup = new CapacityGroup
                        {
                            CurriculumGroup = currGroup,
                            Name            = scheduleGroup.SubGroupName,
                            InSS            = scheduleGroup.SemesterName.StartsWith("SS"),
                            InWS            = scheduleGroup.SemesterName.StartsWith("WS")
                        };
                        db.CapacityGroups.Add(capGroup);
                        db.SaveChanges();
                    }
                }

                // Semester ermitteln
                var semester = db.Semesters.SingleOrDefault(x => x.Name.Equals(scheduleGroup.SemesterName));

                if (semester.Id == sem.Id)
                {
                    // jetzt können wir die Semestergruppe ermitteln
                    var semGroup =
                        db.SemesterGroups.SingleOrDefault(x => x.Semester.Id == semester.Id &&
                                                          x.CapacityGroup.Id == capGroup.Id);
                    if (semGroup == null)
                    {
                        semGroup = new SemesterGroup
                        {
                            Semester      = semester,
                            CapacityGroup = capGroup,
                            IsAvailable   = false // zu Beginn nicht freigegeben
                        };
                        db.SemesterGroups.Add(semGroup);
                        db.SaveChanges();
                    }

                    course.SemesterGroups.Add(semGroup);
                    semGroup.Activities.Add(course);

                    // zu jeder Semestergruppe gibt es dann noch eine
                    // Gruppe für Platzverlosung
                    var occGroup =
                        course.Occurrence.Groups.SingleOrDefault(
                            gg => gg.SemesterGroups.Any(s => s.Id == semGroup.Id));

                    if (occGroup == null)
                    {
                        occGroup = new OccurrenceGroup
                        {
                            Capacity            = 0,
                            FitToCurriculumOnly = true,
                            Occurrence          = course.Occurrence
                        };
                        occGroup.SemesterGroups.Add(semGroup);
                        semGroup.OccurrenceGroups.Add(occGroup);
                        course.Occurrence.Groups.Add(occGroup);
                        db.OccurrenceGroups.Add(occGroup);
                    }

                    // NEU: Chapter und Topics
                    if (!string.IsNullOrEmpty(scheduleGroup.ChapterName) &&
                        !string.IsNullOrEmpty(scheduleGroup.TopicName))
                    {
                        var chapter = curr.Chapters.FirstOrDefault(x => x.Name.Equals(scheduleGroup.ChapterName));
                        if (chapter == null)
                        {
                            chapter = new CurriculumChapter
                            {
                                Curriculum = curr,
                                Name       = scheduleGroup.ChapterName
                            };
                            db.CurriculumChapters.Add(chapter);
                        }

                        var topic = chapter.Topics.FirstOrDefault(x => x.Name.Equals(scheduleGroup.TopicName));
                        if (topic == null)
                        {
                            topic = new CurriculumTopic
                            {
                                Chapter = chapter,
                                Name    = scheduleGroup.TopicName
                            };
                            db.CurriculumTopics.Add(topic);
                        }

                        var semTopic = db.SemesterTopics.FirstOrDefault(x =>
                                                                        x.Semester.Id == sem.Id && x.Topic.Id == topic.Id);

                        if (semTopic == null)
                        {
                            semTopic = new SemesterTopic
                            {
                                Semester = sem,
                                Topic    = topic,
                            };
                            db.SemesterTopics.Add(semTopic);
                        }

                        semTopic.Activities.Add(course);
                    }
                }
                // else => Semestergruppe wird nicht angelegt
            }

            db.SaveChanges();

            if (!course.SemesterGroups.Any())
            {
                _Logger.ErrorFormat("Kurs {0} ohne Gruppe", scheduleCourse.CourseId);
            }

            // zum Schluss die Termine
            _report.AppendLine("<h2>Neue Termine</h2>");
            _report.AppendLine("<table>");

            foreach (var scheduleDate in scheduleCourse.Dates)
            {
                // Der Tag
                var occDate = scheduleDate.Begin.Date;

                bool isVorlesung = true;
                foreach (var sd in _semester.Dates)
                {
                    // Wenn der Termin in eine vorlesungsfreie Zeit fällt, dann nicht importieren
                    if (sd.From.Date <= occDate.Date &&
                        occDate.Date <= sd.To.Date &&
                        sd.HasCourses == false)
                    {
                        isVorlesung = false;
                    }
                }

                if (isVorlesung)
                {
                    var occ = new ActivityDate
                    {
                        Begin      = scheduleDate.Begin,
                        End        = scheduleDate.End,
                        Activity   = course,
                        Occurrence = CreateDefaultOccurrence(),
                    };
                    _report.AppendLine("<tr>");
                    _report.AppendFormat("<td>{0}</td><td>{1}</td><td>{2}</td>", occ.Begin.ToShortDateString(), occ.Begin.ToShortTimeString(), occ.End.ToShortTimeString());

                    _report.AppendFormat("<td>");
                    foreach (var scheduleDateRoom in scheduleDate.Rooms)
                    {
                        _report.AppendFormat("<p>{0}", scheduleDateRoom.RoomNumber);
                        if (!string.IsNullOrEmpty(scheduleDateRoom.RoomNumber))
                        {
                            var room = db.Rooms.SingleOrDefault(r => r.Number.Equals(scheduleDateRoom.RoomNumber));
                            if (room == null)
                            {
                                room = new Room
                                {
                                    Number      = scheduleDateRoom.RoomNumber,
                                    Capacity    = 0,
                                    Description = string.Empty,
                                    Owner       = string.Empty,
                                };
                                db.Rooms.Add(room);
                                db.SaveChanges();

                                _numRooms++;
                                _report.AppendFormat(" !!!NEUER RAUM!!!");
                            }


                            var assignment = db.RoomAssignments.SingleOrDefault(x =>
                                                                                x.Room.Id == room.Id &&
                                                                                x.Organiser.Id == organiser.Id);
                            if (assignment == null)
                            {
                                assignment = new RoomAssignment
                                {
                                    Organiser = organiser,
                                    InternalNeedConfirmation = false, // offen für interne
                                    ExternalNeedConfirmation = true   // geschlossen für externe
                                };

                                room.Assignments.Add(assignment);
                                db.RoomAssignments.Add(assignment);
                                db.SaveChanges();
                            }

                            occ.Rooms.Add(room);
                            _report.AppendFormat("</p>");
                        }
                    }
                    _report.AppendFormat("</td>");

                    _report.AppendFormat("<td>");
                    foreach (var scheduleDateLecturer in scheduleDate.Lecturers)
                    {
                        _report.AppendFormat("<p>{0} ({1})", scheduleDateLecturer.Name, scheduleDateLecturer.ShortName);

                        var lecturer = organiser.Members.SingleOrDefault(l => l.ShortName.Equals(scheduleDateLecturer.ShortName));
                        if (lecturer == null)
                        {
                            lecturer = new OrganiserMember
                            {
                                ShortName   = scheduleDateLecturer.ShortName,
                                Name        = scheduleDateLecturer.Name,
                                Role        = String.Empty,
                                Description = String.Empty
                            };
                            organiser.Members.Add(lecturer);
                            db.Members.Add(lecturer);
                            db.SaveChanges();
                            _numLecturers++;
                            _report.AppendFormat(" !!!NEUER DOZENT!!!");
                        }

                        occ.Hosts.Add(lecturer);
                        _report.AppendFormat("</p>");
                    }
                    _report.AppendFormat("</td>");

                    db.ActivityDates.Add(occ);

                    _report.AppendLine();
                    _report.AppendLine("</tr>");
                }
            }

            _report.AppendLine("</table>");
            db.SaveChanges();

            msEnd = sw.ElapsedMilliseconds;
            _Logger.DebugFormat("Dauer {0}ms", msEnd - msStart);

            msg = $"Kurs {course.ShortName} mit Terminen importiert";

            return(msg);
        }
Exemplo n.º 20
0
        public string UpdateCourse(Course c, ScheduleCourse scheduleCourse)
        {
            string msg;

            _Logger.DebugFormat("Aktualisiere Fach: {0}", scheduleCourse.Name);

            _report.AppendFormat("<h1>Aktualisiere LV \"{0} ({1})\" - [{2}]</h1>", scheduleCourse.Name, scheduleCourse.ShortName,
                                 scheduleCourse.CourseId);
            _report.AppendLine();

            var db = new TimeTableDbContext();

            var  organiser = db.Organisers.SingleOrDefault(s => s.Id == _orgId);
            var  sem       = db.Semesters.SingleOrDefault(s => s.Id == _semId);
            long msStart   = sw.ElapsedMilliseconds;

            var course = db.Activities.OfType <Course>().SingleOrDefault(x => x.Id == c.Id);

            // Ober sticht Unter => zuerst alle termine raus!
            _report.AppendLine("<h2>Gelöschte Termine</h2>");
            _report.AppendLine("<table>");
            foreach (var date in course.Dates.ToList())
            {
                _report.AppendLine("<tr>");
                _report.AppendFormat("<td>{0}</td><td>{1}</td><td>{2}</td>", date.Begin.ToShortDateString(), date.Begin.ToShortTimeString(), date.End.ToShortTimeString());

                _report.AppendLine("<td>");
                foreach (var room in date.Rooms)
                {
                    _report.AppendFormat("<p>{0}</p>", room.Number);
                }
                _report.AppendLine("</td>");

                _report.AppendLine("<td>");
                foreach (var host in date.Hosts)
                {
                    _report.AppendFormat("<p>{0} ({1})</p>", host.Name, host.ShortName);
                }
                _report.AppendLine("</td>");

                _report.AppendFormat("<td>{0}</td>", date.Title);
                _report.AppendFormat("<td>{0}</td>", date.Description);
                _report.AppendFormat("<td>{0}</td>", date.Occurrence.Information);

                _report.AppendLine();
                _report.AppendLine("</tr>");


                db.Occurrences.Remove(date.Occurrence);

                foreach (var change in date.Changes.ToList())
                {
                    foreach (var notificationState in change.NotificationStates.ToList())
                    {
                        db.NotificationStates.Remove(notificationState);
                        change.NotificationStates.Remove(notificationState);
                    }
                    date.Changes.Remove(change);
                    db.DateChanges.Remove(change);
                }

                course.Dates.Remove(date);

                db.ActivityDates.Remove(date);
            }
            db.SaveChanges();

            _report.AppendLine("</table>");


            // Die Bezeichnung
            _report.AppendLine("<h2>Bezeichnungen</h2>");
            _report.AppendLine("<h3>Alt</h3>");
            _report.AppendLine("<table>");
            _report.AppendFormat("<tr><td>Name</td><td>{0}</td></tr>", course.Name);
            _report.AppendFormat("<tr><td>Kurzname</td><td>{0}</td></tr>", course.ShortName);
            _report.AppendFormat("<tr><td>Beschreibung</td><td>{0}</td></tr>", course.Description);
            _report.AppendLine("</table>");

            course.Name        = scheduleCourse.Name;
            course.ShortName   = scheduleCourse.ShortName;
            course.Description = scheduleCourse.Description;

            _report.AppendLine("<h3>Neu</h3>");
            _report.AppendLine("<table>");
            _report.AppendFormat("<tr><td>Name</td><td>{0}</td></tr>", course.Name);
            _report.AppendFormat("<tr><td>Kurzname</td><td>{0}</td></tr>", course.ShortName);
            _report.AppendFormat("<tr><td>Beschreibung</td><td>{0}</td></tr>", course.Description);
            _report.AppendLine("</table>");

            // Platzkontingent
            course.Occurrence.Capacity = scheduleCourse.SeatRestriction ?? 0;

            // Termine einfügen
            // zum Schluss die Termine
            _report.AppendLine("<h2>Neue Termine</h2>");
            _report.AppendLine("<table>");

            foreach (var scheduleDate in scheduleCourse.Dates)
            {
                // Der Tag
                var occDate = scheduleDate.Begin.Date;

                bool isVorlesung = true;
                foreach (var sd in _semester.Dates)
                {
                    // Wenn der Termin in eine vorlesungsfreie Zeit fällt, dann nicht importieren
                    if (sd.From.Date <= occDate.Date &&
                        occDate.Date <= sd.To.Date &&
                        sd.HasCourses == false)
                    {
                        isVorlesung = false;
                    }
                }

                // Es muss Vorlesung sein und das Datum darf nicht existieren
                if (isVorlesung)
                {
                    var occ = new ActivityDate
                    {
                        Begin      = scheduleDate.Begin,
                        End        = scheduleDate.End,
                        Activity   = course,
                        Occurrence = CreateDefaultOccurrence(),
                    };

                    _report.AppendLine("<tr>");
                    _report.AppendFormat("<td>{0}</td><td>{1}</td><td>{2}</td>", occ.Begin.ToShortDateString(), occ.Begin.ToShortTimeString(), occ.End.ToShortTimeString());

                    _report.AppendFormat("<td>");
                    foreach (var scheduleDateRoom in scheduleDate.Rooms)
                    {
                        _report.AppendFormat("<p>{0}", scheduleDateRoom.RoomNumber);
                        if (!string.IsNullOrEmpty(scheduleDateRoom.RoomNumber))
                        {
                            var room = db.Rooms.SingleOrDefault(r => r.Number.Equals(scheduleDateRoom.RoomNumber));
                            if (room == null)
                            {
                                room = new Room
                                {
                                    Number      = scheduleDateRoom.RoomNumber,
                                    Capacity    = 0,
                                    Description = string.Empty,
                                    Owner       = string.Empty,
                                };
                                db.Rooms.Add(room);
                                db.SaveChanges();

                                _numRooms++;

                                _report.AppendFormat(" !!!NEUER RAUM!!!");
                            }


                            var assignment = db.RoomAssignments.SingleOrDefault(x =>
                                                                                x.Room.Id == room.Id &&
                                                                                x.Organiser.Id == organiser.Id);
                            if (assignment == null)
                            {
                                assignment = new RoomAssignment
                                {
                                    Organiser = organiser,
                                    InternalNeedConfirmation = false, // offen für interne
                                    ExternalNeedConfirmation = true   // geschlossen für externe
                                };

                                room.Assignments.Add(assignment);
                                db.RoomAssignments.Add(assignment);
                                db.SaveChanges();
                            }

                            occ.Rooms.Add(room);

                            _report.AppendFormat("</p>");
                        }
                    }
                    _report.AppendFormat("</td>");

                    _report.AppendFormat("<td>");
                    foreach (var scheduleDateLecturer in scheduleDate.Lecturers)
                    {
                        _report.AppendFormat("<p>{0} ({1})", scheduleDateLecturer.Name, scheduleDateLecturer.ShortName);
                        var lecturer = organiser.Members.SingleOrDefault(l => l.ShortName.Equals(scheduleDateLecturer.ShortName));
                        if (lecturer == null)
                        {
                            lecturer = new OrganiserMember
                            {
                                ShortName   = scheduleDateLecturer.ShortName,
                                Name        = scheduleDateLecturer.Name,
                                Role        = String.Empty,
                                Description = String.Empty
                            };
                            organiser.Members.Add(lecturer);
                            db.Members.Add(lecturer);
                            db.SaveChanges();
                            _numLecturers++;

                            _report.AppendFormat(" !!!NEUER DOZENT!!!");
                        }

                        occ.Hosts.Add(lecturer);

                        _report.AppendFormat("</p>");
                    }
                    _report.AppendFormat("</td>");


                    db.ActivityDates.Add(occ);

                    _report.AppendLine();
                    _report.AppendLine("</tr>");
                }
            }
            _report.AppendLine("</table>");

            db.SaveChanges();

            long msEnd = sw.ElapsedMilliseconds;

            _Logger.DebugFormat("Dauer {0}ms", msEnd - msStart);

            msg = $"Kurs {course.ShortName} mit Terminen aktualisiert";

            return(msg);
        }
Exemplo n.º 21
0
        public static void Initialize(StuyDbContext context)
        {
            context.Database.EnsureCreated();

            // Look for any students.
            if (context.Students.Any())
            {
                return;   // DB has been seeded
            }

            var students = new Student[]
            {
                new Student {
                    FirstName = "Shreya", LastName = "Shukla", EnrollmentDate = DateTime.Parse("2020-01-01")
                },
                new Student {
                    FirstName = "Bobby", LastName = "Smith", EnrollmentDate = DateTime.Parse("2020-01-01")
                },
                new Student {
                    FirstName = "John", LastName = "Doe", EnrollmentDate = DateTime.Parse("2020-01-01")
                },
                new Student {
                    FirstName = "Tom", LastName = "Mathew", EnrollmentDate = DateTime.Parse("2019-01-01")
                },
                new Student {
                    FirstName = "Dan", LastName = "Pauli", EnrollmentDate = DateTime.Parse("2016-01-01")
                },
                new Student {
                    FirstName = "Joe", LastName = "Gregor", EnrollmentDate = DateTime.Parse("2017-01-01")
                },
                new Student {
                    FirstName = "Laura", LastName = "Newman", EnrollmentDate = DateTime.Parse("2019-01-01")
                },
                new Student {
                    FirstName = "Nina", LastName = "Thomas", EnrollmentDate = DateTime.Parse("2018-01-01")
                }
            };

            foreach (Student s in students)
            {
                context.Students.Add(s);
            }
            context.SaveChanges();

            var teachers = new Teacher[]
            {
                new Teacher {
                    FirstName = "Sally", LastName = "Xu",
                    JoinDate  = DateTime.Parse("2001-01-11")
                },
                new Teacher {
                    FirstName = "Lara", LastName = "Bose",
                    JoinDate  = DateTime.Parse("2002-05-16")
                },
                new Teacher {
                    FirstName = "Diana", LastName = "Heden",
                    JoinDate  = DateTime.Parse("2010-01-08")
                },
                new Teacher {
                    FirstName = "Raj", LastName = "Patel",
                    JoinDate  = DateTime.Parse("2015-02-10")
                },
                new Teacher {
                    FirstName = "Roger", LastName = "Lee",
                    JoinDate  = DateTime.Parse("2008-01-09")
                }
            };

            foreach (Teacher i in teachers)
            {
                context.Teachers.Add(i);
            }
            context.SaveChanges();

            var departments = new Department[]
            {
                new Department {
                    Name = "English", TeacherID = teachers.Single(i => i.LastName == "Xu").TeacherID
                },
                new Department {
                    Name = "Mathematics", TeacherID = teachers.Single(i => i.LastName == "Bose").TeacherID
                },
                new Department {
                    Name = "Engineering", TeacherID = teachers.Single(i => i.LastName == "Heden").TeacherID
                },
                new Department {
                    Name = "Biology", TeacherID = teachers.Single(i => i.LastName == "Patel").TeacherID
                },
                new Department {
                    Name = "Botany", TeacherID = teachers.Single(i => i.LastName == "Lee").TeacherID
                }
            };

            foreach (Department d in departments)
            {
                context.Departments.Add(d);
            }
            context.SaveChanges();


            var subjects = new Subject[]
            {
                new Subject {
                    SubjectID    = 1050, Title = "Chemistry", Credits = 3,
                    DepartmentID = departments.Single(s => s.Name == "Engineering").DepartmentID
                },
                new Subject {
                    SubjectID    = 4022, Title = "Micro Biology", Credits = 3,
                    DepartmentID = departments.Single(s => s.Name == "Biology").DepartmentID
                },
                new Subject {
                    SubjectID    = 4041, Title = "Life Sciences", Credits = 3,
                    DepartmentID = departments.Single(s => s.Name == "Biology").DepartmentID
                },
                new Subject {
                    SubjectID    = 1045, Title = "Calculus", Credits = 4,
                    DepartmentID = departments.Single(s => s.Name == "Mathematics").DepartmentID
                },
                new Subject {
                    SubjectID    = 3141, Title = "Algebra2", Credits = 4,
                    DepartmentID = departments.Single(s => s.Name == "Mathematics").DepartmentID
                },
                new Subject {
                    SubjectID    = 2021, Title = "Creative Writng", Credits = 3,
                    DepartmentID = departments.Single(s => s.Name == "English").DepartmentID
                },
                new Subject {
                    SubjectID    = 2042, Title = "Literature", Credits = 4,
                    DepartmentID = departments.Single(s => s.Name == "English").DepartmentID
                },
            };

            foreach (Subject c in subjects)
            {
                context.Subjects.Add(c);
            }
            context.SaveChanges();

            var roomAssignments = new RoomAssignment[]
            {
                new RoomAssignment {
                    TeacherID = teachers.Single(i => i.LastName == "Xu").TeacherID,
                    Room      = "Room 101"
                },
                new RoomAssignment {
                    TeacherID = teachers.Single(i => i.LastName == "Bose").TeacherID,
                    Room      = "Room 102"
                },
                new RoomAssignment {
                    TeacherID = teachers.Single(i => i.LastName == "Heden").TeacherID,
                    Room      = "Room 305"
                },
                new RoomAssignment {
                    TeacherID = teachers.Single(i => i.LastName == "Patel").TeacherID,
                    Room      = "Room 202"
                },
                new RoomAssignment {
                    TeacherID = teachers.Single(i => i.LastName == "Lee").TeacherID,
                    Room      = "Room 301"
                },
            };

            foreach (RoomAssignment o in roomAssignments)
            {
                context.RoomAssignments.Add(o);
            }
            context.SaveChanges();

            var subjectAssignments = new SubjectAssignment[]
            {
                new SubjectAssignment {
                    SubjectID = subjects.Single(c => c.Title == "Chemistry").SubjectID,
                    TeacherID = teachers.Single(i => i.LastName == "Patel").TeacherID
                },
                new SubjectAssignment {
                    SubjectID = subjects.Single(c => c.Title == "Chemistry").SubjectID,
                    TeacherID = teachers.Single(i => i.LastName == "Heden").TeacherID
                },
                new SubjectAssignment {
                    SubjectID = subjects.Single(c => c.Title == "Micro Biology").SubjectID,
                    TeacherID = teachers.Single(i => i.LastName == "Lee").TeacherID
                },
                new SubjectAssignment {
                    SubjectID = subjects.Single(c => c.Title == "Life Sciences").SubjectID,
                    TeacherID = teachers.Single(i => i.LastName == "Lee").TeacherID
                },
                new SubjectAssignment {
                    SubjectID = subjects.Single(c => c.Title == "Calculus").SubjectID,
                    TeacherID = teachers.Single(i => i.LastName == "Bose").TeacherID
                },
                new SubjectAssignment {
                    SubjectID = subjects.Single(c => c.Title == "Algebra2").SubjectID,
                    TeacherID = teachers.Single(i => i.LastName == "Bose").TeacherID
                },
                new SubjectAssignment {
                    SubjectID = subjects.Single(c => c.Title == "Creative Writng").SubjectID,
                    TeacherID = teachers.Single(i => i.LastName == "Xu").TeacherID
                },
                new SubjectAssignment {
                    SubjectID = subjects.Single(c => c.Title == "Literature").SubjectID,
                    TeacherID = teachers.Single(i => i.LastName == "Xu").TeacherID
                },
            };

            foreach (SubjectAssignment ci in subjectAssignments)
            {
                context.SubjectAssignments.Add(ci);
            }
            context.SaveChanges();

            var enrollments = new Enrollment[]
            {
                new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Shukla").StudentID,
                    SubjectID = subjects.Single(c => c.Title == "Chemistry").SubjectID,
                    Score     = 95
                },
                new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Shukla").StudentID,
                    SubjectID = subjects.Single(c => c.Title == "Micro Biology").SubjectID,
                    Score     = 90
                },
                new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Shukla").StudentID,
                    SubjectID = subjects.Single(c => c.Title == "Life Sciences").SubjectID,
                    Score     = 88
                },
                new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Smith").StudentID,
                    SubjectID = subjects.Single(c => c.Title == "Calculus").SubjectID,
                    Score     = 96
                },
                new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Smith").StudentID,
                    SubjectID = subjects.Single(c => c.Title == "Algebra2").SubjectID,
                    Score     = 78
                },
                new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Smith").StudentID,
                    SubjectID = subjects.Single(c => c.Title == "Creative Writng").SubjectID,
                    Score     = 86
                },
                new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Doe").StudentID,
                    SubjectID = subjects.Single(c => c.Title == "Chemistry").SubjectID,
                    Score     = 85
                },
                new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Doe").StudentID,
                    SubjectID = subjects.Single(c => c.Title == "Micro Biology").SubjectID,
                    Score     = 77
                },
                new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Mathew").StudentID,
                    SubjectID = subjects.Single(c => c.Title == "Chemistry").SubjectID,
                    Score     = 88
                },
                new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Pauli").StudentID,
                    SubjectID = subjects.Single(c => c.Title == "Creative Writng").SubjectID,
                    Score     = 94
                },
                new Enrollment {
                    StudentID = students.Single(s => s.LastName == "Newman").StudentID,
                    SubjectID = subjects.Single(c => c.Title == "Literature").SubjectID,
                    Score     = 83
                }
            };

            foreach (Enrollment e in enrollments)
            {
                var enrollmentInDataBase = context.Enrollments.Where(
                    s =>
                    s.Student.StudentID == e.StudentID &&
                    s.Subject.SubjectID == e.SubjectID).SingleOrDefault();
                if (enrollmentInDataBase == null)
                {
                    context.Enrollments.Add(e);
                }
            }
            context.SaveChanges();
        }