public async Task <ActionResult <UserDTO> > PostUser(UserDTO data)
        {
            var user = await _context.Users.FindAsync(data.Id);

            if (user != null)
            {
                var err = new ValidationErrors().Add("Pseudo already in use", nameof(user.Pseudo));
                return(BadRequest(err));
            }
            var newUser = new User()
            {
                Pseudo    = data.Pseudo,
                Password  = data.Password,
                Email     = data.Email,
                LastName  = data.LastName,
                FirstName = data.FirstName,
                BirthDate = data.BirthDate,
                Role      = data.Role
            };

            _context.Users.Add(newUser);
            var res = await _context.SaveChangesAsyncWithValidation();

            if (!res.IsEmpty)
            {
                return(BadRequest(res));
            }

            return(CreatedAtAction(nameof(GetOne), new { pseudo = newUser.Pseudo }, newUser.ToDTO()));
        }
        public async Task <ActionResult <CardDTO> > PostCard(int listId, CardDTO data)
        {
            var card = await _context.Cards.FindAsync(data.Id);

            if (card != null)
            {
                var err = new ValidationErrors().Add("Card already in use", nameof(card.Name));
                return(BadRequest(err));
            }
            var newCard = new Card()
            {
                Name     = data.Name,
                AuthorId = data.AuthorId,
                ListId   = listId
            };

            _context.Cards.Add(newCard);
            var res = await _context.SaveChangesAsyncWithValidation();

            if (!res.IsEmpty)
            {
                return(BadRequest(res));
            }


            return(CreatedAtAction(nameof(GetOne), new { name = newCard.Name }, newCard.ToDTO()));
        }
Beispiel #3
0
        public async Task <ActionResult <ListDTO> > PostList(int id, ListDTO data)
        {
            var list = await _context.Lists.FindAsync(data.Id);

            if (list != null)
            {
                var err = new ValidationErrors().Add("List already in use", nameof(list.Name));
                return(BadRequest(err));
            }
            var newList = new List()
            {
                Name    = data.Name,
                BoardId = id
            };

            _context.Lists.Add(newList);
            var res = await _context.SaveChangesAsyncWithValidation();

            if (!res.IsEmpty)
            {
                return(BadRequest(res));
            }


            return(CreatedAtAction(nameof(GetOne), new { name = newList.Name }, newList.ToDTO()));
        }
        public async Task <ActionResult <BoardDTO> > PostBoard(BoardDTO data)
        {
            var board = await _context.Boards.FindAsync(data.Id);

            var user = await _context.Users.Where(u => u.Pseudo == User.Identity.Name).SingleOrDefaultAsync();

            if (board != null)
            {
                var err = new ValidationErrors().Add("Board's name already in use", nameof(board.Name));
                return(BadRequest(err));
            }

            var newBoard = new Board()
            {
                Name    = data.Name,
                OwnerId = user.Id
            };

            if (data.Collaborations != null)
            {
                var collabs = data.Collaborations.Select(co => new Collaboration {
                    UserId = co
                });
                foreach (var c in collabs)
                {
                    newBoard.Collaborations.Add(c);
                }
            }

            _context.Boards.Add(newBoard);
            var res = await _context.SaveChangesAsyncWithValidation();

            if (!res.IsEmpty)
            {
                return(BadRequest(res));
            }

            return(CreatedAtAction(nameof(GetOne), new { id = newBoard.Id }, newBoard.ToDTO()));
        }