Пример #1
0
        public async Task <IActionResult> PutDormitory(int id, Dormitory dormitory)
        {
            if (id != dormitory.Id)
            {
                return(BadRequest());
            }

            DormValid valid = new DormValid(_context, dormitory);

            if (valid.Valid() == false)
            {
                return(BadRequest("This Dormitory is already exist"));
            }

            _context.Entry(dormitory).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!DormitoryExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Пример #2
0
        public async Task <IActionResult> PutBlok(int id, Blok blok)
        {
            if (id != blok.Id)
            {
                return(BadRequest());
            }

            BlokValid valid = new BlokValid(_context, blok);

            if (valid.Valid() == false)
            {
                return(BadRequest("This Block is already exist"));
            }

            _context.Entry(blok).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!BlokExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Пример #3
0
        public async Task <IActionResult> PutRoom(int id, Room room)
        {
            if (id != room.Id)
            {
                return(BadRequest());
            }

            RoomValid valid = new RoomValid(_context, room);

            if (valid.Valid() == false)
            {
                return(BadRequest("This Room is already exist"));
            }

            _context.Entry(room).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!RoomExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Пример #4
0
        public async Task <IActionResult> PutFloor(int id, Floor floor)
        {
            if (id != floor.Id)
            {
                return(BadRequest());
            }

            FloorValid valid = new FloorValid(_context, floor);

            if (valid.Valid() == false)
            {
                return(BadRequest("This Floor is already exist"));
            }

            _context.Entry(floor).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!FloorExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Пример #5
0
        public async Task <IActionResult> PutOrders(int id, Orders orders)
        {
            if (id != orders.ID)
            {
                return(BadRequest());
            }

            _context.Entry(orders).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!OrdersExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Пример #6
0
        public async Task <IActionResult> PutCampus(int id, Campus campus)
        {
            if (id != campus.Id)
            {
                return(BadRequest());
            }

            CampusValid valid = new CampusValid(_context, campus);

            if (valid.Valid() == false)
            {
                return(BadRequest("This Campus is already exist"));
            }

            _context.Entry(campus).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!CampusExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Пример #7
0
        public async Task <IActionResult> PutUniversity(int id, University university)
        {
            if (id != university.Id)
            {
                return(BadRequest());
            }
            UniversityValid valid = new UniversityValid(_context, university);

            if (valid.Valid() == false)
            {
                return(BadRequest("This University is already exist"));
            }

            _context.Entry(university).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!UniversityExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Пример #8
0
        public async Task <IActionResult> PutClientRoom(int id, ClientRoom clientRoom)
        {
            if (id != clientRoom.ClientRoomID)
            {
                return(BadRequest());
            }


            _context.Entry(clientRoom).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ClientRoomExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Пример #9
0
        public async Task <IActionResult> PutClients(int id, Clients clients)
        {
            if (id != clients.ClientID)
            {
                return(BadRequest());
            }

            var t = _context.Clients.ToList();

            foreach (var tt in t)
            {
                if (tt.Email == clients.Email)
                {
                    return(BadRequest("you're not allowed to create duplicate records"));
                }
            }

            _context.Entry(clients).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ClientsExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }