public void Initialize(Person connectedPerson)
        {
            ConnectedPerson = connectedPerson;

            // Get the list of existing classes
            ClassesTableData = new ObservableCollection <ClassData>(_schoolData.Classes.AsEnumerable().Select(currClass => ModelClassToClassData(currClass)).ToList());

            // Create the basic list of available classes
            AvailableTeachers.Clear();

            // Add a 'No teacher' option, as not all classes have a teacher assigned to them.
            AvailableTeachers.Add(NOT_ASSIGNED, "אין מורה משויך");

            // Create the list of teachers that are not homeroom teachers already.
            _schoolData.Teachers.Where(teacher => teacher.classID == null && !teacher.Person.User.isDisabled).ToList()
            .ForEach(teacher => AvailableTeachers.Add(teacher.teacherID, teacher.Person.firstName + " " + teacher.Person.lastName));

            // Create the basic list of available rooms
            AvailableRooms.Clear();

            // Add a 'no room' option, as not all classes have an an assigned room.
            AvailableRooms.Add(NOT_ASSIGNED, "אין חדר משויך");

            // Create the list of rooms that are not assigned to a specific class already
            _schoolData.Rooms.Where(room => room.Classes.Count() == 0).ToList()
            .ForEach(room => AvailableRooms.Add(room.roomID, room.roomName));

            // Reset selections
            SelectedTeacher = NOT_ASSIGNED;
            SelectedRoom    = NOT_ASSIGNED;

            // For some reason, after re-initializing this view, the selections are not updated properly in the view unless called again
            OnPropertyChanged("SelectedTeacher");
            OnPropertyChanged("SelectedRoom");
        }
 private void ShowAvailableRooms()
 {
     if ((SelectedDate != null) && (SelectedArea != null) && (MeetingStart != null) && (MeetingEnd != null))
     {
         AvailableRooms.Clear();
         foreach (Room r in Database.GetAvailableRooms(SelectedArea, MeetingStart, MeetingEnd.Value, CurrentMeetingId))
         {
             AvailableRooms.Add(r);
         }
     }
 }
        private void LoadAvailableRooms()
        {
            List <RoomPlan> roomPlans = new List <RoomPlan>();

            foreach (var roomPlanAssignment in ProjectFile.RoomPlans.ToList())
            {
                if (roomPlanAssignment.RoomPlan != null)
                {
                    roomPlans.Add(roomPlanAssignment.RoomPlan);
                }
            }

            AvailableRooms.Clear();
            AvailableRooms.Add(roomPlans);
        }
 /// <summary>
 /// Assistant method that clears all the ViewModel properties
 /// </summary>
 private void ResetData()
 {
     AvailableSearchChoices.Clear();
     LessonsTableData.Clear();
     AvailableClasses.Clear();
     AvailableCourses.Clear();
     AvailableTeachers.Clear();
     AvailableRooms.Clear();
     SelectedLesson       = null;
     SelectedSearchChoice = NOT_ASSIGNED;
     SelectedTeacher      = NOT_ASSIGNED;
     SelectedClass        = NOT_ASSIGNED;
     LessonFirstDay       = NOT_ASSIGNED;
     LessonSecondDay      = NOT_ASSIGNED;
     LessonThirdDay       = NOT_ASSIGNED;
     LessonFourthDay      = NOT_ASSIGNED;
     LessonFirstHour      = NOT_ASSIGNED;
     LessonSecondHour     = NOT_ASSIGNED;
     LessonThirdHour      = NOT_ASSIGNED;
     LessonFourthHour     = NOT_ASSIGNED;
 }
Esempio n. 5
0
        async Task ExecuteSearchAvailableRoomsCommand()
        {
            if (NewReservation.StartingTime > NewReservation.EndingTime)
            {
                await Application.Current.MainPage.DisplayAlert("Something is wrong", "A reservation cannot finish before it starts!", "OK");

                return;
            }

            if (IsBusy)
            {
                return;
            }
            IsBusy = true;

            try
            {
                var reservationTable = await CloudService.GetTableAsync <Reservation>();

                var listOfReservations = await reservationTable.ReadAllReservationsAsync();

                var roomTable = await CloudService.GetTableAsync <Room>();

                var listOfRooms = await roomTable.ReadAllRoomsAsync();

                AvailableRooms.Clear();

                //inserts all the rooms in the collection, then removes the ones which are arleady reserved
                foreach (Room room in listOfRooms)
                {
                    AvailableRooms.Add(room);
                    SortRooms(AvailableRooms, room);
                    foreach (Reservation reservation in listOfReservations)
                    {
                        if (reservation.RoomName.Equals(room.Name))
                        {
                            if (reservation.Date.Date.Equals(NewReservation.Date.Date))
                            {
                                if ((TimeSpan.Compare(reservation.StartingTime, NewReservation.EndingTime) == -1 &&
                                     TimeSpan.Compare(reservation.EndingTime, NewReservation.EndingTime) == 1) ||
                                    (TimeSpan.Compare(reservation.StartingTime, NewReservation.StartingTime) == -1 &&
                                     TimeSpan.Compare(reservation.EndingTime, NewReservation.StartingTime) == 1) ||
                                    (TimeSpan.Compare(reservation.StartingTime, NewReservation.StartingTime) == 1 &&
                                     TimeSpan.Compare(reservation.EndingTime, NewReservation.EndingTime) == -1))
                                {
                                    AvailableRooms.Remove(room);
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"[ReservationListViewModel] Save error: {ex.Message}");
            }
            finally
            {
                IsBusy = false;
            }
        }