public static List <LessonDTO> GetLessonsListBySubscriptionByStudentIdEndDate(int studentId, string date)
        {
            using (Gymnastics_Studio_DataEntities GSDE = new Gymnastics_Studio_DataEntities())
            {
                List <Lesson>         LessonList            = new List <Lesson>();
                DateTime              Date                  = Convert.ToDateTime(date);
                StudentInSubscription studentInSubscription = new StudentInSubscription();
                studentInSubscription = GSDE.StudentInSubscriptions.Where(x => x.StudentId == studentId && x.StartDate <= Date && x.FinishDate >= Date).FirstOrDefault();
                Subscription subscriptin = new Subscription();
                if (studentInSubscription == default)
                {
                    return(null);
                }
                subscriptin = GSDE.Subscriptions.Where(x => x.Id == studentInSubscription.SubscribtionId).FirstOrDefault();
                var subscription = GSDE.Subscriptions.Where(x => x.Id == subscriptin.Id).FirstOrDefault();
                if (subscriptin.LessonKind == default)
                {
                    return(null);
                }
                string lessonKind = subscriptin.LessonKind;
                LessonList = GSDE.Lessons.Where(x => x.LessonKind == lessonKind).ToList();

                return(LessonDTO.ConvertListToDTO(LessonList));
            }
        }
示例#2
0
        public static bool AddStudentInSubscription(StudentInSubscriptionDTO studentInSubscriptionDTO)
        {
            try
            {
                using (Gymnastics_Studio_DataEntities GSDE = new Gymnastics_Studio_DataEntities())
                {
                    StudentInSubscription studentInSubscription = StudentInSubscriptionDTO.ConvertFromDTO(studentInSubscriptionDTO);
                    Subscription          subscription          = GSDE.Subscriptions.Where(x => x.Id == studentInSubscription.SubscribtionId).FirstOrDefault();



                    if (studentInSubscription != default)
                    {
                        Convert.ToDateTime(studentInSubscription.StartDate);
                        studentInSubscription.FinishDate = studentInSubscription.StartDate;
                        studentInSubscription.FinishDate = Convert.ToDateTime(studentInSubscription.FinishDate).AddDays(7 * (double)subscription.WeeksNum);
                    }
                    var lastStudentInSubscriptions = GSDE.StudentInSubscriptions.Where(x => x.StartDate == studentInSubscription.StartDate).FirstOrDefault();
                    if (lastStudentInSubscriptions != default)
                    {
                        studentInSubscription.Id = lastStudentInSubscriptions.Id;
                        return(EditStudentInSubscription(StudentInSubscriptionDTO.ConvertToDTO(studentInSubscription)));
                    }

                    GSDE.StudentInSubscriptions.Add(studentInSubscription);
                    GSDE.SaveChanges();
                    return(true);
                }
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        public static StudentInSubscriptionDTO ConvertToDTO(StudentInSubscription studentInSubscription)
        {
            StudentInSubscriptionDTO studentInSubscriptionDTO = new StudentInSubscriptionDTO();

            studentInSubscriptionDTO.Id             = studentInSubscription.Id;
            studentInSubscriptionDTO.StudentId      = studentInSubscription.StudentId;
            studentInSubscriptionDTO.SubscribtionId = studentInSubscription.SubscribtionId;
            studentInSubscriptionDTO.StartDate      = studentInSubscription.StartDate;
            studentInSubscriptionDTO.FinishDate     = studentInSubscription.FinishDate;

            return(studentInSubscriptionDTO);
        }
示例#4
0
        public static StudentInSubscriptionDTO GetCurrentStudentInSubscription(int studentId)
        {
            using (Gymnastics_Studio_DataEntities GSDE = new Gymnastics_Studio_DataEntities())
            {
                StudentInSubscription CurrentstudentInSubscription = new StudentInSubscription();
                CurrentstudentInSubscription = GSDE.StudentInSubscriptions.Where(x => x.StudentId == studentId && x.StartDate <= DateTime.Now && x.FinishDate >= DateTime.Now).FirstOrDefault();
                if (CurrentstudentInSubscription == default)
                {
                    StudentInSubscriptionDTO studentInSubscriptionDTO = new StudentInSubscriptionDTO();

                    return(studentInSubscriptionDTO);
                }
                return(StudentInSubscriptionDTO.ConvertToDTO(CurrentstudentInSubscription));
            }
        }
示例#5
0
        public static StudentInSubscription ConvertFromDTO(StudentInSubscriptionDTO studentInSubscriptionDTO)
        {
            StudentInSubscription studentInSubscription = new StudentInSubscription();

            if (studentInSubscriptionDTO.Id != default)
            {
                studentInSubscription.Id = studentInSubscriptionDTO.Id;
            }
            studentInSubscription.StudentId      = studentInSubscriptionDTO.StudentId;
            studentInSubscription.SubscribtionId = studentInSubscriptionDTO.SubscribtionId;
            studentInSubscription.StartDate      = Convert.ToDateTime(studentInSubscriptionDTO.StartDate);
            studentInSubscription.FinishDate     = Convert.ToDateTime(studentInSubscriptionDTO.FinishDate);
            studentInSubscription.Stop           = studentInSubscriptionDTO.Stop;

            return(studentInSubscription);
        }
        public static bool PostStudentInLessons(LessonDTO lessonDTO, int studentId, string date)
        {
            try
            {
                using (Gymnastics_Studio_DataEntities GSDE = new Gymnastics_Studio_DataEntities())
                {
                    DateTime Date = Convert.ToDateTime(date);
                    StudentInSubscription studentInSubscription = new StudentInSubscription();
                    studentInSubscription = GSDE.StudentInSubscriptions.Where(x => x.StudentId == studentId && x.StartDate <= Date && x.FinishDate >= Date).FirstOrDefault();
                    List <StudentInLesson> studentInLessonList = new List <StudentInLesson>();
                    studentInLessonList = GSDE.StudentInLessons.Where(x => x.StudentInSubscriptionId == studentInSubscription.Id).ToList();
                    StudentInLesson studentInLesson1 = studentInLessonList[0];
                    var             lastLessonDay    = GSDE.Lessons.Where(x => x.Id == studentInLesson1.LessonId).FirstOrDefault().Day;
                    double          reminder         = ConvertHebrewDayNameToNumber(lessonDTO.Day);
                    reminder -= ConvertHebrewDayNameToNumber(lastLessonDay);
                    if (Convert.ToDateTime(studentInLesson1.Date).AddDays(reminder) < studentInSubscription.StartDate)
                    {
                        reminder += 7;
                    }

                    for (int i = 0; i < studentInLessonList.Count(); i++)
                    {
                        var studentInLesson = studentInLessonList[i];
                        if (studentInLesson.Date >= Date && Convert.ToDateTime(studentInLesson.Date).AddDays(reminder) >= Date)
                        {
                            studentInLesson.Date     = Convert.ToDateTime(studentInLesson.Date).AddDays(reminder);
                            studentInLesson.LessonId = lessonDTO.Id;

                            //Week week = new Week();
                            //DateTime Date2 = Date.AddDays(7);
                            //week = GSDE.Weeks.Where(x => x.Date <= Date && x.Date > Date2).FirstOrDefault();
                            //if (week == default) return false;
                            //studentInLesson.WeekId = week.Id;

                            GSDE.SaveChanges();
                        }
                    }

                    return(true);
                }
            }
            catch (Exception e)
            {
                throw e;
            }
        }
示例#7
0
        public static ExceptionsEnum StopSubscriptionByDate(string Date)
        {
            try
            {
                using (Gymnastics_Studio_DataEntities GSDE = new Gymnastics_Studio_DataEntities())
                {
                    DateTime date = Convert.ToDateTime(Date);
                    StudentInSubscription studentInSubscription = new StudentInSubscription();
                    studentInSubscription = GSDE.StudentInSubscriptions.Where(x => x.StartDate <date && x.FinishDate> date).FirstOrDefault();
                    if (studentInSubscription == default)
                    {
                        return(ExceptionsEnum.StudentInSubscriptionUndefine);
                    }
                    studentInSubscription.Stop = true;
                    GSDE.SaveChanges();
                    DateTime finishDate     = Convert.ToDateTime(studentInSubscription.FinishDate);
                    int      SubscribtionId = (int)studentInSubscription.SubscribtionId;
                    while (finishDate != default)
                    {
                        studentInSubscription = GSDE.StudentInSubscriptions.Where(x => x.StartDate == finishDate && x.SubscribtionId == SubscribtionId).FirstOrDefault();

                        if (studentInSubscription != default)
                        {
                            //מחיקת כל השיעורים שלו
                            GSDE.StudentInLessons.ToList().RemoveAll(x => x.StudentInSubscriptionId == studentInSubscription.Id);
                            GSDE.SaveChanges();
                            finishDate     = Convert.ToDateTime(studentInSubscription.FinishDate);
                            SubscribtionId = (int)studentInSubscription.SubscribtionId;
                            GSDE.StudentInSubscriptions.Remove(studentInSubscription);
                            GSDE.SaveChanges();
                        }
                        else
                        {
                            finishDate = default;
                        }
                    }
                }

                return(ExceptionsEnum.True);
            }

            catch (Exception e)
            {
                throw (e);
            }
        }
示例#8
0
 public static SubscriptionDTO GetCurrentSubscription(int studentId)
 {
     using (Gymnastics_Studio_DataEntities GSDE = new Gymnastics_Studio_DataEntities())
     {
         StudentInSubscription CurrentstudentInSubscription = new StudentInSubscription();
         CurrentstudentInSubscription = GSDE.StudentInSubscriptions.Where(x => x.StudentId == studentId && x.StartDate <= DateTime.Now && x.FinishDate >= DateTime.Now).FirstOrDefault();
         Subscription currentSubscriptin = new Subscription();
         if (CurrentstudentInSubscription != default)
         {
             currentSubscriptin = GSDE.Subscriptions.Where(x => x.Id == CurrentstudentInSubscription.SubscribtionId).FirstOrDefault();
             return(SubscriptionDTO.ConvertToDTO(currentSubscriptin));
         }
         else
         {
             return(null);
         }
     }
 }
 public static ExceptionsEnum CreateLessonListByDate(int StudentId, int LessonId, String Date)
 {
     try
     {
         using (Gymnastics_Studio_DataEntities GSDE = new Gymnastics_Studio_DataEntities())
         {
             DateTime date = Convert.ToDateTime(Date);
             StudentInSubscription studentInSubscription = new StudentInSubscription();
             studentInSubscription = GSDE.StudentInSubscriptions.Where(x => x.StudentId == StudentId && x.StartDate <= date && x.FinishDate > date).FirstOrDefault();
             if (studentInSubscription == default)
             {
                 return(ExceptionsEnum.StudentInSubscriptionUndefine);
             }
             return(CreateLessonList(StudentId, LessonId, studentInSubscription.Id));
         }
     }
     catch (Exception e)
     {
         throw (e);
     }
 }
示例#10
0
 public static int GetCurrentWeekNum(int studentId)
 {
     using (Gymnastics_Studio_DataEntities GSDE = new Gymnastics_Studio_DataEntities())
     {
         int num;
         StudentInSubscription CurrentstudentInSubscription = new StudentInSubscription();
         CurrentstudentInSubscription = GSDE.StudentInSubscriptions.Where(x => x.StudentId == studentId && x.StartDate <= DateTime.Now && x.FinishDate >= DateTime.Now).FirstOrDefault();
         if (CurrentstudentInSubscription != default && CurrentstudentInSubscription.StartDate != null)
         {
             var d = (DateTime.Now - (DateTime)CurrentstudentInSubscription.StartDate);
             num = (int)d.Days / 7;
             if (d.Days % 7 > 0)
             {
                 num++;
             }
         }
         else
         {
             num = 0;
         }
         return(num);
     }
 }
        public static ExceptionsEnum CreateLessonList(int StudentId, int LessonId, int StudentInSubscreptionId)
        {
            try
            {
                using (Gymnastics_Studio_DataEntities GSDE = new Gymnastics_Studio_DataEntities())
                {
                    // בדיקה אם לתלמידה מספר שיעורים באותו שבוע נמוך ממספר השיעורים שאמור להיות במנוי
                    StudentInSubscription studentInSubscription = new StudentInSubscription();
                    studentInSubscription = GSDE.StudentInSubscriptions.Where(x => x.Id == StudentInSubscreptionId).FirstOrDefault();
                    if (studentInSubscription == default)
                    {
                        return(ExceptionsEnum.StudetInSubscriptionUndefine);
                    }
                    Subscription subscription = new Subscription();
                    subscription = GSDE.Subscriptions.Where(x => x.Id == studentInSubscription.SubscribtionId).FirstOrDefault();
                    if (subscription == default)
                    {
                        return(ExceptionsEnum.SubscriptionUndefine);
                    }
                    List <StudentInLesson> studentInLessonList = new List <StudentInLesson>();
                    studentInLessonList = GSDE.StudentInLessons.Where(x => x.StudentInSubscriptionId == StudentInSubscreptionId).ToList();
                    studentInLessonList = studentInLessonList.Where(x => x.Date >= studentInLessonList[0].Date && x.Date < ((DateTime)studentInLessonList[0].Date).AddDays(7)).ToList();
                    //אם לא החזרת שגיאה מתאימה אחרי יצירת enum
                    if (studentInLessonList.Count >= subscription.DaysInWeekNum)
                    {
                        return(ExceptionsEnum.LessonsNumException);
                    }

                    //אם כן לולאה כמס השבועות במנוי ליצירת שיעור כולל טיפול בתשלום וביצירת שבועות
                    WeekFunction.AddWeeksUpTo((DateTime)studentInSubscription.FinishDate);

                    Lesson lesson = new Lesson();
                    lesson = GSDE.Lessons.Where(x => x.Id == LessonId).FirstOrDefault();
                    if (lesson == default)
                    {
                        return(ExceptionsEnum.LessonUndefine);
                    }
                    if (studentInSubscription.StartDate == default)
                    {
                        return(ExceptionsEnum.StartDateOfStudentInSubscriptionUndefine);
                    }
                    DateTime SundayDate = ((DateTime)studentInSubscription.StartDate).AddDays(0 - (int)((DateTime)studentInSubscription.StartDate).DayOfWeek);
                    int      d          = ConvertHebrewDayNameToNumber(lesson.Day) - (int)SundayDate.DayOfWeek;
                    DateTime Date       = SundayDate.AddDays(d);
                    if (Date < studentInSubscription.StartDate)
                    {
                        Date = Date.AddDays(7);
                    }
                    for (int i = 0; i < subscription.WeeksNum; i++, Date = Date.AddDays(7))
                    {
                        StudentInLesson studentInLesson = new StudentInLesson();
                        studentInLesson.Attendance = true;
                        studentInLesson.Date       = Date;
                        studentInLesson.LessonId   = LessonId;
                        studentInLesson.StudentId  = StudentId;
                        studentInLesson.StudentInSubscriptionId = StudentInSubscreptionId;
                        Week     week  = new Week();
                        DateTime Date2 = Date.AddDays(-7);

                        week = GSDE.Weeks.Where(y => y.Date <= Date && y.Date > Date2).FirstOrDefault();
                        if (week == default)
                        {
                            return(ExceptionsEnum.WeekUndefine);
                        }
                        studentInLesson.WeekId = week.Id;

                        // var x=paymentOfLessson(studentInLesson, subscription, StudentId);
                        // if (x != ExceptionsEnum.True)
                        //   return x;
                        int lessonPayment = (int)(subscription.Price / (subscription.WeeksNum * subscription.DaysInWeekNum));

                        Student student = GSDE.Students.Where(x => x.Id == StudentId).FirstOrDefault();
                        if (student == default)
                        {
                            return(ExceptionsEnum.StudentUndefine);
                        }
                        student.Balance -= lessonPayment;
                        GSDE.SaveChanges();
                        while (lessonPayment > 0)
                        {
                            Payment payment = GSDE.Payments.Where(x => x.StudentId == StudentId && x.FinishDate == null).ToList().OrderBy(o => o.StartDate).FirstOrDefault();
                            switch (payment)
                            {
                            case null:
                                payment               = new Payment();
                                payment.StartDate     = DateTime.Now;
                                payment.StudentId     = StudentId;
                                payment.Sum           = 0 - lessonPayment;
                                payment.FormOfPayment = "חוב";
                                payment.Balance       = 0 - lessonPayment;
                                GSDE.Payments.Add(payment);
                                GSDE.SaveChanges();
                                payment = GSDE.Payments.Where(x => x.StudentId == StudentId && x.FinishDate == default).FirstOrDefault();
                                studentInLesson.PaymentId = payment.Id;
                                break;

                            default:
                                if (payment.Balance > 0 && payment.Balance < lessonPayment)
                                {
                                    lessonPayment      = (int)(lessonPayment - payment.Balance);
                                    payment.Balance    = 0;
                                    payment.FinishDate = DateTime.Now;
                                    GSDE.SaveChanges();
                                }
                                else
                                {
                                    payment.Balance = payment.Balance - lessonPayment;
                                    lessonPayment   = 0;
                                    GSDE.SaveChanges();
                                    studentInLesson.PaymentId = payment.Id;
                                    GSDE.SaveChanges();
                                }
                                break;
                            }
                        }

                        GSDE.StudentInLessons.Add(studentInLesson);
                        GSDE.SaveChanges();
                    }
                }

                return(ExceptionsEnum.True);
            }
            catch (Exception e)
            {
                throw (e);
            }
        }
示例#12
0
        public static bool EditSubscription(int CurrentStudentInSubscriptionId, int SubscriptionId)
        {
            try
            {
                using (Gymnastics_Studio_DataEntities GSDE = new Gymnastics_Studio_DataEntities())
                {
                    StudentInSubscription lastStudentInSubscription = new StudentInSubscription();
                    lastStudentInSubscription = GSDE.StudentInSubscriptions.Where(x => x.Id == CurrentStudentInSubscriptionId).FirstOrDefault();
                    if (lastStudentInSubscription == default)
                    {
                        return(false);
                    }



                    lastStudentInSubscription.Stop = true;
                    GSDE.SaveChanges();



                    StudentInSubscription newStudentInSubscription = new StudentInSubscription();
                    newStudentInSubscription = GSDE.StudentInSubscriptions.Where(x => x.StartDate == lastStudentInSubscription.FinishDate).FirstOrDefault();


                    if (newStudentInSubscription == default)
                    {
                        return(false);
                    }
                    while (newStudentInSubscription != default)
                    {
                        if (newStudentInSubscription.SubscribtionId != SubscriptionId)
                        {
                            //החזרת תשלום על שיעורים מוחלפים

                            Payment      payment          = new Payment();
                            Subscription LastSubscription = GSDE.Subscriptions.Where(x => x.Id == newStudentInSubscription.SubscribtionId).FirstOrDefault();
                            if (LastSubscription == default)
                            {
                                return(false);
                            }
                            List <StudentInLesson> LeststudentInLessonList = new List <StudentInLesson>();
                            var LessonsToRemove = GSDE.StudentInLessons.Where(x => x.StudentInSubscriptionId == newStudentInSubscription.Id);
                            for (int i = 0; i < LessonsToRemove.Count(); i++)
                            {
                                payment.Balance += LastSubscription.Price / (LastSubscription.WeeksNum * LastSubscription.DaysInWeekNum);
                                GSDE.SaveChanges();
                            }

                            Student student = new Student();
                            student = GSDE.Students.Where(x => x.Id == lastStudentInSubscription.StudentId).FirstOrDefault();
                            if (student == default)
                            {
                                return(false);
                            }
                            student.Balance += LastSubscription.Price;
                            GSDE.SaveChanges();

                            Subscription subscription = new Subscription();
                            subscription = GSDE.Subscriptions.Where(x => x.Id == SubscriptionId).FirstOrDefault();
                            if (subscription == default || subscription.WeeksNum == default)
                            {
                                return(false);
                            }
                            newStudentInSubscription.FinishDate = ((DateTime)newStudentInSubscription.StartDate).AddDays(7 * (int)subscription.WeeksNum);
                            newStudentInSubscription.Stop       = false;
                            GSDE.SaveChanges();

                            //מחיקת שיעורים קודמים

                            GSDE.StudentInLessons.ToList().RemoveAll(x => LessonsToRemove.Contains(x));
                            GSDE.SaveChanges();
                            newStudentInSubscription.SubscribtionId = SubscriptionId;
                            GSDE.SaveChanges();
                        }
                        // else if (newStudentInSubscription.StudentInLessons.Where(x => x.LessonId == LessonId) != default) return true;

                        //יצירת שיעורים למנוי של תלמיד
                        // StudentInLessonFunction.CreateLessonListBySubscriptionIdLessonIdStudentInSubscriptionId((int)newStudentInSubscription.StudentId, LessonId, (DateTime)newStudentInSubscription.StartDate, (int)newStudentInSubscription.SubscribtionId, newStudentInSubscription.Id);


                        newStudentInSubscription = GSDE.StudentInSubscriptions.Where(x => x.StartDate == newStudentInSubscription.FinishDate).FirstOrDefault();
                    }

                    return(true);
                }
            }
            catch (Exception e)
            {
                throw (e);
            }
        }
示例#13
0
        public static bool AddStudentInSubscriptionUpToNow(int studentId)
        {
            try
            {
                using (Gymnastics_Studio_DataEntities GSDE = new Gymnastics_Studio_DataEntities())
                {
                    StudentInSubscription studentInSubscription = new StudentInSubscription();
                    var i = GSDE.StudentInSubscriptions.Where(x => x.StudentId == studentId && x.FinishDate <= DateTime.Now).Max(t => t.StartDate);
                    if (i == default)
                    {
                        return(false);
                    }
                    studentInSubscription = GSDE.StudentInSubscriptions.Where(x => x.StudentId == studentId && x.StartDate == i).First();


                    WeekFunction.AddWeeksUpTo(DateTime.Now);



                    // הוספת מנוי לתלמידה עד לתאריך נוכחי אלא אם עצרה מנוי או קבעה מנויי אחר
                    DateTime     StartDate    = (DateTime)studentInSubscription.FinishDate;
                    Subscription Subscription = new Subscription();
                    Subscription = GSDE.Subscriptions.Where(x => x.Id == studentInSubscription.SubscribtionId).FirstOrDefault();
                    var      n          = (double)((int)Subscription.WeeksNum * 7);
                    DateTime FinishDate = StartDate.AddDays(n);
                    while (studentInSubscription.Stop == false && studentInSubscription.FinishDate <= DateTime.Now &&
                           (GSDE.StudentInSubscriptions.Where(x => x.StudentId == studentInSubscription.StudentId &&
                                                              ((x.StartDate <= StartDate && x.FinishDate > StartDate) ||
                                                               (x.StartDate > StartDate && x.StartDate < FinishDate)))
                            .FirstOrDefault() == default))
                    {
                        StudentInSubscription newStudentInSubscription = new StudentInSubscription();
                        newStudentInSubscription.StudentId      = studentId;
                        newStudentInSubscription.SubscribtionId = studentInSubscription.SubscribtionId;
                        newStudentInSubscription.StartDate      = studentInSubscription.FinishDate;
                        Subscription subscription = new Subscription();
                        subscription = GSDE.Subscriptions.Where(x => x.Id == newStudentInSubscription.StudentId).First();
                        newStudentInSubscription.FinishDate = ((DateTime)newStudentInSubscription.StartDate).AddDays((double)(7 * (int)subscription.WeeksNum));
                        newStudentInSubscription.Stop       = false;
                        GSDE.StudentInSubscriptions.Add(newStudentInSubscription);
                        GSDE.SaveChanges();
                        newStudentInSubscription = GSDE.StudentInSubscriptions.OrderByDescending(o => o.Id).FirstOrDefault();

                        //הוספת שיעורים לתלמידה עד לתאריך נוכחי
                        List <StudentInLesson> studentInLessonList = new List <StudentInLesson>();
                        studentInLessonList = GSDE.StudentInLessons.Where(x => x.StudentInSubscriptionId == studentInSubscription.Id).ToList()
                                              .OrderByDescending(o => o.Date).Take((int)subscription.DaysInWeekNum).ToList();

                        foreach (StudentInLesson studentInLesson in studentInLessonList)
                        {
                            for (int j = 0; j < subscription.WeeksNum; j++)
                            {
                                StudentInLesson newStudentInLessson = new StudentInLesson();
                                newStudentInLessson.StudentId  = studentId;
                                newStudentInLessson.LessonId   = studentInLesson.LessonId;
                                newStudentInLessson.Attendance = true;
                                newStudentInLessson.Date       = ((DateTime)studentInLesson.Date).AddDays(7 * (j + 1));
                                newStudentInLessson.StudentInSubscriptionId = newStudentInSubscription.Id;
                                var date2 = ((DateTime)newStudentInLessson.Date).AddDays(-7);
                                newStudentInLessson.WeekId = GSDE.Weeks
                                                             .Where(x => x.Date <= newStudentInLessson.Date && x.Date >= date2).First().Id;
                                Student student = new Student();
                                student = GSDE.Students.Where(x => x.Id == studentId).First();


                                //טיפול בתשלום השיעור
                                Payment payment       = new Payment();
                                int     lessonPayment = (int)(subscription.Price / (subscription.WeeksNum * subscription.DaysInWeekNum));
                                student.Balance -= lessonPayment;
                                while (lessonPayment > 0)
                                {
                                    payment = GSDE.Payments.Where(x => x.StudentId == studentId && x.FinishDate == default).ToList().OrderBy(o => o.StartDate).FirstOrDefault();
                                    switch (payment)
                                    {
                                    case null:
                                        payment               = new Payment();
                                        payment.StartDate     = DateTime.Now;
                                        payment.StudentId     = studentId;
                                        payment.Sum           = 0 - lessonPayment;
                                        payment.FormOfPayment = "חוב";
                                        payment.Balance       = 0 - lessonPayment;
                                        GSDE.Payments.Add(payment);
                                        GSDE.SaveChanges();
                                        payment = GSDE.Payments.Where(x => x.StudentId == studentId && x.FinishDate == default).FirstOrDefault();
                                        newStudentInLessson.PaymentId = payment.Id;
                                        break;

                                    default:
                                        if (payment.Balance > 0 && payment.Balance < lessonPayment)
                                        {
                                            lessonPayment      = (int)(lessonPayment - payment.Balance);
                                            payment.Balance    = 0;
                                            payment.FinishDate = DateTime.Now;
                                            GSDE.SaveChanges();
                                        }
                                        else
                                        {
                                            payment.Balance = payment.Balance - lessonPayment;
                                            lessonPayment   = 0;
                                            GSDE.SaveChanges();
                                            newStudentInLessson.PaymentId = payment.Id;
                                        }
                                        break;
                                    }
                                }


                                studentInSubscription = newStudentInSubscription;
                                StartDate             = (DateTime)studentInSubscription.FinishDate;
                                n          = (double)((int)Subscription.WeeksNum * 7);
                                FinishDate = StartDate.AddDays(n);

                                GSDE.StudentInLessons.Add(newStudentInLessson);
                                GSDE.SaveChanges();
                            }
                        }
                    }
                    return(true);
                }
            }
            catch (Exception e)
            {
                throw (e);
            }
        }