public async Task EditBoardAsync(BoardDto dto)
{
var existingEntity = await _context.Boards.FirstOrDefaultAsync();
MapDtoToExistingEntity(dto, existingEntity);
await _context.SaveChangesAsync();
}
public BoardDto GetBoard()
{
var board = _context.Boards
.Include(b => b.Lists)
.FirstOrDefault();
//singleOrDefault wyrzuci wyjatek jak jest wiecej niz jeden, stosuje sie do id
if (board == null)
{
return(null);
}
//auto maper
var boardDto = new BoardDto()
{
Id = board.Id,
Name = board.Name,
Lists = board.Lists.Select(l => new ListDto()
{
Id = l.Id,
Name = l.Name,
BoardId = l.BoardId
}).ToList()
};
return(boardDto);
}
public void ConvertsToBoardCorrectly()
{
string prompt = "prompt";
string correctResponse = "correctResponse";
AnswerDto answerDto = new AnswerDto()
{
Prompt = prompt,
CorrectResponse = correctResponse
};
List <AnswerDto> answerDtos = new List <AnswerDto>()
{
answerDto
};
string topicName = "topicName";
TopicDto topicDto = new TopicDto()
{
Answers = answerDtos,
Name = topicName
};
List <TopicDto> topicDtos = new List <TopicDto>()
{
topicDto
};
string boardName = "boardName";
BoardDto boardDto = new BoardDto
{
Name = boardName,
Topics = topicDtos
};
var board = boardDto.ToBoard();
Assert.True(board.Name == boardName, "Board.Name was not copied correctly.");
Assert.True(board.Topics.Count() == topicDtos.Count(), "Board.Topics was not copied correctly");
}
public BoardDto GetBoard()
{
var board = _context.Boards
.Include(b => b.Lists)
.ThenInclude(x => x.Cards)
.LastOrDefault();
if (board == null)
{
return(null);
}
var boardDto = new BoardDto()
{
Id = board.Id,
Name = board.Name,
Lists = board.Lists.Select(l => new ListDto()
{
Id = l.Id,
BoardId = l.BoardId,
Name = l.Name,
Cards = l.Cards.Select(x => new CardDto()
{
CardId = x.CardId,
CardName = x.CardName,
ListId = x.ListId
}).ToList()
}).ToList(),
};
return(boardDto);
}
private void SaveGameState()
{
var boardDto = new BoardDto(_playerOnesTurn, Winner, _playerOne.Marker, _playerTwo.Marker,
_gameBoard.SubBoards);
_storageHandler.StoreBoard(boardDto);
}
public BoardDto GetBoard(int boardId)
{
using (var db = new PGSBoardContext())
{
var board = db.Boards
.Include("Lists.Cards")
.Single(b => b.Id == boardId);
// dto mapping
var boardDto = new BoardDto
{
Id = board.Id,
Name = board.Name,
Description = board.Description,
Lists = board.Lists.Select(l => new ListDto
{
Id = l.Id,
Name = l.Name,
Cards = l.Cards.Select(c => new CardDto
{
Id = c.Id,
Name = c.Name,
Description = c.Description
})
})
};
return(boardDto);
}
}
public ActionResult SaveBoard([FromBody] BoardDto board)
{
_boardReository.SaveBoard(board);
var hashId = CardUtil.GetHashId(User.Identity.Name, board.boardSeq);
return(Ok(hashId));
}
public BoardDto GetBoard()
{
var board = _context.Boards
.Include(b => b.Lists)
.FirstOrDefault();
if (board == null)
{
return(null);
}
var boardDto = new BoardDto()
{
Id = board.Id,
Name = board.Name,
Lists = board.Lists.Select(l => new ListDto()
{
Id = l.Id,
BoardId = l.BoardId,
Name = l.Name
}).ToList()
};
return(boardDto);
}
public void DeleteBoard(BoardDto board)
{
_context.CARD.RemoveRange(_context.CARD.Where(x => x.EMAIL == this.UserEmail && x.BOARD_SEQ == board.boardSeq));
_context.CARD_LIST.RemoveRange(_context.CARD_LIST.Where(x => x.EMAIL == this.UserEmail && x.BOARD_SEQ == board.boardSeq));
_context.BOARD.Remove(_context.BOARD.Find(this.UserEmail, board.boardSeq));
_context.SaveChanges();
}
public async Task <BoardDto> GetBoard()
{
//await Task.Delay(TimeSpan.FromSeconds(2));
BoardDto boardDto = await GetBoardAsync();
return(boardDto);
}
private BoardDto CreateDto(Board board)
{
var boardDto = new BoardDto
{
Id = board.Id, Name = board.Name, Description = board.Description, Created = board.Created, CreatedById = board.CreatedById
};
return(boardDto);
}
private async Task <BoardDto> GetBoardAsync()
{
BoardBo boardBo = await _taskService.GetBoardAsync(BOARD_ID);
BoardDto boardDto = _mapper.Map <BoardDto>(boardBo);
boardDto.Tasks = _mapper.Map <List <TaskDto> >(boardBo.Statuses.SelectMany(s => s.Tasks));
return(boardDto);
}
public async Task UpdateTask(int taskId, decimal priority, int statusId)
{
await Task.Delay(TimeSpan.FromSeconds(2));
await _taskService.UpdateTaskAsync(taskId, priority, statusId);
BoardDto boardDto = await GetBoardAsync();
await _hubContext.Clients.All.RefreshBoard(boardDto);
}
public static BoardDto ToDto(this Board board)
{
BoardDto boardDto = new BoardDto()
{
Id = board.Id,
Name = board.Name,
Topics = board.Topics.Select(x => x.ToDto())
};
return(boardDto);
}
public void SaveBoard(BoardDto board)
{
var entity = new BOARD {
EMAIL = this.UserEmail,
BOARD_SEQ = board.boardSeq,
BOARD_TITLE = board.boardTitle
};
_context.BOARD.Add(entity);
_context.SaveChanges();
}
public void UpdateIsPublic(BoardDto board)
{
var findBoard = _context.BOARD.Find(this.UserEmail, board.boardSeq);
if (findBoard != null)
{
findBoard.PUBLIC_TF = board.isPublic;
_context.BOARD.Update(findBoard);
_context.SaveChanges();
}
}
public void SaveBoardTitle(BoardDto board)
{
var findBoard = _context.BOARD.Find(this.UserEmail, board.boardSeq);
if (findBoard != null)
{
findBoard.BOARD_TITLE = board.boardTitle;
_context.BOARD.Update(findBoard);
_context.SaveChanges();
}
}
public void Setup()
{
_stubSuperStoryDto = new AgileItemDto
{
Id = Guid.Parse("5eb09b45-9c70-4465-b62d-535e28b16aed"),
AssigneeId = Guid.Parse("0f294219-704d-40a5-afe9-a74fffa7003f"),
AssigneeName = "Oli",
CreatedBy = Guid.Parse("0f294219-704d-40a5-afe9-a74fffa7003f"),
Description = "Stub Super Story",
DueBy = DateTime.Now.AddHours(1),
EstimatedTime = 1,
AgileItemType = Models.Types.AgileItemType.SuperStory,
Order = null,
Priority = Models.Types.Priority.High,
Title = "A stub creation of a story",
CreatedOn = DateTime.Now,
IsActive = true,
IsComplete = false,
Status = Models.Types.Status.InProgress,
BoardId = Guid.Parse("aada6f2a-8854-4a5e-a907-2244f43408a1"),
};
_stubStoryDto = new AgileItemDto
{
Id = Guid.Parse("5eb09b45-9c70-4465-b62d-535e28b16aee"),
AssigneeId = Guid.Parse("0f294219-704d-40a5-afe9-a74fffa7003f"),
AssigneeName = "Oli",
CreatedBy = Guid.Parse("0f294219-704d-40a5-afe9-a74fffa7003f"),
Description = "Stub Story",
DueBy = DateTime.Now.AddHours(1),
EstimatedTime = 1,
AgileItemType = Models.Types.AgileItemType.Story,
Order = null,
Priority = Models.Types.Priority.High,
Title = "A stub creation of a story",
CreatedOn = DateTime.Now,
IsActive = true,
IsComplete = false,
Status = Models.Types.Status.InProgress,
ParentId = Guid.Parse("5eb09b45-9c70-4465-b62d-535e28b16aed"),
BoardId = Guid.Parse("aada6f2a-8854-4a5e-a907-2244f43408a1"),
};
_stubBoard = new BoardDto
{
Id = Guid.Parse("aada6f2a-8854-4a5e-a907-2244f43408a1"),
BoardStart = DateTime.Now,
BoardEnd = DateTime.Now.AddDays(7),
BoardName = "Stub board",
IsActive = true
};
_mockLogger = new Mock <ILogger <BoardRepository> >();
_boardRepository = new BoardRepository(GetInMemoryContextWithSeedData(), _mockLogger.Object);
}
public async Task <IActionResult> UpdateBoard(BoardDto boardToUpdate)
{
try
{
UpdateBoardCommand updateBoardCommand = new UpdateBoardCommand(boardToUpdate);
BoardDto boardDto = await mediator.Send(updateBoardCommand);
return(Ok(boardDto));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public void Board_CreateBoard_Pass()
{
var boardDto = new BoardDto
{
BoardType = BoardDto.BoardTypes.Public,
Description = "Unit Test: A New board created through API",
Name = "Unit Test: API Board",
UserId = 5412166
};
var result = _mondayClient.CreateBoard(boardDto).Result;
Assert.IsTrue(result != null);
}
public async Task <IActionResult> CreateBoard(BoardDto boardDtoToCreate)
{
try
{
CreateNewBoardCommand createNewBoardCommand = new CreateNewBoardCommand(boardDtoToCreate.Name, boardDtoToCreate.Owner);
BoardDto boardDto = await mediator.Send(createNewBoardCommand);
return(Ok(boardDto));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public IHttpActionResult CreateBoard(BoardDto boardDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var board = _mapper.Map <BoardDto, Board>(boardDto);
board.DateAdded = DateTime.Now;
_context.Boards.Add(board);
_context.SaveChanges();
return(Created(new Uri(Request.RequestUri + "/" + board.Id), _mapper.Map <Board, BoardDto>(board)));
}
public void Game()
{
var board = new BoardDto();
var round = TimeSpan.FromSeconds(20);
var state = GameState.Won;
var game = new GameDto()
{
Board = board, GameState = state, RoundTime = round
};
Assert.IsTrue(game.Board == board);
Assert.IsTrue(game.RoundTime == round);
Assert.IsTrue(game.GameState == state);
}
protected override void OnStartup(StartupEventArgs e)
{
// TODO handle possible exceptions
try
{
IPlayer playerOne;
IPlayer playerTwo;
IBoard board;
IRules rules = new Rules();
var playerOnesTurn = true;
var filePath = GetFilePath("GameState.txt");
IFileHandler fileHandler = new FileHandler(filePath);
IDataStorageHandler storageHandler = new DataStorageHandler(fileHandler);
// Load board if there is a saved one
BoardDto boardDto = new BoardDto();
var couldLoadBoard = false;
try
{
couldLoadBoard = storageHandler.LoadBoard(rules, out boardDto);
}
catch (Exception)
{
Console.WriteLine(@"Failed to load board from file, will init a new game.");
}
if (couldLoadBoard)
{
board = new Board(rules, boardDto.Winner, boardDto.Subboards);
playerOne = new Player(boardDto.PlayerOne);
playerTwo = new Player(boardDto.PlayerTwo);
playerOnesTurn = boardDto.IsPlayerOneTurn;
}
else
{
board = new Board(rules);
playerOne = new Player(MarkerType.Cross);
playerTwo = new Player(MarkerType.Circle);
}
IGame game = new Game(board, playerOne, playerTwo, playerOnesTurn, storageHandler);
var mainWindow = new MainWindow(game);
mainWindow.Show();
}
catch (Exception exception)
{
Console.WriteLine($@"Failed starting the game, got exception {exception}");
}
}
public void Board()
{
var bombs = 10;
var height = 31;
var width = 12;
var fields = new List <FieldDto>();
var board = new BoardDto()
{
Bombs = bombs, Height = height, Width = width, Fields = fields
};
Assert.IsTrue(board.Bombs == bombs);
Assert.IsTrue(board.Height == height);
Assert.IsTrue(board.Width == width);
Assert.IsTrue(board.Fields == fields);
}
public BoardDto CreateBoard(CreateBoardDto createBoardDto)
{
var board = new Board()
{
Name = createBoardDto.Name
};
_context.Boards.Add(board);
_context.SaveChanges();
var boardDto = new BoardDto()
{
Id = board.Id,
Name = board.Name
};
return(boardDto);
}
public void UpdateBoard(int id, BoardDto boardDto)
{
if (!ModelState.IsValid)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
var boardInDb = _context.Boards.SingleOrDefault(c => c.Id == id);
if (boardInDb == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
_mapper.Map(boardDto, boardInDb);
_context.SaveChanges();
}
public async Task SaveTask([FromBody] TaskDto task)
{
//await Task.Delay(TimeSpan.FromSeconds(2));
try
{
TaskBo taskBo = _mapper.Map <TaskBo>(task);
await _taskService.SaveTaskAsync(taskBo);
}
catch (DbUpdateException e)
{
}
catch (Exception e)
{
}
BoardDto boardDto = await GetBoardAsync();
await _hubContext.Clients.All.RefreshBoard(boardDto);
}
public BoardDto GetBoard(string email, int?boardSeq)
{
var board = _context.BOARD.Find(email, boardSeq);
if (board == null)
{
return(null);
}
// private시 사용자 체크
if (board.PUBLIC_TF == false && this.UserEmail != email)
{
return(null);
}
var cardLists = from cardList in _context.CARD_LIST
join card in _context.CARD
on new { cardList.EMAIL, cardList.BOARD_SEQ, cardList.LIST_SEQ } equals new { card.EMAIL, card.BOARD_SEQ, card.LIST_SEQ } into cards
where cardList.EMAIL == email && cardList.BOARD_SEQ == boardSeq
select new CardListResultDto {
seq = cardList.LIST_SEQ,
listTitle = cardList.LIST_TITLE,
prevSeq = cardList.PREV_LIST,
cards = cards.Select(x => new CardResultDto {
seq = x.CARD_SEQ,
title = x.CARD_TITLE,
description = x.DESCRIPTION,
prevSeq = x.PREV_CARD
}).SetTreeOrder()
};
var result = new BoardDto {
boardSeq = board.BOARD_SEQ,
boardTitle = board.BOARD_TITLE,
isPublic = board.PUBLIC_TF,
canEditing = this.UserEmail == email,
cardLists = cardLists.SetTreeOrder()
};
return(result);
}
public async Task <IActionResult> UpdateBoard(int id, [FromBody] BoardDto boardDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var board = await _context.Boards.FirstOrDefaultAsync(b => b.Id == id);
if (board == null)
{
return(NotFound());
}
_mapper.Map <BoardDto, Board>(boardDto, board);
await _context.SaveChangesAsync();
var boardToReturn = _mapper.Map <Board, BoardDto>(board);
return(Ok(boardToReturn));
}
