private void Init()
{
// DTO 객체에 db정보 초기화
UserDto userDto = new UserDto();
FriendDto dto = new FriendDto();
userDto.Load();
dto.Load();
if (FriendDto.Friends.Find(x => x.id == LoginInfo.selectedUser.id) == null &&
FriendDto.Received_Requests.Find(x => x.id == LoginInfo.selectedUser.id) == null &&
LoginInfo.login.id != LoginInfo.selectedUser.id)
{
button1.Visible = true;
}
// 로그인된 유저의 정보를 폼에 띄우기
label1.Text = LoginInfo.selectedUser.name + " (" + LoginInfo.selectedUser.id + ")";
label2.Text = LoginInfo.selectedUser.message;
MemoryStream ms = new MemoryStream(LoginInfo.selectedUser.image);
pictureBox1.Image = Image.FromStream(ms);
pictureBox1.SizeMode = PictureBoxSizeMode.StretchImage;
this.OnLoad(new EventArgs());
}
public IActionResult AddFriend([FromBody] FriendDto friend)
{
try
{
_memberManager.AddFriend(friend);
ResponseDto response = new ResponseDto()
{
Message = "Success",
StatusCode = System.Net.HttpStatusCode.OK
};
return(Ok(response));
}
catch (Exception ex)
{
ResponseDto response = new ResponseDto()
{
Message = ex.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(response));
}
}
public void MapperTest_FriendContactToFriendDto()
{
//Arrange
//Act
FriendContact fc = new FriendContact()
{
TaxId = 1,
Name = "Name",
DateCreated = new DateTime(),
DateModified = new DateTime(),
EmailAddress = "*****@*****.**",
PhoneNumber = "999-999-9999",
Address = "Address",
Birthday = "01/01/1999",
};
FriendDto fDto = fc.ToFriendDto();
//Assert
Assert.AreEqual(fDto.Name, fc.Name);
Assert.AreEqual(fDto.TaxId, fc.TaxId);
Assert.AreEqual(fDto.DateCreated, fc.DateCreated);
Assert.AreEqual(fDto.DateModified, fc.DateModified);
Assert.AreEqual(fDto.EmailAddress, fc.EmailAddress);
Assert.AreEqual(fDto.PhoneNumber, fc.PhoneNumber);
Assert.AreEqual(fDto.Address, fc.Address);
Assert.AreEqual(fDto.Birthday, fc.Birthday);
}
public void MapperTest_ContactDtoToContact_Friend()
{
//Arrange
//Act
FriendDto wDto = new FriendDto()
{
TaxId = 1,
Name = "Name",
DateCreated = new DateTime(),
DateModified = new DateTime(),
PhoneNumber = "999-999-9999",
Address = "Address",
Birthday = "01/01/1999"
};
Contact cc = ((ContactDto)wDto).ToContact();
//Assert
Assert.AreEqual(cc.Name, wDto.Name);
Assert.AreEqual(cc.TaxId, wDto.TaxId);
Assert.AreEqual(cc.DateCreated, wDto.DateCreated);
Assert.AreEqual(cc.DateModified, wDto.DateModified);
Assert.AreEqual(((FriendContact)cc).Birthday, wDto.Birthday);
Assert.AreEqual(cc.PhoneNumber, wDto.PhoneNumber);
Assert.AreEqual(cc.Address, wDto.Address);
}
/// <summary>
/// 赋值Dto
/// </summary>
/// <param name="playerModel"></param>
/// <returns></returns>
private PlayerDto ToDto(PlayerModel playerModel)
{
PlayerDto playerDto = new PlayerDto()
{
ID = playerModel.Id,
Exp = playerModel.Exp,
Lv = playerModel.Lv,
Name = playerModel.Name,
Power = playerModel.Power,
WinCount = playerModel.WinCount,
LoseCount = playerModel.LoseCount,
RunCount = playerModel.RunCount,
HeroID = new int[playerModel.HeroIdList.Count],
Friends = new FriendDto[playerModel.FriendIdList.Count]
};
//英雄ID列表
for (int i = 0; i < playerModel.HeroIdList.Count; i++)
{
playerDto.HeroID[i] = playerModel.HeroIdList[i];
}
//好友ID列表
FriendDto[] friendDtos = new FriendDto[playerModel.FriendIdList.Count];
for (int i = 0; i < playerModel.FriendIdList.Count; i++)
{
int id = playerModel.FriendIdList[i];
PlayerModel friendModel = playerCache.GetPlayerModel(id);
bool isOnline = playerCache.IsOnLine(id);
friendDtos[i] = new FriendDto(id, friendModel.Name, isOnline);
}
//赋值给playerDto
playerDto.Friends = friendDtos;
return(playerDto);
}
public async Task <ActionResult <List <FriendDto> > > GetAllFriendsForUserID([FromRoute] int id)
{
var FriendListMain = _context.Friends.Include(x => x.UserResponder).Include(x => x.UserRequest).Where(x => x.UserRequestId == id).ToList();
var FriendListSecondary = _context.Friends.Include(x => x.UserResponder).Include(x => x.UserRequest).Where(x => x.UserResponderId == id).ToList();
var FriendList = FriendListMain.Union(FriendListSecondary).ToList();
var Friends = new List <FriendDto>();
foreach (var user in FriendList)
{
if (user.UserRequestId == id)
{
var friendTemp = new FriendDto
{
FirstLastName = user.UserResponder.FirstName + " " + user.UserResponder.LastName,
UserId = (int)user.UserResponderId
};
Friends.Add(friendTemp);
}
if (user.UserResponderId == id)
{
var friendTemp = new FriendDto
{
FirstLastName = user.UserRequest.FirstName + " " + user.UserRequest.LastName,
UserId = (int)user.UserRequestId
};
Friends.Add(friendTemp);
}
}
return(await Task.FromResult(Ok(Friends.OrderBy(x => x.FirstLastName))));
}
public async Task AddFriend(FriendDto friendDto)
{
CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Friends.Add(friendDto);
});
}
public ActionResult <string> Create(FriendDto dto)
{
LibraryAPI.Core.Domain.Freind friend = LibraryAPI.Core.Domain.Freind.AddFreind(dto.friendName, dto.userid, dto.email);
_friendRepo.AddFriend(friend);
return(friend.GetLink());
}
public IActionResult PutFriend(int id, FriendDto Friend)
{
if (id != Friend.Id)
{
return(BadRequest());
}
try
{
_friendService.Update(_mapper.Map <FriendEntity>(Friend));
}
catch (DbUpdateConcurrencyException)
{
if (!FriendExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <bool> DeleteAsync(FriendDto dto, int requesterId)
{
var friendship = await _genericRepository.GetAsync(x =>
(x.LeftApplicationUser.Id == requesterId && x.RightApplicationUser.ExternalId == dto.ExternalId) ||
(x.RightApplicationUser.Id == requesterId && x.LeftApplicationUser.ExternalId == dto.ExternalId));
return(await base.DeleteAsync(friendship.ExternalId));
}
public async Task <ActionResult <Result> > Add(FriendDto friendDto)
{
var loginId = await GetLoginId();
var result = await _friendService.Add(friendDto, loginId);
return(Ok(result));
}
public async Task <IActionResult> DeleteAsync([FromBody] FriendDto friendDto)
{
int.TryParse(_userManager.GetUserId(User), out var userId);
var result = await _friendshipService.DeleteAsync(friendDto, userId).ConfigureAwait(true);
return(result
? Ok(result)
: (IActionResult)NotFound($"Could not delete {typeof(FriendDto).Name}"));
}
public ReturnGame()
{
var game = new GameBuilder().Build();
_gameDto = new GameDto(game.Id, game.Name);
var friend = new FriendBuilder().Build();
_friendDto = new FriendDto(friend.Id, friend.Name, friend.PhoneNumber);
}
public void UpdateFriend([FromBody] FriendDto friendDto)
{
var user = userRepository.GetUser(base.GetUserId());
var friend = Friend.newFriend(friendDto.Id)
.called(friendDto.Name)
.friendOf(user);
user.updateFriendData(friend);
userRepository.Update(user);
}
public async Task FriendAdded(FriendDto friendDto)
{
await friendStore.AddFriend(friendDto);
var request = friendStore.SentRequests.FirstOrDefault(r => r.ReceiverName == friendDto.Username);
if (request != null)
{
await friendStore.RemoveSentRequest(request.Id);
}
}
public async Task <IActionResult> AddFriendForCurrentUser([FromBody] FriendDto friendToAdd)
{
var result = await _friendService.AddFriendForCurrentUser(friendToAdd);
if (!result.Succeeded)
{
return(BadRequest(result));
}
return(Ok(result));
}
public void AddFriend([FromBody] FriendDto friendDto)
{
var user = userRepository.GetUser(base.GetUserId());
var friend = Friend.newFriend()
.called(friendDto.Name)
.friendsSince(DateTime.Now)
.friendOf(user);
user.newFriend(friend);
userRepository.Update(user);
}
public ActionResult UpdateFriend(FriendDto friend)
{
try
{
_friendRepository.Update(friend);
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
catch (Exception e)
{
return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError, e.Message));
}
}
public void DeclineFriendRequest(int friendId)
{
Db db = new Db();
UserDTO userDto = db.Users.Where(x => x.Username.Equals(User.Identity.Name)).FirstOrDefault();
int userId = userDto.Id;
FriendDto friends = db.Friends.Where(x => x.User1 == friendId && x.User2 == userId).FirstOrDefault();
db.Friends.Remove(friends);
db.SaveChanges();
}
public void Update(FriendDto friendDto)
{
using (var ctx = new FriendListContext())
{
var friend = ctx.Friends.Single(x => x.Id == friendDto.Id);
friend.Name = friendDto.Name;
friend.LastName = friendDto.LastName;
ctx.Friends.AddOrUpdate(friend);
ctx.SaveChanges();
}
}
public void AcceptFriendRequest(int friendId)
{
Db db = new Db();
UserDTO userDto = db.Users.Where(x => x.Username.Equals(User.Identity.Name)).FirstOrDefault();
int userId = userDto.Id;
FriendDto friends = db.Friends.Where(x => x.User1 == friendId && x.User2 == userId).FirstOrDefault();
friends.Active = true;
db.SaveChanges();
}
public async Task <ActionResult <List <FriendDto> > > GetAllNonFriendsForUserID([FromRoute] int id)
{
var FriendListMain = _context.Friends.Include(x => x.UserResponder).Include(x => x.UserRequest).Where(x => x.UserRequestId == id).ToList();
var FriendListSecondary = _context.Friends.Include(x => x.UserResponder).Include(x => x.UserRequest).Where(x => x.UserResponderId == id).ToList();
var FriendList = FriendListMain.Union(FriendListSecondary).ToList();
var allUsers = _context.Users.ToList();
var Friends = new List <FriendDto>();
foreach (var user in FriendList)
{
if (user.UserRequestId == id)
{
var friendTemp = new FriendDto
{
FirstLastName = user.UserResponder.FirstName + " " + user.UserResponder.LastName,
UserId = (int)user.UserResponderId
};
Friends.Add(friendTemp);
}
if (user.UserResponderId == id)
{
var friendTemp = new FriendDto
{
FirstLastName = user.UserRequest.FirstName + " " + user.UserRequest.LastName,
UserId = (int)user.UserRequestId
};
Friends.Add(friendTemp);
}
}
var NonFriends = new List <FriendDto>();
foreach (var user in allUsers)
{
var friendTemp = new FriendDto
{
FirstLastName = user.FirstName + ' ' + user.LastName,
UserId = user.Iduser
};
NonFriends.Add(friendTemp);
}
foreach (var item in Friends)
{
NonFriends.RemoveAll((x) => x.UserId == item.UserId);
}
NonFriends.RemoveAll((x) => x.UserId == id);
var result = NonFriends.OrderBy(x => x.FirstLastName);
return(await Task.FromResult(Ok(result)));
}
public async Task <ActionResult <Result> > Put(int id, FriendDto friendDto)
{
if (id != friendDto.Id)
{
return(BadRequest());
}
var loginId = await GetLoginId();
var result = await _friendService.Update(friendDto, loginId);
return(Ok(result));
}
public async Task <IActionResult> UpdateFriend([FromBody] FriendDto friend)
{
try
{
var response = await _service.UpdateFriend(friend);
return(Ok(response.Object));
}
catch (Exception ex)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, ex.Message));
}
}
public async Task <IActionResult> Update(FriendDto friendDto)
{
try
{
FriendResponse response = await _serviceFriend.Update(friendDto);
return(Ok(response));
}
catch (Exception)
{
return(BadRequest(new GameResponse(NotificacaoDto.ErroPadrao)));
}
}
public async Task <ActionResult <FriendDto> > PostFriend([FromBody] FriendDto friend)
{
var newFriendDto = new Friend()
{
Status = friend.Status, UserID = friend.UserID, UserFriendID = friend.UserFriendID
};
_context.Friends.Add(newFriendDto);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetFriend", new { id = friend.FriendID }, friend));
}
public async Task <SelectItemVm> GetAllAsSelect(FriendDto friendDto)
{
var vm = new SelectItemVm
{
SelectItems = await _context.Friends
.Where(x => !x.Deleted)
.Select(x => new SelectItemDto {
Label = x.Nickname, Value = x.Id.ToString()
})
.ToListAsync()
};
return(vm);
}
public async Task <FriendResponse> Update(FriendDto friendDto)
{
Friend friend = _mapper.Map <FriendDto, Friend>(friendDto);
ValidationResult result = new FriendValidator(_repositoryFriend).Validate(friend);
if (!result.IsValid)
{
return(new FriendResponse(result));
}
await _repositoryFriend.Update(friend);
return(new FriendResponse(_mapper.Map <Friend, FriendDto>(friend), new NotificacaoDto(NotificacaoDto.TipoMensagem.Sucesso, "Amigo atualizado com sucesso!")));
}
public async Task <Result> AddFriend(FriendDto friendToAdd)
{
var entity = new Friend
{
Nickname = friendToAdd.Nickname,
UserId = friendToAdd.UserId,
UserFriendId = friendToAdd.UserFriendId
};
await _context.Friends.AddAsync(entity);
await _context.SaveChangesAsync();
return(Result.Success("Friend was created successfully"));
}
public void Add(FriendDto friend)
{
using (var ctx = new FriendListContext())
{
var newFriend = new Friend()
{
Id = friend.Id,
Name = friend.Name,
LastName = friend.LastName
};
ctx.Friends.Add(newFriend);
ctx.SaveChanges();
}
}
