private static BoardDTO CurrentBoardReducer(BoardDTO currentBoard, IAction action) { switch (action) { case ClearThreadsAction _: return(new BoardDTO()); case GetThreadsAction a: if (currentBoard?.CurrentThread != null) { a.Board.CurrentThread = currentBoard.CurrentThread; } a.Board.Threads.OrderByDescending(e => e.BumpDate ?? e.DateCreated); return(a.Board); case ClearPostsAction _: if (currentBoard != null) { currentBoard.CurrentThread = new PostDTO(); } return(currentBoard); case GetPostsAction a: if (currentBoard?.Id == a.Board.Id) { a.Board.Threads = currentBoard.Threads; } a.Board.CurrentThread.Posts.OrderBy(e => e.DateCreated); return(a.Board); default: return(currentBoard); } }
//Crée un tableau non verrouillé avec ses trois sections (Todo, Doing, Done) public async Task <BoardDTO> CreateBoard(BoardDTO board) { board.IsLocked = false; var boardDb = await boardRepository.Create(board); await sectionRepository.Create(new SectionDTO() { Name = "Todo", BoardId = boardDb.Id }); await sectionRepository.Create(new SectionDTO() { Name = "Doing", BoardId = boardDb.Id }); await sectionRepository.Create(new SectionDTO() { Name = "Done", BoardId = boardDb.Id }); return(boardDb); }
//public List<BoardDTO> GetBoardsByUserID(string userID) //{ // var boardsModel = db_.getBoardsByUser(userID).ToList(); // return boardsModel.Select(b => new BoardDTO(b.Id.ToString(), b.BoardName, b.Starred, b.Color, b.OrderNo)).ToList(); //} public BoardDTO GetById(string id) { BoardModel board = db_.GetBoardById(id); IEnumerable <ListDTO> lists = new List <ListDTO>(); var tempLists = db_.GetListByBoardId(id); if (tempLists != null) { lists = tempLists.Select(l => new ListDTO(l.Id.ToString(), l.Name, l.Order, l.Description)).OrderBy(l => l.Order).ToList(); foreach (var list in lists) { var tempCards = db_.GetCardsByListId(list.Id); if (tempCards != null) { list.Cards = tempCards.Select(c => new CardDTO(c.Id.ToString(), c.Name, c.Order, c.Description, list.Id.ToString(), c.Comments.Select(com => new CommentDTO(com.Id.ToString(), com.UserId.ToString(), com.Text)).ToList(), c.Labels.Select(l => db_.GetLabelById(l)).ToList(), c.DueDate)) .OrderBy(c => c.Order); } } } var result = new BoardDTO(board.Id.ToString(), board.BoardName, board.Starred, board.Color, board.UserCreatedBy.ToString(), lists); result.AllLabels = db_.GetLabels(); return(result); }
public async Task TestPostingValidSet() { SeedDTO seed = new SeedDTO { Seed = 42 }; StringContent postContent = TestUtilities.ObjToStringContent(seed); HttpClient client = TestUtilities.GetHttpClient(); HttpResponseMessage response = await client.PostAsync("newgame", postContent); string content = await response.Content.ReadAsStringAsync(); BoardDTO gameObj = JsonConvert.DeserializeObject <BoardDTO>(content); List <Card> cards = TestUtilities.FindSet(gameObj.Cards); GuessDTO guess = new GuessDTO { GameID = gameObj.GameID, Card1 = cards[0], Card2 = cards[1], Card3 = cards[2] }; StringContent guessContent = TestUtilities.ObjToStringContent(guess); HttpResponseMessage postResponse = await client.PostAsync("submitguess", guessContent); string responseContent = await postResponse.Content.ReadAsStringAsync(); GameDTO gameDTO = JsonConvert.DeserializeObject <GameDTO>(responseContent); Assert.AreEqual(true, gameDTO.ValidSet, "Posted cards should have registered as valid but are invalid"); Assert.AreEqual(78, gameDTO.CardsRemaining, "Cards remaining should have been 78 but are not"); Assert.IsFalse(gameDTO.WinState, "Win state after a single POST should be false but is true"); Assert.IsFalse(TestUtilities.BoardContainsCards(gameDTO.Board, guess.Card1, guess.Card2, guess.Card3), "Posted cards should be removed from the board but are still present"); }
public int AddNewBoard(int categoryId, string name) { if (!string.IsNullOrWhiteSpace(name) && name.Length > 0 && name.Length <= 255) { var category = Get(categoryId); if (category == null) { return(0); } var board = new BoardDTO { Name = name, CardLists = new List <CardListDTO>() }; category.Boards.Add(board); Save(category); return(board.Id); } else { return(0); } }
public IHttpActionResult PutBoard(int id, BoardDTO boardDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != boardDto.Id) { return(BadRequest()); } var board = AutoMapper.Mapper.Map <Board>(boardDto); _unitOfWork.Boards.Put(board); try { _unitOfWork.Complete(); } catch (DbUpdateConcurrencyException) { if (!BoardExists(id)) { return(NotFound()); } else { throw; } } return(StatusCode(HttpStatusCode.NoContent)); }
public static void Update(BoardDTO updateBoard) { try { databaseDataContext db = new databaseDataContext(); var find = (from board in db.Boards where board.Id == updateBoard.Id select board).Single(); find.BoxId = updateBoard.BoxId; find.Width = updateBoard.Width; find.Height = updateBoard.Height; find.Depth = updateBoard.Depth; find.BoardThickness = updateBoard.BoardThickness; find.PositionX = updateBoard.PositionX; find.PositionY = updateBoard.PositionY; find.PositionZ = updateBoard.PositionZ; find.Name = updateBoard.Name; find.Texture = updateBoard.Texture; db.SubmitChanges(); } catch (Exception e) { Console.WriteLine(e.Message); } }
public object GetBoard(int id) { var map = mapper.CreateMapper(); if (id != 0) { BoardDTO board = BoardService.Get(id); BoardViewModel myboard = map.Map <BoardViewModel>(board); return(JsonConvert.SerializeObject(myboard, Formatting.None, new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore })); } else { IEnumerable <BoardDTO> board = BoardService.GetAll(User.Identity.GetUserId()); IEnumerable <BoardViewModel> myboard = map.Map <IEnumerable <BoardViewModel> >(board); return(JsonConvert.SerializeObject(myboard.FirstOrDefault(), Formatting.None, new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore })); } }
public static int Create(BoardDTO boardCreate) { try { databaseDataContext db = new databaseDataContext(); Board board = new Board() { BoxId = boardCreate.BoxId, Width = boardCreate.Width, Height = boardCreate.Height, Depth = boardCreate.Depth, BoardThickness = boardCreate.BoardThickness, PositionX = boardCreate.PositionX, PositionY = boardCreate.PositionY, PositionZ = boardCreate.PositionZ, Name = boardCreate.Name, Texture = boardCreate.Texture }; db.Boards.InsertOnSubmit(board); db.SubmitChanges(); return(board.Id); } catch (Exception e) { Console.WriteLine(e.Message); } return(-1); }
public static BoardDTO Read(int boardId) { BoardDTO boardRead = null; try { databaseDataContext db = new databaseDataContext(); var find = (from board in db.Boards where board.Id == boardId select board).Single(); boardRead = new BoardDTO() { Id = find.Id, BoxId = find.BoxId, Width = find.Width, Height = find.Height, Depth = find.Depth, BoardThickness = find.BoardThickness, PositionX = find.PositionX, PositionY = find.PositionY, PositionZ = find.PositionZ, Name = find.Name, Texture = find.Texture }; } catch (Exception e) { Console.WriteLine(e.Message); } return(boardRead); }
public async Task TestReset() { SeedDTO seed = new SeedDTO { Seed = 42 }; StringContent postContent = TestUtilities.ObjToStringContent(seed); HttpClient client = TestUtilities.GetHttpClient(); HttpResponseMessage response = await client.PostAsync("newgame", postContent); string content = await response.Content.ReadAsStringAsync(); BoardDTO gameObj = JsonConvert.DeserializeObject <BoardDTO>(content); List <Card> cards = TestUtilities.FindSet(gameObj.Cards); GuessDTO guess = new GuessDTO { GameID = gameObj.GameID, Card1 = cards[0], Card2 = cards[1], Card3 = cards[2] }; StringContent guessContent = TestUtilities.ObjToStringContent(guess); HttpResponseMessage postResponse = await client.PostAsync("submitguess", guessContent); string responseContent = await postResponse.Content.ReadAsStringAsync(); gameDTO = JsonConvert.DeserializeObject <GameDTO>(responseContent); Assert.IsFalse(gameDTO.WinState, "After a reset, game marked as won still"); Assert.AreEqual(78, gameDTO.CardsRemaining, "After a reset, expected 78 cards remaining but actual was different"); }
public int Delete(BoardDTO data) { if (data != null) { var map = mapper.CreateMapper(); Board board = map.Map <Board>(data); foreach (ClientProfile user in board.Users) { user.Boards.Remove(board); } foreach (TaskList taskList in board.TaskLists) { foreach (Card card in taskList.Cards) { Database.Cards.Delete(card.Id); } Database.TaskLists.Delete(taskList.Id); } Database.Boards.Delete(board.Id); Database.Save(); return(0); } else { return(-1); } }
public async Task TestSetup() { SeedDTO seed = new SeedDTO { Seed = 42 }; StringContent postContent = TestUtilities.ObjToStringContent(seed); HttpClient client = TestUtilities.GetHttpClient(); HttpResponseMessage response = await client.PostAsync("newgame", postContent); string content = await response.Content.ReadAsStringAsync(); BoardDTO gameObj = JsonConvert.DeserializeObject <BoardDTO>(content); gameDTO = new GameDTO { Board = gameObj.Cards, GameID = gameObj.GameID }; for (int i = 0; i < 24; i++) { List <Card> cards = TestUtilities.FindSet(gameDTO.Board); GuessDTO guess = new GuessDTO { GameID = gameDTO.GameID, Card1 = cards[0], Card2 = cards[1], Card3 = cards[2] }; StringContent guessContent = TestUtilities.ObjToStringContent(guess); HttpResponseMessage postResponse = await client.PostAsync("submitguess", guessContent); string responseContent = await postResponse.Content.ReadAsStringAsync(); gameDTO = JsonConvert.DeserializeObject <GameDTO>(responseContent); } }
public bool CheckIsWin(BoardDTO board, BoardCellDTO selectedCell) { return(IsWinInBoardRow(board, selectedCell) || IsWinInBoardColumn(board, selectedCell) || IsWinInBoardDiagonal(board, selectedCell) || IsWinInReverseBoardDiagonal(board, selectedCell)); }
public virtual RowOpResult <BoardDTO> ValidateBoard(RowOpResult <BoardDTO> result) { BoardDTO b = result.Entity; if (string.IsNullOrEmpty(b.Name)) { result.ErrorMessage = "Name is required."; } else if (b.Name.Length > 100) { result.ErrorMessage = "Name is too long."; } if (string.IsNullOrEmpty(b.Notes)) { result.ErrorMessage = "Notes are required."; } else if (b.Notes.Length > 1000) { result.ErrorMessage = "Notes are too long."; } // more validation here result.Success = string.IsNullOrEmpty(result.ErrorMessage); return(result); }
public void EditeBoardName(BoardDTO editBoard) { Mapper.Reset(); Mapper.Initialize(cfg => cfg.CreateMap(typeof(BoardDTO), typeof(Board))); Board boardEntyti = (Board)Mapper.Map(editBoard, typeof(BoardDTO), typeof(Board)); BoardRepos.Edit(boardEntyti); }
public void CreateBoard(BoardDTO newBoard) { Mapper.Reset(); Mapper.Initialize(cfg => cfg.CreateMap(typeof(BoardDTO), typeof(Board))); Board boardEntyti = (Board)Mapper.Map(newBoard, typeof(BoardDTO), typeof(Board)); BoardRepos.Add(boardEntyti); }
public static Board createBoardFromDTO(BoardDTO boardDTO) { return(new Board { Id = boardDTO.Id, Name = boardDTO.Name }); }
public int Update(BoardViewModel data) { var map = mapper.CreateMapper(); BoardDTO board = map.Map <BoardDTO>(data); int i = BoardService.Update(board); return(i); }
public ActionResult GetBoard(int id) { var map = mapper.CreateMapper(); BoardDTO board = BoardService.GetByUserId(id, User.Identity.GetUserId()); BoardViewModel myboard = map.Map <BoardViewModel>(board); return(PartialView("GetBoard", map.Map <BoardViewModel>(myboard))); }
public PresentationBoard(BoardDTO dto) { ID = dto.Id; Name = dto.Name; Notes = dto.Notes; Tasks = new ObservableCollection <PresentationTask>(); TagsCollection = new ObservableCollection <string>(); }
public int Delete(int boardId) { var map = mapper.CreateMapper(); BoardDTO board = BoardService.Get(boardId); int i = BoardService.Delete(board); return(i); }
public IActionResult SaveBoardData(string img) { BoardDTO dto = new BoardDTO(); dto.bytes = img; var result = _utils.SaveBoard(dto); return(Ok(result)); }
public IActionResult New(int categoryId) { var board = new BoardDTO { Category = _categoryManager.Get(categoryId) }; var vm = Mapper.Map <BoardViewModel>(board); return(Board(vm)); }
public int Create(string name) { var map = mapper.CreateMapper(); BoardDTO boardDTO = new BoardDTO { Name = name }; int i = boardDTO.Id = BoardService.Create(boardDTO, User.Identity.GetUserId()); return(i); }
public async Task <int> Update(BoardDTO board) { var boardDb = await context.Boards.FindAsync(board.Id); if (boardDb != null) { context.Entry(boardDb).CurrentValues.SetValues(mapper.Map <BoardDb>(board)); } return(await Save()); }
public void AddBoard(string email) { email = email.ToLower(); BoardB newb = new BoardB(email); boards.Add(email, newb); BoardDTO b = new BoardDTO(email, 0); boardCont.Insert(b); }
public bool UpdateBoard(BoardDTO boardDTO, int?projectId) { var board = _boardRepository.GetBoard(boardDTO.Id, projectId.Value); board.Name = boardDTO.Name; board.Description = boardDTO.Description; _boardRepository.UpdateBoard(board); return(_boardRepository.Save()); }
public BoardDTO GetBoard(int?boardId) { // TODO //if (!boardId.HasValue) BoardDTO board = new BoardDTO(); board.Columns = _columnRepository.GetColumnsForBoard(boardId.Value).Select(c => new ColumnDTO(c.Id, c.Name, MapTasksToDTO(c.Tasks))).ToList(); return(board); }
public void Put(int id, [FromBody] BoardDTO board) { try { board_repo_.update(board); } catch (Exception ex) { throw ex; } }