Esempio n. 1
0
        public void DeleteLecture(Przedmiot lectureExisted)
        {
            var             noteContainDeleteLecture = MongoDBContext.Oceny.Find(_ => true).ToList().FindAll(ocenaObj => ocenaObj.IdPrzedmiot == lectureExisted.Id);
            List <ObjectId> listNoteObjectContainIdDeletedLecture = new List <ObjectId>();

            foreach (var note in noteContainDeleteLecture)
            {
                listNoteObjectContainIdDeletedLecture.Add(note.Id);
            }

            //Delete Oceny which contains Id deleted lecture from concrete student and then replace student note list
            var studenciContainDeleteLecture = MongoDBContext.Studenci.Find(_ => true).ToList()
                                               .FindAll(studentObj =>
                                                        studentObj.Oceny.Any(noteObj => listNoteObjectContainIdDeletedLecture.Any(noteTempObj => noteTempObj == noteObj)));

            foreach (var student in studenciContainDeleteLecture)
            {
                student.Oceny.RemoveAll(ocenaObj => listNoteObjectContainIdDeletedLecture.Contains(ocenaObj));
                MongoDBContext.Studenci.ReplaceOne(studentObj => studentObj.Id == student.Id,
                                                   student, new UpdateOptions {
                    IsUpsert = true
                });
            }

            //Remove all Oceny, which contains Id deleted lecture
            foreach (var deleteNote in noteContainDeleteLecture)
            {
                MongoDBContext.Oceny.DeleteOne(ocenaObj => ocenaObj.Id == deleteNote.Id);
            }

            //Delete Przedmiot
            MongoDBContext.Przedmioty.DeleteOne(przedmiotObj => przedmiotObj.Id == lectureExisted.Id);
        }
Esempio n. 2
0
        public List <Ocena> GetNotesStudentsByFilter(Student student, Przedmiot przedmiot, double?ge, double?le)
        {
            try
            {
                var indexNumberFiler = Builders <Ocena> .Filter
                                       .Where(studentObj => studentObj.Indeks == student.Indeks);

                List <Ocena> notes = MongoDBContext.Oceny
                                     .Find(indexNumberFiler).ToList();

                if (ge != null)
                {
                    notes = notes.Where(o => o.Wartosc >= ge).ToList();
                }

                if (le != null)
                {
                    notes = notes.Where(o => o.Wartosc <= le).ToList();
                }

                return(notes);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Esempio n. 3
0
        private List <Student> PrepareStudents()
        {
            List <Student> students = new List <Student>();

            Student student = new Student()
            {
                Imie          = "Paweł",
                Nazwisko      = "Nowak",
                Indeks        = 112513,
                DataUrodzenia = new DateTime(1980, 2, 12)
            };

            Przedmiot przedmiotRef = new Przedmiot();

            przedmiotRef.Id = 1;
            student.Przedmioty.Add(przedmiotRef);

            students.Add(student);

            student = new Student()
            {
                Imie          = "Tymoteusz",
                Nazwisko      = "Borowiak",
                Indeks        = 153623,
                DataUrodzenia = new DateTime(1983, 5, 20)
            };

            przedmiotRef    = new Przedmiot();
            przedmiotRef.Id = 2;
            student.Przedmioty.Add(przedmiotRef);

            students.Add(student);

            return(students);
        }
Esempio n. 4
0
        public void UpdateStudentNote(Student student, Przedmiot lecture, Ocena noteTemp, Ocena updatedNote)
        {
            if (student != null && lecture != null && noteTemp != null && updatedNote != null)
            {
                //Prepare Ocena field
                float    wartoscOceny = updatedNote.Wartosc;
                DateTime time         = updatedNote.DataWystawienia;

                updatedNote = noteTemp;

                if (time == null)
                {
                    updatedNote.DataWystawienia = DateTime.Now;
                }
                else
                {
                    updatedNote.DataWystawienia = time;
                }

                updatedNote.Wartosc = wartoscOceny;

                //Replace in Oceny (only, student store objectid note )
                MongoDBContext.Oceny.ReplaceOne(ocenyObj => ocenyObj.Id == updatedNote.Id, updatedNote, new UpdateOptions {
                    IsUpsert = true
                });
            }
        }
Esempio n. 5
0
        public Przedmiot AddLecture(Przedmiot lecture)
        {
            Przedmiot lectureToInsert = new Przedmiot();

            if (lecture != null)
            {
                //Find last added Przedmiot
                int       przedmiotIndex     = 0;
                Przedmiot lastAddedPrzedmiot = MongoDBContext.Przedmioty.Find(_ => true).ToList().OrderByDescending(przedmiotObj => przedmiotObj.IdPrzedmiotu).FirstOrDefault();

                if (lastAddedPrzedmiot != null)
                {
                    przedmiotIndex = lastAddedPrzedmiot.IdPrzedmiotu;
                    przedmiotIndex++;
                }

                lectureToInsert.IdPrzedmiotu = przedmiotIndex;
                lectureToInsert.Nauczyciel   = lecture.Nauczyciel;
                lectureToInsert.Nazwa        = lecture.Nazwa;

                MongoDBContext.Przedmioty.InsertOne(lectureToInsert);

                return(lectureToInsert);
            }

            return(null);
        }
Esempio n. 6
0
 public void AddLecture(Przedmiot lecture)
 {
     if (lecture != null)
     {
         lecture.Id = generateUniqueLectureID();
         Lectures.Add(lecture);
     }
 }
Esempio n. 7
0
 public void AddStudentToLecture(Student studentExisted, Przedmiot lectureExisted)
 {
     if (studentExisted != null && lectureExisted != null)
     {
         var studentFounded      = Students.Find(studentObj => studentObj.Indeks == studentExisted.Indeks);
         int indexFoundedStudent = Students.IndexOf(studentFounded);
         Students[indexFoundedStudent].Przedmioty.Add(lectureExisted);
         //studentExisted.Przedmioty.Add(lectureExisted);
     }
 }
Esempio n. 8
0
 public void AddStudentToLecture(Student studentExisted, Przedmiot lectureExisted)
 {
     if (studentExisted != null && lectureExisted != null)
     {
         lectureExisted.ZapisaniStudenci.Add(studentExisted.Id);
         MongoDBContext.Przedmioty.ReplaceOne(lectureObj => lectureObj.Id == lectureExisted.Id, lectureExisted, new UpdateOptions {
             IsUpsert = true
         });
     }
 }
Esempio n. 9
0
        public void DeleteStudentFromLecture(Student studentExisted, Przedmiot lectureExisted)
        {
            if (studentExisted != null && lectureExisted != null)
            {
                lectureExisted.ZapisaniStudenci.RemoveAll(studentObj => studentObj == studentExisted.Id);

                MongoDBContext.Przedmioty.ReplaceOne(przedmiotObj => przedmiotObj.Id == lectureExisted.Id,
                                                     lectureExisted, new UpdateOptions {
                    IsUpsert = true
                });
            }
        }
Esempio n. 10
0
        public IEnumerable <Student> GetStudentsFromLecture(Przedmiot lecture)
        {
            IEnumerable <Student> allStudentsList     = null;
            IEnumerable <Student> studentsFromLecture = null;

            if (lecture != null)
            {
                allStudentsList     = GetStudents().FindAll(_ => true).ToList();
                studentsFromLecture = allStudentsList.Where(s => lecture.ZapisaniStudenci.Contains(s.Id));
            }

            return(studentsFromLecture);
        }
Esempio n. 11
0
        public void UpdateLecture(Przedmiot lectureFromDB, Przedmiot lectureFromBody)
        {
            if (lectureFromDB != null && lectureFromBody != null)
            {
                lectureFromDB.Nauczyciel = lectureFromBody.Nauczyciel;
                lectureFromDB.Nazwa      = lectureFromBody.Nazwa;

                MongoDBContext.Przedmioty.ReplaceOne(przedmiotObj => przedmiotObj.Id == lectureFromDB.Id,
                                                     lectureFromDB, new UpdateOptions {
                    IsUpsert = true
                });
            }
        }
Esempio n. 12
0
        public void DeleteLecture(Przedmiot lectureExisted)
        {
            var lectureToDelete    = Lectures.Find(studentObj => studentObj.Id == lectureExisted.Id);
            int indexDeleteLecture = -1;

            if (lectureToDelete != null)
            {
                indexDeleteLecture = Lectures.IndexOf(lectureToDelete);

                if (indexDeleteLecture >= 0)
                {
                    Lectures.RemoveAt(indexDeleteLecture);
                }
            }
        }
Esempio n. 13
0
        public Przedmiot getLecture(int indexLecture)
        {
            Przedmiot przedmiotRef = Lectures.Find(lectureObj => lectureObj.Id == indexLecture);

            try
            {
                przedmiotRef = Lectures.Find(lectureObj => lectureObj.Id == indexLecture);
            }
            catch
            {
                przedmiotRef = null;
            }

            return(przedmiotRef);
        }
Esempio n. 14
0
        public void DeleteStudentNote(Student student, Przedmiot lecture, Ocena note)
        {
            if (student != null && lecture != null && note != null)
            {
                Ocena ocena = Notes.Find(noteObj => noteObj.Id == note.Id &&
                                         student.Indeks == note.IdStudent &&
                                         lecture.Id == note.IdPrzedmiot);

                if (ocena != null)
                {
                    var indexFoundedNotes = Notes.IndexOf(ocena);
                    Notes.RemoveAt(indexFoundedNotes);
                }
            }
        }
Esempio n. 15
0
        public void DeleteStudentFromLecture(Student studentExisted, Przedmiot lectureExisted)
        {
            int indexFoundedStudent = -1;
            int indexFoundedLecture = -1;

            if (studentExisted != null && lectureExisted != null)
            {
                indexFoundedStudent = Students.IndexOf(studentExisted);
                var lectureFounded = Students[indexFoundedStudent].Przedmioty.Find(lectureObj => lectureObj.Id == lectureExisted.Id);
                indexFoundedLecture = Students[indexFoundedStudent].Przedmioty.IndexOf(lectureFounded);

                if (indexFoundedLecture >= 0)
                {
                    Students[indexFoundedStudent].Przedmioty.RemoveAt(indexFoundedLecture);
                }
            }
        }
Esempio n. 16
0
        public bool UpdateLecture(Przedmiot updateLecture)
        {
            bool IsLectureUpdated = false;
            var  lectureToReplace = Lectures.Find(lectureObj => lectureObj.Id == updateLecture.Id);

            if (lectureToReplace != null)
            {
                var indexOfReplacedStudent = Lectures.IndexOf(lectureToReplace);

                if (indexOfReplacedStudent >= 0)
                {
                    Lectures[indexOfReplacedStudent] = updateLecture;
                    IsLectureUpdated = true;
                }
            }

            return(IsLectureUpdated);
        }
Esempio n. 17
0
        public void DeleteStudentNote(Student student, Przedmiot lecture, Ocena note)
        {
            if (student != null && lecture != null && note != null)
            {
                //Delete from Oceny
                MongoDBContext.Oceny.DeleteMany(ocenaObj => ocenaObj.Id == note.Id &&
                                                ocenaObj.IdPrzedmiot == note.IdPrzedmiot &&
                                                ocenaObj.IdStudent == note.IdStudent);

                //Delete from concrete student
                student.Oceny.RemoveAll(ocenaObj => ocenaObj == note.Id);

                //Replace modified student
                MongoDBContext.Studenci.ReplaceOne(studentObj => studentObj.Id == student.Id,
                                                   student, new UpdateOptions {
                    IsUpsert = true
                });
            }
        }
Esempio n. 18
0
        public void AddNoteStudentFromLecture(Student studentExisted, Przedmiot lectureExisted, Ocena note)
        {
            var studentFounded = Students.Find(studentObj => studentObj.Indeks == studentExisted.Indeks);
            var lectureFounded = Lectures.Find(lectureObj => lectureObj.Id == lectureExisted.Id);

            if (studentExisted != null && lectureExisted != null && note != null)
            {
                int indexStudent = Students.IndexOf(studentFounded);
                int indexLecture = Lectures.IndexOf(lectureFounded);

                note.Id              = generateUniqueNoteID();
                note.IdStudent       = studentExisted.Indeks;
                note.IdPrzedmiot     = lectureExisted.Id;
                note.DataWystawienia = DateTime.Now;

                Students[indexStudent].Oceny.Add(note);
                Notes.Add(note);
                //studentExisted.Przedmioty.Add(lectureExisted);
            }
        }
Esempio n. 19
0
        public void AddNoteStudentFromLecture(Student studentExisted, Przedmiot lectureExisted, Ocena note)
        {
            if (studentExisted != null && lectureExisted != null && note != null)
            {
                //Find last added Ocena
                long  ocenyIndex    = 0;
                Ocena lastAddedNote = MongoDBContext.Oceny.Find(_ => true).ToList().OrderByDescending(ocenaObj => ocenaObj.IdOceny).FirstOrDefault();

                if (lastAddedNote != null)
                {
                    ocenyIndex = lastAddedNote.IdOceny;
                    ocenyIndex++;
                }

                //Prepare Ocena field
                note.IdOceny      = (int)ocenyIndex;
                note.IdPrzedmiotu = lectureExisted.IdPrzedmiotu;
                note.Indeks       = studentExisted.Indeks;
                note.IdStudent    = studentExisted.Id;
                note.IdPrzedmiot  = lectureExisted.Id;

                if (note.DataWystawienia == null)
                {
                    note.DataWystawienia = DateTime.Now;
                }

                //Add to Oceny
                MongoDBContext.Oceny.InsertOne(note);

                //Add to concrete Student Oceny
                var ocenaLastAdded = MongoDBContext.Oceny.Find(_ => true).ToList().OrderByDescending(ocenaObj => ocenaObj.IdOceny).FirstOrDefault();
                studentExisted.Oceny.Add(ocenaLastAdded.Id);

                //Replace old Student data to new
                MongoDBContext.Studenci.ReplaceOne(studentObj => studentObj.Id == studentExisted.Id, studentExisted, new UpdateOptions {
                    IsUpsert = true
                });
            }
        }
Esempio n. 20
0
        public void UpdateStudentNote(Student student, Przedmiot lecture, Ocena note)
        {
            var studentFounded = Students.Find(studentObj => studentObj.Indeks == student.Indeks);
            var lectureFounded = Lectures.Find(lectureObj => lectureObj.Id == lecture.Id);
            var noteFounded    = Notes.Find(lectureObj => lectureObj.Id == note.Id);

            if (studentFounded != null && lectureFounded != null && noteFounded != null)
            {
                int indexStudent = Students.IndexOf(studentFounded);
                int indexLecture = Lectures.IndexOf(lectureFounded);
                int indexNote    = Notes.IndexOf(noteFounded);

                note.IdStudent       = student.Indeks;
                note.IdPrzedmiot     = lecture.Id;
                note.DataWystawienia = DateTime.Now;

                //Students[indexStudent].Oceny.Add(note);
                Notes.RemoveAt(indexNote);
                Notes.Insert(indexNote, note);
                //studentExisted.Przedmioty.Add(lectureExisted);
            }
        }
Esempio n. 21
0
        List <Przedmiot> PrepareLectures()
        {
            List <Przedmiot> lectures = new List <Przedmiot>();

            Przedmiot lecture = new Przedmiot()
            {
                Id         = 1,
                Nazwa      = "Język polski",
                Nauczyciel = "Mikołaj Nowacki",
            };

            lectures.Add(lecture);

            lecture = new Przedmiot()
            {
                Id         = 2,
                Nazwa      = "Matematyka",
                Nauczyciel = "Marta Polak",
            };

            lectures.Add(lecture);

            return(lectures);
        }
Esempio n. 22
0
 public void UpdateNote(Przedmiot lecture, Student student, Ocena note, Ocena noteFromBody)
 {
     UpdateStudentNote(student, lecture, note, noteFromBody);
 }
Esempio n. 23
0
 public void DeleteNote(Student student, Przedmiot lecture, Ocena note)
 {
     DeleteStudentNote(student, lecture, note);
 }
Esempio n. 24
0
        private void PrepareStudents()
        {
            MongoDBContext.Studenci.DeleteMany(_ => true);
            MongoDBContext.Przedmioty.DeleteMany(_ => true);
            MongoDBContext.Oceny.DeleteMany(_ => true);

            Student studentPawel = new Student()
            {
                Imie          = "Paweł",
                Nazwisko      = "Nowak",
                Indeks        = 112513,
                DataUrodzenia = new DateTime(1980, 2, 12)
            };

            Student studentTymek = new Student()
            {
                Imie          = "Tymoteusz",
                Nazwisko      = "Borowiak",
                Indeks        = 153623,
                DataUrodzenia = new DateTime(1983, 5, 20)
            };

            Przedmiot przedmiotJezykPolski = new Przedmiot()
            {
                IdPrzedmiotu = 1,
                Nazwa        = "Polski",
                Nauczyciel   = "Bogdan Marecki",
            };

            Przedmiot przedmiotMatematyka = new Przedmiot()
            {
                IdPrzedmiotu = 2,
                Nazwa        = "Matematyka",
                Nauczyciel   = "Roman Bielecki",
            };

            MongoDBContext.Przedmioty.InsertOne(przedmiotJezykPolski);
            MongoDBContext.Przedmioty.InsertOne(przedmiotMatematyka);

            MongoDBContext.Studenci.InsertOne(studentPawel);
            MongoDBContext.Studenci.InsertOne(studentTymek);

            var przedmioty = MongoDBContext.Przedmioty.Find(_ => true).ToList();
            var studenci   = MongoDBContext.Studenci.Find(_ => true).ToList();

            var przedmiot = przedmioty.FindAll(przedmiotTemp => przedmiotTemp.Nazwa == przedmiotJezykPolski.Nazwa).FirstOrDefault();
            var student   = studenci.FindAll(studentTemp => studentTemp.Indeks == studentPawel.Indeks).FirstOrDefault();

            przedmiotJezykPolski.ZapisaniStudenci.Add(student.Id);

            przedmiot = przedmioty.FindAll(przedmiotTemp => przedmiotTemp.Nazwa == przedmiotMatematyka.Nazwa).FirstOrDefault();
            student   = studenci.FindAll(studentTemp => studentTemp.Indeks == studentTymek.Indeks).FirstOrDefault();
            przedmiotMatematyka.ZapisaniStudenci.Add(student.Id);

            MongoDBContext.Przedmioty.ReplaceOne(x => x.IdPrzedmiotu == 1, przedmiotJezykPolski, new UpdateOptions {
                IsUpsert = true
            });
            MongoDBContext.Przedmioty.ReplaceOne(x => x.IdPrzedmiotu == 2, przedmiotMatematyka, new UpdateOptions {
                IsUpsert = true
            });
        }