public IHttpActionResult Get(int id)
        {
            User = System.Web.HttpContext.Current.User;
            int user;

            int.TryParse(((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Id").Value, out user);

            ((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin");
            if (((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin").Value == "false" &&
                user != id)
            {
                return(Content(HttpStatusCode.Forbidden, "Brak uprawnień do wykonania zadania!"));
            }
            try
            {
                Models.DataBaseEntities db        = new Models.DataBaseEntities();
                Models.Pracownik        pracownik = db.Pracownik.First(p => p.Id == id);

                return(Ok(new Models.PracownikToSend(pracownik, true)));
            }
            catch (InvalidOperationException ex)
            {
                return(Content(HttpStatusCode.NotFound, "Nie znaleziono pracownika o id " + id));
            }
            catch (Exception ex)
            {
                return(Content(HttpStatusCode.InternalServerError, "Błąd serwera"));
            }
        }
Example #2
0
        public IHttpActionResult Put(Models.DzienRoboczyPracownikaToSend dzienRoboczy)
        {
            User = System.Web.HttpContext.Current.User;
            int user;

            int.TryParse(((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Id").Value, out user);

            ((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin");
            if (((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin").Value == "false")
            {
                return(Content(HttpStatusCode.Forbidden, "Brak uprawnień do wykonania zadania!"));
            }

            Models.DzienRoboczyPracownika drp = null;
            try
            {
                Models.DataBaseEntities db        = new Models.DataBaseEntities();
                Models.Pracownik        pracownik = db.Pracownik.First(p => p.Id == dzienRoboczy.pracownik);

                drp = pracownik.DzienRoboczyPracownika.FirstOrDefault(d => d.DzienTygodnia.Id == dzienRoboczy.dzien);
                if (drp != null)
                {
                    drp.Poczatek = dzienRoboczy.poczatek;
                    drp.Koniec   = dzienRoboczy.koniec;
                }
                else
                {
                    drp = new Models.DzienRoboczyPracownika();
                    drp.DzienTygodnia = db.DzienTygodnia.First(d => d.Id == dzienRoboczy.dzien);
                    drp.Koniec        = dzienRoboczy.koniec;
                    drp.Poczatek      = dzienRoboczy.poczatek;
                    drp.Pracownik     = pracownik;

                    db.DzienRoboczyPracownika.Add(drp);
                }

                db.SaveChanges();
            }
            catch (DbEntityValidationException e)
            {
                string wiadomosc = "";
                foreach (DbValidationError er in e.EntityValidationErrors.First().ValidationErrors)
                {
                    wiadomosc += er.ErrorMessage + "\n";
                }
                return(Content(HttpStatusCode.BadRequest, wiadomosc));
            }
            catch (InvalidOperationException ex)
            {
                return(Content(HttpStatusCode.NotFound, "Nie znaleziono pracownika o id " + dzienRoboczy.pracownik));
            }
            catch (Exception ex)
            {
                return(Content(HttpStatusCode.InternalServerError, "Błąd serwera"));
            }

            return(Ok(drp.Id));
        }
Example #3
0
        public IHttpActionResult List(int id, DateTime data, Boolean zatwierdzone)
        {
            User = System.Web.HttpContext.Current.User;
            int user;

            int.TryParse(((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Id").Value, out user);

            ((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin");
            if (((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin").Value == "false" &&
                user != id)
            {
                return(Content(HttpStatusCode.Forbidden, "Brak uprawnień do wykonania zadania!"));
            }

            List <Models.UrlopToSend> lista = new List <Models.UrlopToSend>();

            try
            {
                Models.DataBaseEntities db        = new Models.DataBaseEntities();
                Models.Pracownik        pracownik = db.Pracownik.First(p => p.Id == id);

                if (zatwierdzone)
                {
                    foreach (Models.Urlop u in db.Urlop.Where(u => u.Zatwierdzony && u.DzienUrlopu.OrderBy(dd => dd.Dzien_Data).FirstOrDefault().Dzien_Data >= data))
                    //foreach (Models.Urlop u in pracownik.Urlop.Where(ur => ur.Zatwierdzony == true))
                    {
                        lista.Add(new Models.UrlopToSend(u));
                    }
                }
                else
                {
                    foreach (Models.Urlop u in pracownik.Urlop.Where(u => u.DzienUrlopu.OrderBy(dd => dd.Dzien_Data).FirstOrDefault().Dzien_Data >= data))
                    //foreach (Models.Urlop u in pracownik.Urlop)
                    {
                        lista.Add(new Models.UrlopToSend(u));
                    }
                }
            }
            catch (InvalidOperationException ex)
            {
                return(Content(HttpStatusCode.NotFound, "Nie znaleziono pracownika o id " + id));
            }
            catch (Exception ex)
            {
                return(Content(HttpStatusCode.InternalServerError, "Błąd serwera"));
            }

            return(Ok(lista));
        }
Example #4
0
        public IHttpActionResult Delete(int pracownik, int dzien)
        {
            User = System.Web.HttpContext.Current.User;
            int user;

            int.TryParse(((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Id").Value, out user);

            ((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin");
            if (((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin").Value == "false")
            {
                return(Content(HttpStatusCode.Forbidden, "Brak uprawnień do wykonania zadania!"));
            }

            Models.DzienRoboczyPracownika drp = null;
            try
            {
                Models.DataBaseEntities db = new Models.DataBaseEntities();
                Models.Pracownik        pr = db.Pracownik.First(p => p.Id == pracownik);
                if (dzien < 0 || dzien > 6)
                {
                    throw new ArgumentException();
                }

                drp = pr.DzienRoboczyPracownika.FirstOrDefault(d => d.DzienTygodnia.Id == dzien);

                db.DzienRoboczyPracownika.Remove(drp);

                db.SaveChanges();
            }
            catch (ArgumentException ex)
            {
                return(Content(HttpStatusCode.NotFound, "Nie ma dnia tygodnia nr " + dzien));
            }
            catch (InvalidOperationException ex)
            {
                return(Content(HttpStatusCode.NotFound, "Nie znaleziono pracownika o id " + pracownik));
            }
            catch (Exception ex)
            {
                return(Content(HttpStatusCode.InternalServerError, "Błąd serwera"));
            }

            return(Ok(drp.Id));
        }
        public IHttpActionResult Get()
        {
            try
            {
                Models.DataBaseEntities db = new Models.DataBaseEntities();
                int user = int.Parse(((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Id").Value);
                Models.Pracownik pracownik = db.Pracownik.First(p => p.Id == user);

                return(Ok(new Models.PracownikToSend(pracownik, true)));
            }
            catch (InvalidOperationException ex)
            {
                return(Content(HttpStatusCode.NotFound, "Nie istnieje pracownik odpowiadający przesłanemu tokenowi"));
            }
            catch (Exception ex)
            {
                return(Content(HttpStatusCode.InternalServerError, "Błąd serwera"));
            }
        }
        public IHttpActionResult Delete(int id)
        {
            User = System.Web.HttpContext.Current.User;
            int user;

            int.TryParse(((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Id").Value, out user);

            ((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin");
            if (((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin").Value == "false")
            {
                return(Content(HttpStatusCode.Forbidden, "Brak uprawnień do wykonania zadania!"));
            }

            try
            {
                Models.DataBaseEntities db = new Models.DataBaseEntities();

                Models.Pracownik pracownik = db.Pracownik.First(p => p.Id == id);

                pracownik.Administrator = false;
                pracownik.GodzinWUmowie = 0;
                pracownik.StanowiskoPracownika.Clear();
                pracownik.Urlop.Clear();
                pracownik.DzienRoboczyPracownika.Clear();

                db.SaveChanges();
            }
            catch (InvalidOperationException ex)
            {
                return(Content(HttpStatusCode.NotFound, "Nie znaleziono pracownika o id " + id));
            }
            catch (Exception ex)
            {
                return(Content(HttpStatusCode.InternalServerError, "Błąd serwera"));
            }

            return(Ok());
        }
        public IHttpActionResult Patch(Models.PracownikToSend pracownik)
        {
            User = System.Web.HttpContext.Current.User;
            int user;

            int.TryParse(((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Id").Value, out user);

            ((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin");
            if (((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin").Value == "false" &&
                user != pracownik.Id)
            {
                return(Content(HttpStatusCode.Forbidden, "Brak uprawnień do wykonania zadania!"));
            }
            try
            {
                Models.DataBaseEntities db = new Models.DataBaseEntities();

                Models.Pracownik pr = db.Pracownik.First(p => p.Id == pracownik.Id);
                if (pracownik.Imie != null && pracownik.Imie.Length > 0)
                {
                    pr.Imie = pracownik.Imie;
                }
                if (pracownik.Nazwisko != null && pracownik.Nazwisko.Length > 0)
                {
                    pr.Nazwisko = pracownik.Nazwisko;
                }
                if (pracownik.Haslo != null && pracownik.Haslo.Length > 0)
                {
                    pr.Haslo = HashPassword(pracownik.Haslo);
                }
                if (pracownik.Email != null && pracownik.Email.Length > 0)
                {
                    pr.Email = pracownik.Email;
                }
                if (pracownik.GodzinWUmowie != null)
                {
                    pr.GodzinWUmowie = pracownik.GodzinWUmowie;
                }
                pr.Administrator = pracownik.Administrator;

                if (pracownik.DniRobocze != null)
                {
                    db.DzienRoboczyPracownika.RemoveRange(pr.DzienRoboczyPracownika);
                    pr.DzienRoboczyPracownika.Clear();

                    foreach (Models.DzienRoboczyPracownikaToSend drpts in pracownik.DniRobocze)
                    {
                        if (drpts.poczatek >= drpts.koniec)
                        {
                            return(Content(HttpStatusCode.BadRequest, "Godzina zakończenai musi być po godzinie rozpoczęcia!"));
                        }
                        Models.DzienRoboczyPracownika drp = new Models.DzienRoboczyPracownika();
                        drp.DzienTygodnia = db.DzienTygodnia.First(d => d.Id == drpts.dzien);
                        drp.Pracownik     = pr;
                        drp.Poczatek      = drpts.poczatek;
                        drp.Koniec        = drpts.koniec;

                        db.DzienRoboczyPracownika.Add(drp);
                    }
                }

                if (pracownik.Stanowiska != null)
                {
                    db.StanowiskoPracownika.RemoveRange(pr.StanowiskoPracownika);
                    pr.StanowiskoPracownika.Clear();

                    foreach (Models.StanowiskoPracownikaToSend spts in pracownik.Stanowiska)
                    {
                        Models.StanowiskoPracownika sp = new Models.StanowiskoPracownika();
                        sp.Pracownik  = pr;
                        sp.Stanowisko = db.Stanowisko.First(s => s.Id == spts.StanowiskoId);

                        db.StanowiskoPracownika.Add(sp);
                    }
                }

                db.SaveChanges();
            }
            catch (InvalidOperationException ex)
            {
                return(Content(HttpStatusCode.NotFound, "Nie znaleziono pracownika o id " + pracownik.Id));
            }
            catch (DbEntityValidationException e)
            {
                string wiadomosc = "";
                foreach (DbValidationError er in e.EntityValidationErrors.First().ValidationErrors)
                {
                    wiadomosc += er.ErrorMessage + "\n";
                }
                return(Content(HttpStatusCode.BadRequest, wiadomosc));
            }
            catch (Exception ex)
            {
                return(Content(HttpStatusCode.InternalServerError, "Błąd serwera"));
            }


            return(Ok());
        }
        public IHttpActionResult Put(Models.PracownikToSend pracownik)
        {
            User = System.Web.HttpContext.Current.User;
            int user;

            int.TryParse(((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Id").Value, out user);

            ((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin");
            if (((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin").Value == "false")
            {
                return(Content(HttpStatusCode.Forbidden, "Brak uprawnień do wykonania zadania!"));
            }
            Models.Pracownik pr = new Models.Pracownik();
            try
            {
                Models.DataBaseEntities db = new Models.DataBaseEntities();

                pr.Imie          = pracownik.Imie;
                pr.Nazwisko      = pracownik.Nazwisko;
                pr.Haslo         = HashPassword(pracownik.Haslo);
                pr.Administrator = false;
                pr.GodzinWUmowie = pracownik.GodzinWUmowie;
                pr.Email         = pracownik.Email;

                if (pracownik.DniRobocze != null)
                {
                    foreach (Models.DzienRoboczyPracownikaToSend drpts in pracownik.DniRobocze)
                    {
                        Models.DzienRoboczyPracownika drp = new Models.DzienRoboczyPracownika();
                        drp.DzienTygodnia = db.DzienTygodnia.First(d => d.Id == drpts.dzien);
                        drp.Pracownik     = pr;
                        drp.Poczatek      = drpts.poczatek;
                        drp.Koniec        = drpts.koniec;

                        db.DzienRoboczyPracownika.Add(drp);
                    }
                }

                if (pracownik.Stanowiska != null)
                {
                    foreach (Models.StanowiskoPracownikaToSend spts in pracownik.Stanowiska)
                    {
                        Models.StanowiskoPracownika sp = new Models.StanowiskoPracownika();
                        sp.Pracownik  = pr;
                        sp.Stanowisko = db.Stanowisko.First(s => s.Id == spts.StanowiskoId);

                        db.StanowiskoPracownika.Add(sp);
                    }
                }

                db.Pracownik.Add(pr);

                db.SaveChanges();
            }
            catch (DbEntityValidationException e)
            {
                string wiadomosc = "";
                foreach (DbValidationError er in e.EntityValidationErrors.First().ValidationErrors)
                {
                    wiadomosc += er.ErrorMessage + "\n";
                }
                return(Content(HttpStatusCode.BadRequest, wiadomosc));
            }
            catch (Exception ex)
            {
                return(Content(HttpStatusCode.InternalServerError, "Błąd serwera"));
            }

            return(Ok(pr.Id));
        }
Example #9
0
        public IHttpActionResult Put(Models.UrlopToSend urlop)
        {
            User = System.Web.HttpContext.Current.User;
            int user;

            int.TryParse(((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Id").Value, out user);

            ((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin");
            if (((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin").Value == "false" &&
                user != urlop.pracownik)
            {
                return(Content(HttpStatusCode.Forbidden, "Brak uprawnień do wykonania zadania!"));
            }

            Models.Urlop ur = null;
            try
            {
                Models.DataBaseEntities db        = new Models.DataBaseEntities();
                Models.Pracownik        pracownik = db.Pracownik.First(p => p.Id == urlop.pracownik);

                DateTime dzis = DateTime.Now;
                if (urlop.poczatek > urlop.koniec)
                {
                    return(Content(HttpStatusCode.BadRequest, "Początek musi być datę wcześneijszą niż koniec!"));
                }
                if (urlop.poczatek < dzis.Date || urlop.koniec < dzis.Date)
                {
                    return(Content(HttpStatusCode.BadRequest, "Obie daty muszą być w przyszłości!"));
                }

                ur           = new Models.Urlop();
                ur.Powod     = urlop.powod;
                ur.Pracownik = pracownik;
                //ur.DzienUrlopu = new List<Models.DzienUrlopu>();

                db.Urlop.Add(ur);

                for (DateTime dt = urlop.poczatek; dt <= urlop.koniec; dt = dt.AddDays(1))
                {
                    if (pracownik.DzienRoboczyPracownika.FirstOrDefault(d => d.DzienTygodnia.Id == (int)dt.DayOfWeek) != null)
                    {
                        Models.Dzien dzien = db.Dzien.FirstOrDefault(d => d.Data == dt);
                        if (dzien == null)
                        {
                            dzien      = new Models.Dzien();
                            dzien.Data = dt;
                            db.Dzien.Add(dzien);
                        }
                        Models.DzienUrlopu du = new Models.DzienUrlopu();
                        du.Dzien = dzien;
                        du.Urlop = ur;
                        db.DzienUrlopu.Add(du);
                    }
                }


                db.SaveChanges();
            }
            catch (InvalidOperationException ex)
            {
                return(Content(HttpStatusCode.NotFound, "Nie znaleziono pracownika o id " + urlop.pracownik));
            }
            catch (Exception ex)
            {
                return(Content(HttpStatusCode.InternalServerError, "Błąd serwera"));
            }

            return(Ok(ur.Id));
        }
Example #10
0
        public IHttpActionResult DodajPozycje(Models.NaStanowiskuToSend naStanowisku, int grafik)
        {
            User = System.Web.HttpContext.Current.User;
            ((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin");
            if (((ClaimsIdentity)User.Identity).Claims.First(c => c.Type == "Admin").Value == "false")
            {
                return(Content(HttpStatusCode.Forbidden, "Brak uprawnień do wykonania zadania!"));
            }

            try
            {
                Models.DataBaseEntities db = new Models.DataBaseEntities();

                Models.Grafik gr = db.Grafik.FirstOrDefault(g => g.Id == grafik);
                if (gr == null)
                {
                    return(Content(HttpStatusCode.NotFound, "Nie znaleziono grafiku o id " + grafik));
                }

                Models.Pracownik pracownik = db.Pracownik.FirstOrDefault(p => p.Id == naStanowisku.IdPracownika);
                if (pracownik == null)
                {
                    return(Content(HttpStatusCode.NotFound, "Nie znaleziono pracownika o id " + naStanowisku.IdPracownika));
                }

                Models.Stanowisko stanowisko = db.Stanowisko.FirstOrDefault(s => s.Id == naStanowisku.IdStanowiska);
                if (stanowisko == null)
                {
                    return(Content(HttpStatusCode.NotFound, "Nie znaleziono stanowiska o id " + naStanowisku.IdStanowiska));
                }

                Models.Czas godzina = gr.Czas.FirstOrDefault(g => g.Poczatek == naStanowisku.Poczatek && g.Koniec == naStanowisku.Koniec);
                if (godzina == null)
                {
                    godzina          = new Models.Czas();
                    godzina.Poczatek = naStanowisku.Poczatek;
                    godzina.Koniec   = naStanowisku.Koniec;
                    godzina.Grafik   = gr;

                    db.Czas.Add(godzina);
                }
                else
                {
                    foreach (Models.PracownikNaStanowisku pns in godzina.PracownikNaStanowisku)
                    {
                        if (pns.Pracownik.Id == naStanowisku.IdPracownika)
                        {
                            return(Content(HttpStatusCode.BadRequest, "Pracownik znajduje się już na stanowisku"));
                        }
                    }
                }

                Models.PracownikNaStanowisku prns = new Models.PracownikNaStanowisku();
                prns.Pracownik  = pracownik;
                prns.Stanowisko = stanowisko;
                prns.Czas       = godzina;

                db.PracownikNaStanowisku.Add(prns);
                db.SaveChanges();
            }
            catch (Exception ex)
            {
                return(Content(HttpStatusCode.InternalServerError, ex.ToString()));
            }

            return(Ok());
        }