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;
}
}
