public async Task <IActionResult> GetSchedule([FromRoute] int id)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var schedule = await _context.Schedules.SingleOrDefaultAsync(m => m.Id == id);

            if (schedule == null)
            {
                return(NotFound());
            }

            ScheduleDTO scheduleDTO = new ScheduleDTO
            {
                Id          = schedule.Id,
                DoctorId    = schedule.DoctorId,
                DoctorName  = _context.Doctors.Where(d => d.Id == schedule.DoctorId).SingleOrDefault().Name,
                PatientId   = schedule.PatientId,
                PatientName = _context.Patients.Where(d => d.Id == schedule.PatientId).SingleOrDefault().Name,
                Date        = schedule.Date.ToString("yyyy-MM-dd"),
                Time        = schedule.Date.ToShortTimeString()
            };

            return(Ok(scheduleDTO));
        }
Beispiel #2
0
        public static void sendEmail(ScheduleDTO schedule)
        {
            SmtpClient client = new SmtpClient();

            client.Port                  = 587;
            client.Host                  = "smtp.gmail.com";
            client.EnableSsl             = true;
            client.Timeout               = 1000000;
            client.DeliveryMethod        = SmtpDeliveryMethod.Network;
            client.UseDefaultCredentials = false;
            client.Credentials           = new System.Net.NetworkCredential("*****@*****.**", "diniracheli909");

            try
            {
                var         q  = DAL.UserDal.GetUsers().FirstOrDefault(i => i.userId == schedule.StudentId);
                var         q2 = DAL.UserDal.GetUsers().FirstOrDefault(i => i.userId == schedule.TeacherId);
                MailMessage mm = new MailMessage("*****@*****.**", q.email, "ביטול שיעור" + schedule.Subject, "");
                mm.Body = " הי " + q.firstName + ' ' + q.lastName +
                          " \n" + " שיעור " + schedule.Subject + " של המורה  " + q2.firstName + ' ' + q2.lastName + " בתאריך " + schedule.Date + " בשעה " + schedule.starTtime + " התבטל!!!!!! "
                          + "\n" + "<a href='http://localhost:4200/חיפוש'> לקביעת שיעור אחר</a>";
                mm.BodyEncoding = UTF8Encoding.UTF8;
                //  mm. = MailFormat.Html;
                mm.IsBodyHtml = true;
                mm.DeliveryNotificationOptions = DeliveryNotificationOptions.OnFailure;

                client.Send(mm);
            }
            catch (Exception e)
            {
            }
        }
Beispiel #3
0
        public DateTime GetDisbursementDate(int LoanMasterId)
        {
            ScheduleDTO obj = new ScheduleDTO();

            obj = _groupLoanDisbursementService.GetDisbusementDate(LoanMasterId);
            return(Convert.ToDateTime(obj.DisbursementDate));
        }
        public Response <ScheduleDTO> AddVacations(ScheduleDTO obj)
        {
            try
            {
                using (VDEntities entities = new VDEntities())
                {
                    foreach (var clinic in obj.Clinics)
                    {
                        var dbSchedules = entities.Schedules.Where(x => x.Child.ClinicID == clinic.ID &&
                                                                   x.Date >= obj.FromDate && x.Date <= obj.ToDate).ToList();

                        foreach (Schedule schedule in dbSchedules)
                        {
                            schedule.Date = obj.ToDate.AddDays(1);
                            entities.SaveChanges();
                        }
                    }

                    return(new Response <ScheduleDTO>(true, "Vacations are considered and appointments are moved to " +
                                                      obj.ToDate.AddDays(1).ToString("dd-MM-yyy") + " date.", null));
                }
            }
            catch (Exception e)
            {
                return(new Response <ScheduleDTO>(false, GetMessageFromExceptionObject(e), null));
            }
        }
 public Guid Add(ScheduleDTO scheduleDTO)
 {
     try
     {
         if (scheduleDTO != null)
         {
             Schedule schedule = new Schedule
             {
                 IdFlight      = scheduleDTO.FlightID,
                 IdFlightState = scheduleDTO.FlightStateID,
                 DepartureDT   = scheduleDTO.DepartureDT,
                 ArrivalDT     = scheduleDTO.ArrivalDT,
                 Comment       = scheduleDTO.Comment
             };
             _airplaneContext.Schedules.Add(schedule);
             _airplaneContext.SaveChanges();
             return(schedule.Id);
         }
         else
         {
             throw new AirportServiceException("Couldn't add schedule. Provided data was invalid.");
         }
     }
     catch (DbUpdateException ex)
     {
         throw new AirportServiceException("Couldn't add schedule. Provided data was invalid.");
     }
 }
Beispiel #6
0
        public ActionResult CreateSchedule(ScheduleDTO scheduleDTO)
        {
            //TODO:
            // 1) Check any conflict with broadcast shifts
            //First populate with all Rostered shifts
            //IEnumerable<ShiftDTO> shifts = null;
            //using (HttpClientWrapper httpClient = new HttpClientWrapper(Session))
            //{
            //    Task<String> response = httpClient.GetStringAsync("api/EmployeeRosterAPI?startDate=" + HttpUtility.UrlEncode(scheduleDTO.S.StartDateTime.AddDays(1).ToShortDateString()) + "&endDate=" + HttpUtility.UrlEncode(range.EndDateTime.AddDays(1).ToShortDateString()));
            //    shifts = JsonConvert.DeserializeObjectAsync<IEnumerable<ShiftDTO>>(response.Result).Result;

            //}
            // 2) check any conflict with recurring shifts

            if (ModelState.IsValid)
            {
                using (HttpClientWrapper httpClient = new HttpClientWrapper(Session))
                    httpClient.PostAsJsonAsync("/api/ScheduleAPI", scheduleDTO).Result.EnsureSuccessStatusCode();

                return(RedirectToAction("IndexSchedule"));//, new { id = employeedto.BusinessId });
            }
            LoadViewBag();

            return(PartialView(scheduleDTO));
        }
        public Response <ScheduleDTO> Update(ScheduleDTO scheduleDTO)
        {
            try
            {
                using (VDEntities entities = new VDEntities())
                {
                    var dbSchedule       = entities.Schedules.Where(c => c.ID == scheduleDTO.ID).FirstOrDefault();
                    var dbBrandInventory = entities.BrandInventories.Where(b => b.BrandID == scheduleDTO.BrandId &&
                                                                           b.DoctorID == scheduleDTO.DoctorID).FirstOrDefault();
                    if (dbBrandInventory != null && dbBrandInventory.Count > 0)
                    {
                        if (scheduleDTO.GivenDate.Date == DateTime.UtcNow.AddHours(5).Date)
                        {
                            dbBrandInventory.Count--;
                        }
                    }
                    dbSchedule.BrandId   = scheduleDTO.BrandId;
                    dbSchedule.Weight    = scheduleDTO.Weight;
                    dbSchedule.Height    = scheduleDTO.Height;
                    dbSchedule.Circle    = scheduleDTO.Circle;
                    dbSchedule.IsDone    = scheduleDTO.IsDone;
                    dbSchedule.GivenDate = scheduleDTO.GivenDate;

                    ChangeDueDatesOfInjectedSchedule(scheduleDTO, entities, dbSchedule);
                    entities.SaveChanges();
                    return(new Response <ScheduleDTO>(true, "schedule updated successfully.", null));
                }
            }
            catch (Exception e)
            {
                return(new Response <ScheduleDTO>(false, GetMessageFromExceptionObject(e), null));
            }
        }
        public ScheduleDTO GetByID(int?id)
        {
            try
            {
                ScheduleDTO schedule = new ScheduleDTO();

                using (MySqlConnection conn = _con.GetConnection())
                {
                    //join statement for scheduleDetails
                    conn.Open();
                    MySqlCommand cmd = new MySqlCommand("SELECT ScheduleID,DivisionID,ScheduleName FROM schedule WHERE ScheduleID = ?id", conn);
                    cmd.Parameters.AddWithValue("id", id);

                    using (var reader = cmd.ExecuteReader())
                    {
                        while (reader.Read())
                        {
                            schedule.ScheduleID   = reader[0] as int? ?? default;
                            schedule.DivisionID   = reader[1] as int? ?? default;
                            schedule.ScheduleName = reader[2] as string ?? default;
                        }
                    }

                    //get scheduleDetails
                    schedule.ScheduleDetailsList = GetScheduleDetails(id, conn);
                }
                return(schedule);
            }
            catch (Exception ex)
            {
                throw new ContextErrorException(ex);
            }
        }
        public int Update(ScheduleDTO dto)
        {
            var entity = ModelMapper.Mapper.Map <Schedule>(dto);

            entity.EntityState = EntityState.Modified;
            return(_scheduleRepository.Save(entity));
        }
        //Update
        public int?Update(ScheduleDTO entity)
        {
            try
            {
                using (MySqlConnection conn = _con.GetConnection())
                {
                    conn.Open();
                    MySqlCommand cmd = new MySqlCommand("UPDATE schedule SET DivisionID = ?DivisionID, ScheduleName = ?ScheduleName WHERE ScheduleID = ?id", conn);
                    //where id is
                    cmd.Parameters.AddWithValue("id", entity.ScheduleID);
                    //values
                    cmd.Parameters.AddWithValue("DivisionID", entity.DivisionID ?? (object)DBNull.Value);
                    cmd.Parameters.AddWithValue("TeamID", entity.ScheduleName ?? (object)DBNull.Value);
                    //execute command
                    int rowsAffected = cmd.ExecuteNonQuery();
                    //should return if a row is affected or not

                    //update scheduleDetails
                    UpdateScheduleDetails(entity, conn);
                    //get all then compare and delete the ones that are not in the list anymore then update all the rest.
                    //easier to just drop details and then insert new ones?!
                    return(rowsAffected);
                }
            }
            catch (Exception ex)
            {
                throw new ContextErrorException(ex);
            }
        }
        //Create
        public int?Add(ScheduleDTO entity)
        {
            try
            {
                using (MySqlConnection conn = _con.GetConnection())
                {
                    conn.Open();
                    MySqlCommand cmd = new MySqlCommand("INSERT INTO schedule (ScheduleID,DivisionID,ScheduleName) VALUES(?ScheduleID,?DivisionID,?ScheduleName)", conn);
                    //values
                    cmd.Parameters.AddWithValue("ScheduleID", entity.ScheduleID ?? (object)DBNull.Value);
                    cmd.Parameters.AddWithValue("DivisionID", entity.DivisionID ?? (object)DBNull.Value);
                    cmd.Parameters.AddWithValue("ScheduleName", entity.ScheduleName ?? (object)DBNull.Value);
                    //execute command
                    int rowsAffected = cmd.ExecuteNonQuery();
                    //should return if a row is affected or not

                    //add multiple scheduleDetails
                    AddScheduleDetails(entity.ScheduleDetailsList, conn);

                    return(rowsAffected);
                }
            }
            catch (Exception ex)
            {
                throw new ContextErrorException(ex);
            }
        }
        public void GetOrderDetail(string orderID)
        {
            OrderDAO    orderDao    = new OrderDAO();
            ScheduleDAO scheduleDAO = new ScheduleDAO();
            MovieDAO    movieDAO    = new MovieDAO();
            OrderDTO    order       = orderDao.CheckOrder(orderID);

            if (order != null)
            {
                ScheduleDTO schedule   = scheduleDAO.GetScheduleByID(order.ScheduleID);
                string      movieTitle = movieDAO.GetMovieTitle(schedule.MovieID);
                this.orderDetail.Visible = true;
                this.lblOrderID.Text     = order.OrderID;
                this.invalidCode.Visible = false;
                this.lbMovieName.Text    = movieTitle;
                this.lbDate.Text         = schedule.ScheduleDate.ToShortDateString();
                this.lbTime.Text         = schedule.ScheduleDate.ToShortTimeString();
                this.lbRoom.Text         = schedule.RoomID.ToString();
                this.lbPrice.Text        = (schedule.PriceOfTicket * (order.ListOfSeat).Count) + "";
                string seat = "";
                foreach (string s in order.ListOfSeat)
                {
                    seat += (s + "  ");
                }
                this.lbSeat.Text = seat;
            }
            else
            {
                this.invalidCode.CssClass = "error_message_show";
                this.orderDetail.Visible  = false;
            }
        }
        public List <ValidationResult> Validate(ScheduleDTO schedule)
        {
            List <ValidationResult> errors = new List <ValidationResult>();

            if (schedule.ProjectWorkId == 0)
            {
                errors.Add(new ValidationResult("Не указан идентификатор участия в проекте", new List <string>()
                {
                    "ProjectWorkId"
                }));
            }
            if (schedule.ScheduleDayId == 0)
            {
                errors.Add(new ValidationResult("Не указан идентификатор дня недели", new List <string>()
                {
                    "ScheduleDayId"
                }));
            }
            if (schedule.ScheduleDayId != 0 && (schedule.ScheduleDayId > 6 || schedule.ScheduleDayId < 1))
            {
                errors.Add(new ValidationResult("День не существует", new List <string>()
                {
                    "ScheduleDayId"
                }));
            }

            return(errors);
        }
Beispiel #14
0
        public void EditAnyway(ScheduleDTO entity)
        {
            Schedule schedule = Database.Schedules.Find(x => x.Id == entity.Id).FirstOrDefault();

            if (schedule == null)
            {
                throw new ArgumentNullException();
            }

            schedule.DoctorId = Database.Doctors.Find(x => x.Id == entity.DoctorId).FirstOrDefault().Id;
            schedule.Date     = entity.Date;
            schedule.Time     = entity.Time;

            if (schedule.PatientId == 0)
            {
                var list = Database.Schedules.Find(x => x.DoctorId == schedule.DoctorId && TimeParsing(entity.Time).Contains(x.Time));

                foreach (var el in list)
                {
                    Database.Schedules.Delete(el.Id);
                }
            }

            Database.Schedules.Update(schedule);
            Database.Save();
        }
Beispiel #15
0
        //Nssf table Body details
        private void AddNSSFTableBodyDetails(ScheduleDTO det, Table statementInfoTable)
        {
            Cell A = new Cell(new Phrase(det.EmpNo, tcFont));

            A.HorizontalAlignment = Cell.ALIGN_LEFT;
            statementInfoTable.AddCell(A);

            Cell C = new Cell(new Phrase(det.EmpName, tcFont));

            C.HorizontalAlignment = Cell.ALIGN_LEFT;
            statementInfoTable.AddCell(C);

            Cell E = new Cell(new Phrase(det.Amount.ToString("#,##0"), tcFont));

            E.HorizontalAlignment = Cell.ALIGN_RIGHT;
            statementInfoTable.AddCell(E);

            Cell D = new Cell(new Phrase(det.EmpNSSFContrib.ToString("#,##0"), tcFont));

            D.HorizontalAlignment = Cell.ALIGN_RIGHT;
            statementInfoTable.AddCell(D);

            Cell F = new Cell(new Phrase(det.TotalContribs.ToString("#,##0"), tcFont));

            F.HorizontalAlignment = Cell.ALIGN_RIGHT;
            statementInfoTable.AddCell(F);
        }
Beispiel #16
0
        public void UpdatingSchedule_ReturnsNewSchedule()
        {
            // Arrange
            var old         = new ScheduleDTO("old", "xyz", "abc");
            var newName     = "def";
            var newCompany  = "ghi";
            var newId       = "jkl";
            var newSchedDto = new ScheduleDTO(newName, newId, newCompany);
            var newSched    = new Schedule(newId, newCompany, newName);

            // Mock the interface and implementation
            _mockHandler.Setup(x => x.Update(It.IsAny <ScheduleDTO>())).Returns(newSchedDto);

            // Act
            var actual = _schedCol.Update(newSched);

            // Assert
            // Asserting that the value is actually updated and is not the old schedule
            Assert.AreEqual(newSched.Name, actual.Name);
            Assert.AreNotEqual(old.Name, actual.Name);
            Assert.AreEqual(newSched.CompanyId, actual.CompanyId);
            Assert.AreNotEqual(old.CompanyId, actual.CompanyId);
            Assert.AreEqual(newSched.ScheduleId, actual.ScheduleId);
            Assert.AreNotEqual(old.ScheduleId, actual.ScheduleId);
        }
Beispiel #17
0
        public ActionResult EditSchedule(ScheduleDTO scheduleDTO)
        {
            //if (scheduleDTO.StartTime < DateTime.Now.AddHours(-1)  //Ensure entry is a valid start date and finish date
            //    || scheduleDTO.FinishTime < scheduleDTO.StartTime)
            //    ModelState.AddModelError(String.Empty, "Start time must be after current time and before the finish time");

            if (ModelState.IsValid)
            {
                using (HttpClientWrapper httpClient = new HttpClientWrapper(Session))
                {
                    var responseMessage = httpClient.PutAsJsonAsync("api/ScheduleAPI/" + scheduleDTO.Id.ToString(), scheduleDTO).Result;

                    if (responseMessage.IsSuccessStatusCode)
                    {
                        return(RedirectToAction("IndexSchedule"));
                    }
                    else
                    { //If and error occurred add details to model error.
                        var error = JsonConvert.DeserializeObject <System.Web.Http.HttpError>(responseMessage.Content.ReadAsStringAsync().Result);
                        ModelState.AddModelError(String.Empty, error.Message);
                    }
                }
            }
            LoadViewBag();
            return(PartialView(scheduleDTO));
        }
Beispiel #18
0
        public void GetShiftsFromSchedule_ReturnsProperList()
        {
            // Arrange
            var sched  = new ScheduleDTO("hello", "test", "company");
            var shift1 = new ShiftDTO("1", "test", "user", DateTime.Now, 1, 2);
            var shift2 = new ShiftDTO("2", "test", "user", DateTime.Now, 1, 2);
            var shift3 = new ShiftDTO("3", "test", "user", DateTime.Now, 1, 2);
            var shift4 = new ShiftDTO("4", "test", "user", DateTime.Now, 1, 2);
            var dtos   = new List <ShiftDTO>()
            {
                shift1, shift2, shift3, shift4
            };

            // Mock the interface and implementation
            var mock = new Mock <IScheduleHandler>();

            _mockHandler.Setup(x => x.GetShiftsFromSchedule("test")).Returns(dtos);

            // Act
            // I am using sched.scheduleId to check if it actually gets the id properly
            var actual = _schedCol.GetShiftsFromSchedule(sched.ScheduleId);

            // Assert
            for (int i = 0; i < actual.Count; i++)
            {
                Assert.AreEqual(dtos[i].ScheduleId, actual[i].ScheduleId);
                Assert.AreEqual(dtos[i].ShiftId, actual[i].ShiftId);
                Assert.AreEqual(dtos[i].UserId, actual[i].UserId);
                Assert.AreEqual(dtos[i].ShiftDate, actual[i].ShiftDate);
                Assert.AreEqual(dtos[i].StartTime, actual[i].StartTime);
                Assert.AreEqual(dtos[i].EndTime, actual[i].EndTime);
            }
        }
        public void CreateScheduleTest()
        {
            ScheduleServise    scheduleServise    = new ScheduleServise(uow, new Map <Schedule, ScheduleDTO>(), new Map <ScheduleDay, ScheduleDayDTO>());
            EmployeeService    employeeService    = new EmployeeService(uow, new Map <Employee, EmployeeDTO>());
            ProjectService     projectService     = new ProjectService(uow, new Map <Project, ProjectDTO>());
            ProjectWorkService projectWorkService = new ProjectWorkService(uow, new Map <ProjectWork, ProjectWorkDTO>());

            EmployeeDTO employee = new EmployeeDTO
            {
                EmployeeName       = "Екатерина",
                EmployeeSurname    = "Антонович",
                EmployeePatronymic = "Алексеевна",
                RoleId             = 3,
                Email = "*****@*****.**",
            };
            var employeeOnWork = employeeService.CreateEmployee(employee);
            var em             = employeeService.GetEmployeeById(employeeOnWork.Id);

            ProjectDTO project = new ProjectDTO
            {
                ProjectName        = "проект 1",
                ProjectDescription = "проект номер один",
                ProjectStartDate   = new DateTimeOffset(2021, 10, 6, 10, 15, 35, new TimeSpan(3, 0, 0)),
                ProjectEndDate     = new DateTimeOffset(2021, 10, 21, 10, 15, 35, new TimeSpan(3, 0, 0))
            };
            var proj = projectService.CreateProject(project);
            var pr   = projectService.GetProjectById(proj.Id);

            ProjectWorkDTO projectWork = new ProjectWorkDTO
            {
                EmployeeId    = em.Id,
                ProjectId     = pr.Id,
                ProjectRoleId = 3
            };
            var pWork = projectWorkService.CreateProjectWork(projectWork);
            var prw   = projectWorkService.GetProjectWorkById(pWork.Id);

            ScheduleDTO schedule = new ScheduleDTO
            {
                ProjectWorkId = prw.Id,
                ScheduleDayId = 1
            };

            var         sch      = scheduleServise.CreateSchedule(schedule);
            ScheduleDTO actual   = scheduleServise.GetScheduleById(sch.Id);
            ScheduleDTO expected = new ScheduleDTO
            {
                Id            = actual.Id,
                ProjectWorkId = prw.Id,
                ScheduleDayId = 1
            };

            Assert.IsTrue(actual.Id == expected.Id && actual.ProjectWorkId == expected.ProjectWorkId &&
                          actual.ScheduleDayId == expected.ScheduleDayId);

            scheduleServise.DeleteScheduleById(actual.Id);
            projectWorkService.DeleteProjectWorkById(prw.Id);
            employeeService.DeleteEmployeeById(em.Id);
            projectService.DeleteProjectById(pr.Id);
        }
Beispiel #20
0
        public void GetAll_ReturnsList()
        {
            // Arrange
            // Setting up the expected dto list
            ScheduleDTO        dto1 = new ScheduleDTO("1", "1", "1");
            ScheduleDTO        dto2 = new ScheduleDTO("2", "2", "2");
            ScheduleDTO        dto3 = new ScheduleDTO("3", "3", "3");
            List <ScheduleDTO> dtos = new List <ScheduleDTO>()
            {
                dto1, dto2, dto3
            };

            // Mocking the repo and implementation
            _mockHandler.Setup(x => x.GetAll()).Returns(dtos);

            // Act
            var actual = _schedCol.GetAll();

            // Assert
            for (int i = 0; i < dtos.Count; i++)
            {
                Assert.AreEqual(dtos[i].Name, actual[i].Name);
                Assert.AreEqual(dtos[i].CompanyId, actual[i].CompanyId);
            }
        }
        public Response <ScheduleDTO> BulkReschedule(ScheduleDTO scheduleDTO, [FromUri] bool ignoreMaxAgeRule = false, [FromUri] bool ignoreMinAgeFromDOB = false, [FromUri] bool ignoreMinGapFromPreviousDose = false)
        {
            try
            {
                using (VDEntities entities = new VDEntities())
                {
                    var dbSchedule = entities.Schedules.Where(x => x.ID == scheduleDTO.ID).FirstOrDefault();

                    var dbSchedules = entities.Schedules.Where(x => x.Date == dbSchedule.Date &&
                                                               x.ChildId == dbSchedule.ChildId &&
                                                               x.IsDone == false
                                                               ).ToList();

                    foreach (var schedule in dbSchedules)
                    {
                        ChangeDueDatesOfSchedule(scheduleDTO, entities, schedule, "bulk", ignoreMaxAgeRule, ignoreMinAgeFromDOB, ignoreMinGapFromPreviousDose);
                    }

                    return(new Response <ScheduleDTO>(true, "schedule updated successfully.", null));
                }
            }
            catch (Exception e)
            {
                return(new Response <ScheduleDTO>(false, GetMessageFromExceptionObject(e), null));
            }
        }
        // POST api/calendarapi
        public HttpResponseMessage Post([FromBody] ScheduleDTO scheduleDTO)
        {
            if (ModelState.IsValid)
            {
                var recurringCalendarEvent = MapperFacade.MapperConfiguration.Map <ScheduleDTO, Schedule>(scheduleDTO);
                //recurringCalendarEvent.Id = Guid.NewGuid(); //Assign new ID on save.

                //Ensure unsupported options are not created
                if (scheduleDTO.Frequency != 0 && scheduleDTO.Frequency != 1 && scheduleDTO.Frequency != 2)
                {
                    throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.ExpectationFailed, "Frequency not supported. Must be once off (0), Daily (1) or Weekly(2)"));
                }

                //Lookup Business and attach, so that no updates or inserts are performed on BusinessType lookup table
                recurringCalendarEvent.UserProfile = db.UserProfiles.Single(u => u.Email == User.Identity.Name);
                if (recurringCalendarEvent.UserProfile == null)
                {
                    throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Userprofile is null"));
                }
                try
                {
                    db.Schedules.Add(recurringCalendarEvent);
                    db.SaveChanges();
                }
                catch (Exception ex)
                {
                    var mes = ex.Message;
                }
                return(Request.CreateResponse(HttpStatusCode.Created));
            }
            else
            {
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
            }
        }
        public Response <List <ScheduleDTO> > GetVaccineBrands(ScheduleDTO scheduleDto)
        {
            try
            {
                using (VDEntities entities = new VDEntities())
                {
                    var dbSchedule = entities.Schedules.Where(x => x.Date == scheduleDto.Date && x.ChildId == scheduleDto.ChildId).ToList();

                    List <ScheduleDTO> scheduleDTOs = new List <ScheduleDTO>();
                    foreach (var schedule in dbSchedule)
                    {
                        ScheduleDTO     scheduleDTO = new ScheduleDTO();
                        var             dbBrands    = schedule.Dose.Vaccine.Brands.ToList();
                        List <BrandDTO> brandDTOs   = Mapper.Map <List <BrandDTO> >(dbBrands);
                        scheduleDTO.Dose   = Mapper.Map <DoseDTO>(schedule.Dose);
                        scheduleDTO.ID     = schedule.ID;
                        scheduleDTO.Brands = brandDTOs;
                        scheduleDTO.Date   = schedule.Date;
                        scheduleDTO.IsDone = schedule.IsDone;
                        scheduleDTOs.Add(scheduleDTO);
                    }

                    return(new Response <List <ScheduleDTO> >(true, null, scheduleDTOs));
                }
            }
            catch (Exception e)
            {
                return(new Response <List <ScheduleDTO> >(false, GetMessageFromExceptionObject(e), null));
            }
        }
Beispiel #24
0
        public void FindOpenRestaurantsByDate_Should_Return_New_List_When_Any_Resto_Is_Open()
        {
            //Arrange
            var mock      = new Mock <IRestoRepository>();
            var schedules = new List <ScheduleDTO>();
            var schedule  = new ScheduleDTO
            {
                TimeOpen   = DateTime.Now,
                TimeClosed = DateTime.Now.AddHours(3),
                DayOfWeek  = (int)DateTime.Now.DayOfWeek
            };

            schedules.Add(schedule);
            mock.Setup(x => x.GetAll()).Returns(new List <RestoDTO>()
            {
                new RestoDTO {
                    City = "Bruxelles", Id = 1, Name = "R1", Schedules = new List <ScheduleDTO>()
                },
                new RestoDTO {
                    City = "Bruxelles", Id = 2, Name = "R2", Schedules = new List <ScheduleDTO>()
                },
                new RestoDTO {
                    City = "Liege", Id = 3, Name = "R3", Schedules = new List <ScheduleDTO>()
                },
            });
            RestaurantUC target = new RestaurantUC(mock.Object);

            //Act
            var result = target.FindOpenRestaurantsByDate(schedule.TimeOpen).ToList();

            //Assert
            Assert.AreEqual(result.Count, 0);
        }
        public void Edit(ScheduleDTO scheduleDTO)
        {
            try
            {
                if (scheduleDTO != null)
                {
                    var schedule = _airplaneContext.Schedules.FirstOrDefault(c => c.Id == scheduleDTO.ID);
                    if (schedule != null)
                    {
                        schedule.IdFlight      = scheduleDTO.FlightID;
                        schedule.IdFlightState = scheduleDTO.FlightStateID;
                        schedule.DepartureDT   = scheduleDTO.DepartureDT;
                        schedule.ArrivalDT     = scheduleDTO.ArrivalDT;
                        schedule.Comment       = scheduleDTO.Comment;

                        _airplaneContext.SaveChanges();
                    }
                    else
                    {
                        throw new AirportServiceException("Couldn't edit schedule. Provided schedule doesn't exist.");
                    }
                }
                else
                {
                    throw new AirportServiceException("Couldn't edit schedule. Provided data was invalid.");
                }
            }
            catch (DbUpdateException ex)
            {
                throw new AirportServiceException("Couldn't edit schedule. Provided data was invalid.");
            }
        }
        public bool Save(ScheduleDTO scheduleDTO)
        {
            if (scheduleDTO.ID == 0)
            {
                scheduleDTO.ID = MockDatabase.UniqueID;
                MockDatabase.UniqueID++;
                MockDatabase.Schedules.Add(scheduleDTO);
            }
            else
            {
                var schedule = MockDatabase.Schedules.FirstOrDefault(s => s.ID == scheduleDTO.ID);

                if (schedule == null)
                {
                    return(false);
                }

                schedule.Title               = scheduleDTO.Title;
                schedule.Frequency           = scheduleDTO.Frequency;
                schedule.DaysOfWeek          = scheduleDTO.DaysOfWeek;
                schedule.WeeklyInterval      = scheduleDTO.WeeklyInterval;
                schedule.MonthlyInterval     = scheduleDTO.MonthlyInterval;
                schedule.NumberOfOccurrences = scheduleDTO.NumberOfOccurrences;
                schedule.StartDate           = scheduleDTO.StartDate;
                schedule.EndDate             = scheduleDTO.EndDate;
                schedule.StartTime           = scheduleDTO.StartTime;
                schedule.EndTime             = scheduleDTO.EndTime;
            }

            return(true);
        }
Beispiel #27
0
        public IActionResult UpdatePatient(int id, [FromBody] ScheduleDTO sched)
        {
            if (sched == null)
            {
                return(BadRequest());
            }

            if (sched.MRN == string.Empty)
            {
                ModelState.AddModelError("MRN", "Medical record number can not be empty");
            }

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var patToUpdate = _scheduleRepository.GetScheduleByKey(sched.Key);

            if (patToUpdate == null)
            {
                return(NotFound());
            }

            _scheduleRepository.Update(sched);

            return(NoContent()); //success
        }
        private void LoadDataFromQueryRequest(string scheduleID, int roomID)
        {
            ScheduleDTO sDTO       = sDAO.GetScheduleDTO((List <ScheduleDTO>)Session["ScheduleList"], scheduleID);
            string      movieID    = sDTO.MovieID;
            string      movieTitle = mDAO.getMovieDTOByMovieID((List <MovieDTO>)Session["MovieList"], movieID).MovieTitle;

            EnableSelect();
            roomTitle.Text = "Room " + roomID;

            dlMovieList.SelectedValue = movieTitle;

            dlScheduleID.Items.Clear();
            dlScheduleList.Items.Clear();

            dlScheduleList.Items.Add("--Select a schedule--");
            List <ScheduleDTO> scheduleList = sDAO.getSpecificMovieSchedule((List <ScheduleDTO>)Session["ScheduleList"], movieID);

            LoadScheduleToDropDownList(scheduleList);
            dlScheduleList.Enabled       = true;
            dlScheduleList.SelectedValue = sDTO.ScheduleDate + " at Room No. " + sDTO.RoomID;


            dlTicketNum.Items.Clear();

            List <string> bookedSeatList = odDAO.GetAllSeats(scheduleID);
            int           bookedSeat;

            if (bookedSeatList == null)
            {
                bookedSeat = 0;
            }
            else
            {
                bookedSeat = bookedSeatList.Count;
            }
            int remainingSeat = rDAO.getRoom((List <RoomDTO>)Session["RoomList"], roomID).NumberOfSeat - bookedSeat;

            if (remainingSeat >= 10)
            {
                LoadAvailableSeat(10);
            }
            else
            {
                LoadAvailableSeat(remainingSeat);
            }
            dlTicketNum.Enabled                = true;
            lblPriceTicket.Text                = "Per Ticket costs " + sDTO.PriceOfTicket + " $";
            lblPriceTicket.Visible             = true;
            lblTicketNoti.Visible              = true;
            Session["SelectionAvailable"]      = 1;
            Session["SelectedSeats"]           = new List <string>();
            Session["CurrentPage"]             = "BookTicketPage.aspx";
            Session["CurrentSelectdlMovie"]    = dlMovieList.SelectedValue;
            Session["CurrentSelectdlSchedule"] = sDTO.ScheduleID;
            UpdateTicketMessage();

            List <Button> seaList = loadSeatList();

            MarkBookedSeats(bookedSeatList, seaList);
        }
Beispiel #29
0
        private void btnAddTimeInterval_Click_1(object sender, EventArgs e)
        {
            try
            {
                using (var controller = this.iFactory.GetController <ManageScheduleHandler>())
                {
                    DataGridViewRow    row          = dgvDateInterval.CurrentRow;
                    ScheduleDTO        dateInterval = dgvDateInterval.GetItem(row.Index);
                    ScheduleEntryDTO   timeInterval = new ScheduleEntryDTO();
                    IAddModifyViewForm ventana      = new AgregarModificarIntervaloTiempo(this.iFactory);
                    ventana.Add((IDTO)timeInterval);
                    DialogResult resultado = ventana.ShowForm();
                    if (resultado == DialogResult.OK)
                    {
                        dateInterval.ActiveHours.Add(timeInterval);
                    }
                }
            }
            catch
            {
                throw;
            }

            //TODO revisar esto
        }
Beispiel #30
0
        public ScheduleDTO GetSchedule(int pId)
        {
            ScheduleDTO lResult = new ScheduleDTO();

            iUoW.BeginTransaction();
            try
            {
                lResult = Mapper.Map <Schedule, ScheduleDTO>(iServ.Read(pId));
            }
            finally
            {
                iUoW.Rollback();
            }

            return(lResult);
            //TODO esto lo comenté y no lo borré por el tema del helper, por las dudas
            //  Schedule lTemp;

            //      lTemp = serv.Read(pId);
            //      //lResult = MapperHelper.Map<Schedule, ScheduleDTO>(lTemp, lResult);
            //      lResult = Mapper.Map<Schedule, ScheduleDTO>(lTemp);

            ////  lResult = MapperHelper.Map<Schedule,ScheduleDTO>(lTemp,lResult);
            //  return lResult;
        }