public async Task <IActionResult> Create([Bind("Id,Date,StartTime,EndTime,Notes,Child_Id,Teacher_Id")] Nap nap)
        {
            if (ModelState.IsValid)
            {
                nap.Id   = Guid.NewGuid();
                nap.Date = DateTime.Now;
                string y = nap.StartTime.Remove(2, 1);
                string x = DateTime.ParseExact(y, "HHmm", CultureInfo.CurrentCulture).ToString("hh:mm tt");
                nap.StartTime = x;
                string z = nap.EndTime.Remove(2, 1);
                string a = DateTime.ParseExact(z, "HHmm", CultureInfo.CurrentCulture).ToString("hh:mm tt");
                nap.EndTime = a;
                var teacher = await _context.Teachers.FirstOrDefaultAsync(m => m.Id == nap.Teacher_Id);

                nap.TeacherName = teacher.FirstName + " " + teacher.LastName;
                _context.Add(nap);
                await _context.SaveChangesAsync();

                return(RedirectToAction("Index", new { id = nap.Child_Id }));
            }

            ViewData["Teacher"] = new SelectList(_context.Teachers, "Id", "FirstName", nap.Teacher_Id);

            return(View(nap));
        }
Beispiel #2
0
        public Nap GetANapBySession(int sessionId, int careTakerId, int napId)
        {
            Nap naps = new Nap();

            using (SqlConnection conn = new SqlConnection(this.connectionString))
            {
                conn.Open();

                const string sql = @"SELECT *
                                        FROM nap
                                        JOIN session ON nap.session_id = session.session_id
                                        JOIN session_caretaker ON session.session_id = session_caretaker.session_id
                                        WHERE nap.session_id = @session_id
                                        AND nap.nap_id = @nap_id
                                        AND session_caretaker.caretaker_id = @caretaker_id";

                SqlCommand cmd = new SqlCommand(sql, conn);
                cmd.Parameters.AddWithValue("@session_id", sessionId);
                cmd.Parameters.AddWithValue("@caretaker_id", careTakerId);
                cmd.Parameters.AddWithValue("@nap_id", napId);

                SqlDataReader rdr = cmd.ExecuteReader();

                while (rdr.Read())
                {
                    naps = ParseRow(rdr);
                }

                return(naps);
            }
        }
        // GET: Naps/Create
        public IActionResult Create(Guid Id)
        {
            ViewData["Teacher"] = new SelectList(_context.Teachers, "Id", "FirstName");
            Nap nap = new Nap();

            nap.Child_Id = Id;
            return(View(nap));
        }
Beispiel #4
0
        public void TestGetANapBySession()
        {
            // Arrange
            NapSqlDAO dao = new NapSqlDAO(this.connectionString);

            // Act
            Nap nap = dao.GetANapBySession(session1, ruth, nap1);

            // Assert
            Assert.AreEqual("Didnt sleep good", nap.Notes);
        }
Beispiel #5
0
        public Nap UpdateNap(Nap nap, int careTakerId)
        {
            using (SqlConnection conn = new SqlConnection(this.connectionString))
            {
                conn.Open();
                string sql;
                if (nap.EndTime == null)
                {
                    sql = @"UPDATE nap
                                        SET nap.start_time = @start_time,
                                        nap.notes = @notes
                                        OUTPUT INSERTED.nap_id
                                        FROM nap
                                        JOIN session ON nap.session_id = session.session_id
                                        JOIN session_caretaker ON session.session_id = session_caretaker.session_id
                                        WHERE nap.nap_id = @nap_id
                                        AND session_caretaker.caretaker_id = @caretaker_id";

                    SqlCommand cmd = new SqlCommand(sql, conn);
                    cmd.Parameters.AddWithValue("@start_time", nap.StartTime);
                    cmd.Parameters.AddWithValue("@notes", nap.Notes);
                    cmd.Parameters.AddWithValue("@nap_id", nap.NapId);
                    cmd.Parameters.AddWithValue("@caretaker_id", careTakerId);

                    nap.NapId = Convert.ToInt32(cmd.ExecuteScalar());
                }
                else
                {
                    sql = @"UPDATE nap
                                        SET nap.start_time = @start_time,
                                        nap.end_time = @end_time,
                                        nap.notes = @notes
                                        OUTPUT INSERTED.nap_id
                                        FROM nap
                                        JOIN session ON nap.session_id = session.session_id
                                        JOIN session_caretaker ON session.session_id = session_caretaker.session_id
                                        WHERE nap.nap_id = @nap_id
                                        AND session_caretaker.caretaker_id = @caretaker_id";

                    SqlCommand cmd = new SqlCommand(sql, conn);
                    cmd.Parameters.AddWithValue("@start_time", nap.StartTime);
                    cmd.Parameters.AddWithValue("@end_time", nap.EndTime);
                    cmd.Parameters.AddWithValue("@notes", nap.Notes);
                    cmd.Parameters.AddWithValue("@nap_id", nap.NapId);
                    cmd.Parameters.AddWithValue("@caretaker_id", careTakerId);

                    nap.NapId = Convert.ToInt32(cmd.ExecuteScalar());
                }

                return(nap);
            }
        }
Beispiel #6
0
        public ActionResult <Nap> UpdateNap(int sessionId, int napId, Nap nap)
        {
            Session checkSession = sessionDao.GetSessionById(sessionId, userId);

            if (checkSession.SessionId == 0)
            {
                return(NotFound());
            }

            nap.NapId = napId;
            Nap updatedNap = napDao.UpdateNap(nap, userId);

            return(Created($"/api/sessions/{sessionId}/naps/{updatedNap.NapId}", updatedNap));
        }
Beispiel #7
0
        public ActionResult <Nap> CreateNap(Nap nap, int sessionId)
        {
            Session session = sessionDao.GetSessionById(sessionId, userId);

            if (session.SessionId == 0)
            {
                return(NotFound());
            }

            nap.SessionId = sessionId;
            Nap newNap = napDao.AddNap(nap);

            return(Created($"/api/sessions/{sessionId}/naps/{newNap.NapId}", newNap));
        }
Beispiel #8
0
        public void TestUpdateNap()
        {
            // Arrange
            NapSqlDAO dao    = new NapSqlDAO(this.connectionString);
            Nap       newNap = new Nap()
            {
                SessionId = session1,
                StartTime = DateTime.Now,
                EndTime   = DateTime.Now,
                Notes     = "Was not Fussy"
            };

            // Act
            Nap nap = dao.UpdateNap(newNap, ruth);

            // Assert
            Assert.AreEqual(newNap.Notes, nap.Notes);
        }
Beispiel #9
0
        public ActionResult <Nap> GetNapById(int sessionId, int napId)
        {
            Session session = sessionDao.GetSessionById(sessionId, userId);

            if (session.SessionId == 0)
            {
                return(NotFound());
            }

            Nap nap = napDao.GetANapBySession(sessionId, userId, napId);

            if (nap.NapId == 0)
            {
                return(NotFound());
            }

            return(Ok(nap));
        }
Beispiel #10
0
        private static void SetNaps(MvvMLoginRegister register, YodaClockDbContext context, Plan plan)
        {
            var naps = new List <Nap>();

            foreach (var nap in register.Plan.Naps)
            {
                var n = new Nap()
                {
                    PlanId     = plan.Id,
                    Name       = nap.Name,
                    Percentage = nap.Percentage
                };

                naps.Add(n);
            }

            context.Naps.AddRange(naps);
            context.SaveChanges();
        }
Beispiel #11
0
        public Nap AddNap(Nap nap)
        {
            using (SqlConnection conn = new SqlConnection(this.connectionString))
            {
                conn.Open();

                const string sql = @"INSERT INTO nap (session_id, start_time, notes)
	                                    VALUES (@session_id, @start_time, @notes)
                                        SELECT @@IDENTITY";

                SqlCommand cmd = new SqlCommand(sql, conn);
                cmd.Parameters.AddWithValue("@session_id", nap.SessionId);
                cmd.Parameters.AddWithValue("@start_time", nap.StartTime);
                cmd.Parameters.AddWithValue("@notes", nap.Notes);

                nap.NapId = Convert.ToInt32(cmd.ExecuteScalar());

                return(nap);
            }
        }
Beispiel #12
0
        private Nap ParseRow(SqlDataReader rdr)
        {
            Nap nap = new Nap();

            nap.NapId     = Convert.ToInt32(rdr["nap_id"]);
            nap.SessionId = Convert.ToInt32(rdr["session_id"]);

            if (rdr["start_time"] != DBNull.Value)
            {
                nap.StartTime = Convert.ToDateTime(rdr["start_time"]);
            }

            if (rdr["end_time"] != DBNull.Value)
            {
                nap.EndTime = Convert.ToDateTime(rdr["end_time"]);
            }

            if (rdr["notes"] != DBNull.Value)
            {
                nap.Notes = Convert.ToString(rdr["notes"]);
            }

            return(nap);
        }