public static ChatAppService.FriendRequest ConvertToFriendRequest(FriendRequest request)
{
return new ChatAppService.FriendRequest
{
FromUserId = request.FromUserId,
ToUserId = request.ToUserId
};
}
public async Task <IActionResult> PostFriendRequest([FromBody] FriendRequestContract friendRequestContract)
{
//TODO: create DataContract
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userId = _httpContextAccessor.CurrentUserId();
if (!friendRequestContract.InitiatorId.Equals(userId))
{
return(Unauthorized());
}
if (friendRequestContract.InitiatorId.Equals(friendRequestContract.TargetId))
{
return(BadRequest(friendRequestContract.TargetId));
}
var userExists = await _context.ApplicationUsers
.AnyAsync(a => a.Id.Equals(friendRequestContract.TargetId));
var blocked = await _context.FriendRequests
.AnyAsync(f => f.InitiatorId.Equals(friendRequestContract.TargetId) &&
f.TargetId.Equals(userId) &&
f.Type.HasValue &&
f.Type.Value.Equals(FriendRequestType.Blocked));
if (!userExists || blocked)
{
return(BadRequest(friendRequestContract.TargetId));
}
var friend = await _context.FriendRequests
.SingleOrDefaultAsync(f => f.InitiatorId.Equals(userId) &&
f.TargetId.Equals(friendRequestContract.TargetId));
DateTime timeStamp = DateTime.Now.ToUniversalTime();
if (friend != null)
{
friend.Type = friendRequestContract.Type;
friend.TimeStamp = timeStamp;
}
else
{
FriendRequest fr = new FriendRequest()
{
InitiatorId = userId,
TargetId = friendRequestContract.TargetId,
TimeStamp = timeStamp,
Type = friendRequestContract.Type
};
await _context.FriendRequests.AddAsync(fr);
}
await _context.SaveChangesAsync();
//return CreatedAtAction("GetFriendRequest", new { id = friendRequestContract.TargetId }, friendRequest);
return(Ok());
}
public async Task <IActionResult> acceptRequest([FromBody] FriendRequest request)
{
var user = await _userManager.FindByEmailAsync(request.receiver);
var user1 = await _userManager.FindByEmailAsync(request.sender);
if (user != null)
{
var userRequests = user.friendRequests.Split(",");
if (userRequests.Contains(request.sender))
{
userRequests = userRequests.Where(w => w != request.sender).ToArray();
string joined = string.Join(",", userRequests);
user.friendRequests = joined;
var userFriends = user.friends.Split(",");
if (userFriends[0].Equals(""))
{
user.friends = request.sender;
}
else
{
String temp = "," + request.sender;
user.friends += temp;
}
// userFriends.Append(request.sender);
// joined = string.Join(",", userFriends);
// user.friends = joined;
userFriends = user1.friends.Split(",");
if (userFriends[0].Equals(""))
{
user1.friends = request.receiver;
}
else
{
String temp = "," + request.receiver;
user1.friends += temp;
}
//userFriends.Append(request.receiver);
// joined = string.Join(",", userFriends);
// user1.friends = joined;
await _userManager.UpdateAsync(user);
await _userManager.UpdateAsync(user1);
return(Ok());
}
else
{
return(BadRequest("No such friend request found"));
}
}
else
{
return(BadRequest());
}
}
public static DalFriendRequest ToDalFriendRequest(this FriendRequest friendRequestEntity)
{
return(new DalFriendRequest()
{
FromUserId = friendRequestEntity.FromUserId,
ToUserId = friendRequestEntity.ToUserId,
Confirmed = friendRequestEntity.Confirmed
});
}
public static void UserSystemUpdate()
{
Console.WriteLine("----------------UserSystemUpdate----------------");
new Thread(() => FriendList.GetPage().Update()).Start();
new Thread(() => FriendRequest.GetPage().Update()).Start();
new Thread(() => Profile.getPage().UpdateUser()).Start();
new Thread(() => FriendProfile.getPage().UpdateUser()).Start();
new Thread(() => Chat.GetPage().Update()).Start();
}
public async Task <ActionResult <ApiResultViewModel <FriendRequest> > > SendFriendRequest([FromRoute] long accountId,
[FromBody] FriendRequestInputModel inputModel, CancellationToken cancellationToken)
{
if (accountId != AccountId)
{
return(Forbidden());
}
if (inputModel.FriendAccountId == accountId)
{
return(BadRequest("invalid_friendAccountId", "you cannot friend yourself"));
}
var friendAccount = await _accountManager.GetAsync(inputModel.FriendAccountId, cancellationToken);
if (friendAccount == null || friendAccount.IsArchived)
{
return(BadRequest("invalid_friendAcccountId", "friend account not found."));
}
var friendRequest =
await _friendRequestManager.GetExistingRequest(accountId, inputModel.FriendAccountId,
cancellationToken);
if (friendRequest != null)
{
return(BadRequest("already_exists", "Friend request already sent."));
}
if (await _accountFriendManager.IsFriendAsync(accountId, inputModel.FriendAccountId, cancellationToken))
{
return(BadRequest("already_friends", "Requested player is already in your friend list."));
}
friendRequest = new FriendRequest
{
FromAccountId = accountId,
ToAccountId = inputModel.FriendAccountId,
RequestDateTime = DateTime.UtcNow,
StatusId = FriendRequestStatus.Pending
};
var account = await _accountManager.GetAsync(accountId, cancellationToken);
friendRequest = await _friendRequestManager.SaveAsync(friendRequest, cancellationToken);
await _notificationManager.SaveAsync(
new Core.Entities.Notification
{
AccountId = friendRequest.ToAccountId,
Body = $"friend request sent by {account.Email}",
NotificationTypeId = NotificationTypeIds.General,
Title = "Friend Request"
}, cancellationToken);
return(CreatedData(friendRequest));
}
public async Task CheckForPendingRequest(FriendRequest friendRequest)
{
List <FriendRequest> pendingRequest = await _friendshipRepo.RetrievePendingRequest(friendRequest);
if (pendingRequest.Any())
{
throw new FriendshipException("Pending request exists!");
}
}
public static FriendRequestViewModel Create(FriendRequest request)
{
return(new FriendRequestViewModel()
{
Id = request.Id,
Status = request.Status,
User = UserViewModelMinified.Create(request.From)
});
}
public async void RemoveRequest(FriendRequestViewModel model, FriendRequest request)
{
_repository.UpdateRequest(request, model.SenderID, model.ReceiverID, RequestStatus.CANCELED);
_notificationRepository.RemoveFriendRequestNotification(model.SenderID, model.ReceiverID);
_notificationRepository.RemoveFriendRequestNotification(model.ReceiverID, model.SenderID);
await _context.SaveChangesAsync();
}
public async Task <ActionResult <Friend> > PostFriend(FriendRequest request)
{
Member member = GetAuthenticatedMember();
foreach (var email in request.FriendEmails)
{
if (string.IsNullOrEmpty(email))
{
return(BadRequest("Invalid email value retrieved!"));
}
// do not allow members to send themselves a FR
if (email == member.Email)
{
continue;
}
Member friend = _context.Members.FirstOrDefault(m => m.Email == email);
// user with that email doesn't exist yet, add it to db and send link to email address to create account
if (friend == null)
{
// create new account with this email
friend = new Member
{
Email = email,
CreationKey = Guid.NewGuid().ToString()
};
_context.Members.Add(friend);
await _context.SaveChangesAsync();
// send invitation email
_mailClient.Send(
"*****@*****.**",
email,
"Strawpolly invitation link",
$"Hello,\n\nPlease click the link below to create a Strawpolly account:\n\n{_appSettings.FrontEndUrl}/register/{friend.CreationKey}"
);
}
// insert pending friend request into db if they are not in the friends table yet
if (!AreFriends(member, friend))
{
_context.Friends.Add(new Friend
{
MemberID = member.MemberID,
MemberFriendID = friend.MemberID,
MemberWhoModifiedID = member.MemberID,
FriendStatus = FriendStatus.Pending
});
}
}
await _context.SaveChangesAsync();
return(Ok());
}
public bool SentFriendReqeust(FriendRequest friendRequest)
{
//friend Request sent to user
friendRequestGetway.Add(friendRequest);
return(true);
}
public ActionResult SendFriendRequest(FriendRequest json)
{
FriendRequest friendRequest = new FriendRequest();
friendRequest.FromUserId = User.Identity.GetUserId();
friendRequest.ToUserId = json.ToUserId;
_userService.SendFriendRequest(friendRequest);
return(null);
}
public IActionResult DenyFriendRequest(int SenderId)
{
FriendRequest friendRequest = new FriendRequest();
friendRequest.RecieverId = (int)HttpContext.Session.GetInt32("Id");
friendRequest.SenderId = SenderId;
_friendRequestLogic.DeleteFriendRequest(friendRequest);
return(RedirectToAction("FriendRequests", "Home"));
}
public MethodResult CanDeclineRequest(Citizen citizen, FriendRequest request)
{
if (citizen.ID == request.SecondCitizenID)
{
return(MethodResult.Success);
}
return(new MethodResult("You cannot accept this request!"));
}
public MethodResult CanRemoveRequest(Citizen citizen, FriendRequest request)
{
if (citizen.ID == request.ProposerCitizenID)
{
return(MethodResult.Success);
}
return(new MethodResult("You cannot accept this request!"));
}
public bool AddToFriends(string WebMemberID)
{
ViewingMember = Member.GetMemberViaWebMemberID(WebMemberID);
member = (Member)HttpContext.Current.Session["Member"];
bool MadeFriendRequest = FriendRequest.CreateWebFriendRequest(member.MemberID, ViewingMember.MemberID);
return(MadeFriendRequest);
}
public void SendFriendRequest(FriendRequest request)
{
var currentStatus = GetRelationshipStatus(request.IdReceiver, request.IdRequester);
if (currentStatus == RelationshipStatus.NoRelationship)
{
Repositories.FriendshipRepository.SaveRequest(request);
}
}
FeatureRequestDataTransaction NewFriendTransaction(long accountId, int chainId, FriendRequestMode friendRequestMode, long friendId)
{
var transaction = new FeatureRequestDataTransaction(accountId, chainId, MessageServiceInfo.FriendChainIndex);
var request = new FriendRequest(friendRequestMode, friendId);
transaction.SetFeatureRequest(request);
return(transaction);
}
public IHttpActionResult SendFriendRequest(string username)
{
var recipient = this.SocialNetworkData.Users.All()
.FirstOrDefault(u => u.UserName == username);
if (recipient == null)
{
return(this.NotFound());
}
var loggedUserId = this.User.Identity.GetUserId();
if (loggedUserId == null)
{
return(this.BadRequest("Invalid session token."));
}
var loggedUser = this.SocialNetworkData.Users.GetById(loggedUserId);
if (username == loggedUser.UserName)
{
return(this.BadRequest("Cannot send request to self."));
}
bool isAlreadyFriend = loggedUser.Friends
.Any(fr => fr.UserName == recipient.UserName);
if (isAlreadyFriend)
{
return(this.BadRequest("User is already in friends."));
}
bool hasReceivedRequest = loggedUser.FriendRequests
.Any(r => r.FromId == recipient.Id && r.Status == FriendRequestStatus.Pending);
bool hasSentRequest = recipient.FriendRequests
.Any(r => r.FromId == loggedUser.Id && r.Status == FriendRequestStatus.Pending);
if (hasSentRequest || hasReceivedRequest)
{
return(this.BadRequest("A pending request already exists."));
}
var friendRequest = new FriendRequest()
{
From = loggedUser,
To = recipient
};
recipient.FriendRequests.Add(friendRequest);
this.SocialNetworkData.SaveChanges();
return(this.Ok(new
{
message = string.Format(
"Friend request successfully sent to {0}.", recipient.Name)
}));
}
public void RejectFriendRequest(FriendRequest fr)
{
FriendRequestList pl = (FriendRequestList)ServerManager.Instance.ServerInstance.ReadDomainObject("SentFriendRequests");
if (pl != null)
{
pl.RemoveFriendRequest(fr);
ServerManager.Instance.ServerInstance.WriteDomainObject(pl);
}
}
public IActionResult AcceptFriendRequest(int SenderId)
{
FriendRequest friendRequest = new FriendRequest();
friendRequest.RecieverId = (int)HttpContext.Session.GetInt32("Id");
friendRequest.SenderId = SenderId;
friendRequest.Recieved = DateTime.Now;
_friendRequestLogic.AcceptFriendRequest(friendRequest);
return(RedirectToAction("FriendRequests", "Home"));
}
public async Task <IActionResult> Post([FromForm] FriendRequest friend)
{
bool created = await FriendService.Add(friend);
if (!created)
{
return(BadRequest());
}
return(Ok());
}
public ActionResult DenyFriendRequest(int id)
{
FriendRequest friendRequest = context.FriendRequests.Single(fr => fr.ID == id);
context.FriendRequests.Remove(friendRequest);
context.SaveChanges();
TempData["Alert"] = "Denied friend request.";
return(Redirect("/User"));
}
public string SetFriendStatus(string WebFriendRequestID, bool IsAccepted)
{
member = (Member)Session["Member"];
FriendRequest.SetFriendRequestStatus(member.MemberID, WebFriendRequestID, IsAccepted);
List <FriendRequest> friendRequests = FriendRequest.GetAllNewFriendRequestByMemberID(member.MemberID, PageListerType);
return(friendRequests.Count.ToString());
}
public void AddFriendRequest(Guid requestorId, Guid requesteeId)
{
var friendRequest = new FriendRequest();
friendRequest.Id = Guid.NewGuid();
friendRequest.RequestorId = requestorId;
friendRequest.RequesteeId = requesteeId;
_friendRequests.Add(friendRequest);
}
public void AddFriendRequest(Citizen proposer, Citizen other)
{
FriendRequest req = new FriendRequest()
{
ProposerCitizen = proposer,
SecondCitizen = other
};
context.FriendRequests.Add(req);
}
/// <summary>
/// This method creates a new friend request
/// </summary>
/// <param name="u"></param>
/// <param name="friend"></param>
public static void CreateFriendRequest(User u, User friend, GameContext gc)
{
FriendRequest friendRequest = new FriendRequest();
friendRequest.User = u;
friendRequest.Friend = friend;
gc.FriendRequests.Add(friendRequest);
gc.SaveChanges();
}
public ActionResult Show(int id)
{
FriendRequest friendRequest = db.FriendRequests.Find(id);
if (friendRequest.ReceiverId == User.Identity.GetUserId())
{
return(View(friendRequest));
}
return(Redirect("/"));
}
public ActionResult RejectFriendRequest(string userID, string FriendID)
{
FriendRequest Requests = db.FriendRequests.FirstOrDefault(o => o.ReqFriendID == userID && o.UserID == FriendID && o.Confirm == false);
Requests.deleted = true;
Requests.Confirm = false;
Requests.Sended = false;
db.SaveChanges();
return(RedirectToAction("allFreindRequests", routeValues: new { user = userID }));
}
public override void Compose(Yupi.Protocol.ISender session, FriendRequest request)
{
using (ServerMessage message = Pool.GetMessageBuffer(Id))
{
message.AppendInteger(request.From.Id);
message.AppendString(request.From.Name);
message.AppendString(request.From.Look);
session.Send(message);
}
}
private static FriendRequestResponse Friend(HttpApiClient api, FriendRequest request)
{
Console.WriteLine("Friend");
Console.WriteLine(request.Time);
Console.WriteLine(request.SelfId);
Console.WriteLine(request.UserId);
Console.WriteLine(request.Comment);
Console.WriteLine(request.Flag);
return(null);
}
//När man klickar på lägg till vän symbolen så uppdateras statusen till 3 som betyder att den
//som man skickat vänförfrågan till kommer kunna accpetera eller neka vänförfrågan
public static void AddFriend(int userID, int friendID)
{
using (var context = new DatabaseEntities())
{
FriendRequest fr = new FriendRequest
{
UserID = userID,
FriendID = friendID,
Status = 3,
};
context.FriendRequests.Add(fr);
context.SaveChanges();
}
}
public ActionResult SendFriendRequest(string senderId, string receiverId)
{
// var sender = this.usersServices.GetUserById(senderId);
// var receiver = this.usersServices.GetUserById(receiverId);
var friendshipRequest = new FriendRequest()
{
CreatedOn = DateTime.Now,
SenderId = senderId,
ReceiverId = receiverId
};
this.friendRequestServices.CreateFriendRequest(friendshipRequest);
return this.Redirect("/Me");
}
public void RejectFriendRequest(FriendRequest fr)
{
for (int i = 1; i <= Config.Instance.NumberOfReplicas; i++)
{
ServerToServerServices obj = (ServerToServerServices)Activator.GetObject(typeof(ServerToServerServices), fr.FromAddress + ":" + (fr.FromPort+ i) + "/ServerToServerServices");
if (obj != null)
{
try
{
obj.RejectFriendRequest(fr);
return;
}
catch (IOException) { }
catch (SocketException) { }
}
}
throw new ServiceUnavailableException("Could not notify user of rejection.");
}
public void SendFriendRequest(FriendRequest fr)
{
for (int i = 1; i <= Config.Instance.NumberOfReplicas; i++)
{
ServerToServerServices obj = (ServerToServerServices)Activator.GetObject(typeof(ServerToServerServices), fr.SendTo + ":" + (fr.SendToPort + i) + "/ServerToServerServices");
if (obj != null)
{
try
{
obj.ReceiveFriendRequest(fr);
return;
}
catch (IOException) { }
catch (SocketException) { }
}
}
throw new ServiceUnavailableException("Could not deliver friend request, please try again later.");
}
public void AcceptFriendRequest(FriendRequest fr)
{
Profile profile = (Profile)ServerManager.Instance.ServerInstance.ReadDomainObject("Profile");
fr.RequestedUserName = profile.UserName;
for (int i = 1; i <= Config.Instance.NumberOfReplicas; i++)
{
ServerToServerServices obj = (ServerToServerServices)Activator.GetObject(typeof(ServerToServerServices), fr.FromAddress + ":" + (fr.FromPort + i) + "/ServerToServerServices");
if (obj != null)
{
try
{
obj.AcceptFriendRequest(fr);
return;
}
catch (IOException) { }
catch (SocketException) { }
}
}
throw new ServiceUnavailableException("Could not notify user of acceptance.");
}
public ActionResult AddFriend(Guid UserId)
{
Guid id = (Guid)Membership.GetUser().ProviderUserKey;
if (db.FriendRequests.Where(x => x.RecieverId == UserId && x.SenderId == id).ToList().Count > 0)
{
//Add Message for user
TempData["HasMessage"] = true;
TempData["Error"] = true;
TempData["Message"] = "Freundesanfrage schon vorhanden!";
return RedirectToAction("Details", "User", new { id = UserId, area = "" });
}
FriendRequest fr = new FriendRequest() { CreatedAt = DateTime.Now, RecieverId = UserId, SenderId = id };
db.FriendRequests.Add(fr);
//Add Message for user
TempData["HasMessage"] = true;
TempData["Success"] = true;
TempData["Message"] = "Freundesanfrage wurde gespeichert!";
return RedirectToAction("Details", "User", new { id = UserId, area = "" });
}
public void AddFriend(FriendRequest fr)
{
for (int i = 0; i < Config.Instance.NumberOfReplicas; i++)
{
string addr;
lock (indexLock)
{
addr = replicas[(serverAddressToCall + i) % Config.Instance.NumberOfReplicas];
}
IClientServices obj = (IClientServices)Activator.GetObject(typeof(IClientServices), addr + "/ClientServices");
if (obj != null)
{
try
{
obj.AcceptFriendRequest(fr);
return;
}
catch (IOException) { }
catch (SocketException) { }
}
}
throw new ServiceUnavailableException("Unable to contact any server.");
}
public void AcceptFriendRequest(FriendRequest f)
{
try
{
ServerManager.Instance.ServerInstance.ServerRequestInvoker.AcceptFriendRequest(f);
//Get processed requests
Post p = new Post("PADIBook de " + f.RequestedUserName, f.RequestingUserName + " ficou seu amigo. O seu endereço é " + f.FromAddress + ":" + f.FromPort);
PostList pl = (PostList)ServerManager.Instance.ServerInstance.ReadDomainObject("PostList");
if (pl == null)
{
pl = new PostList("PostList");
}
pl.AddPost(p);
ServerManager.Instance.ServerInstance.WriteDomainObject(pl);
}
catch (ServiceUnavailableException)
{
throw new ServiceUnavailableException("Não foi possível enviar a resposta.");
}
catch (RemotingException)
{
throw new ServiceUnavailableException("Não foi possível enviar o pedido.");
}
f.FriendRequestState = FriendRequest.RequestState.ACCEPTED;
FriendRequestList recvFrdReqs = GetReceivedFriendRequests();
//add friend
Friends friends = GetFriendList();
friends.AddFriend(f.RequestingUserName, f.FromAddress, f.FromPort);
ServerManager.Instance.ServerInstance.WriteDomainObject(friends);
//Remove request from received requests
recvFrdReqs.RemoveFriendRequest(f);
ServerManager.Instance.ServerInstance.WriteDomainObject(recvFrdReqs);
}
protected void linkBtnAddFriend_Click(object sender, EventArgs e)
{
try
{
using (UserService service = new UserService())
{
LinkButton button = ((LinkButton)sender);
if (button.CommandName == "AddFriend")
{
FriendRequest request = new FriendRequest();
request.FromUserId = LoggedUser.ID;
request.ToUserId = button.CommandArgument;
service.SendFriendRequest(request);
FailureText.Text = "Request Sent sucessfully!!";
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public void ApproveFriendRequest(FriendRequest friendRequest)
{
try
{
userService.ApproveFriendRequest(Helper.ConvertToFriendRequest(friendRequest));
}
catch (SoapException se)
{
Debug.WriteLine(@" {0}", se.Message);
throw se;
}
catch (Exception ex)
{
Debug.WriteLine(@" ERROR {0}", ex.Message);
throw ex;
}
}
public Task<StatusData<string>> UnFriendRequest(FriendRequest request, SystemSession session)
{
return _jUnitOfWork.Friend.UnFriendRequest(request, session);
}
public FriendRequest AddRequestFriend(int friendUserId, string message)
{
User friendUser = userRepo.FindById(friendUserId);
if (friendUser == null)
{
throw new Exception("Cannot request not existed user.");
}
User myUser = sessionManager.GetUser();
if (friendUserId == myUser.UserId
|| friendRepo.IsFriend(myUser.UserId, friendUserId)
|| friendRequestRepo.IsConfirmingFriendRequest(myUser.UserId, friendUserId))
{
throw new Exception("Error when processing your request friend.");
}
string originMessage = Globals.UrlDecode(message.Trim());
int timestamp = DateTimeUtils.UnixTimestamp;
FriendRequest friendRequest = new FriendRequest()
{
User = myUser,
FriendUser = friendUser,
Message = Globals.HtmlEncode(message),
Timestamp = timestamp
};
return friendRequestRepo.Create(friendRequest);
}
private void AdicionarButton_Click(object sender, EventArgs e)
{
if (friendsAddrTextBox.Text != "" && friendPortTextBox.Text != "")
{
string addr = friendsAddrTextBox.Text;
int port;
try
{
port = Int32.Parse(friendPortTextBox.Text);
}catch(FormatException){
MessageBox.Show("Verifique que o porto é um número inteiro.");
return;
}
FriendRequest fr = new FriendRequest(clientAddress, clientPort, addr, port, userProfile.UserName);
//fr.RequestedUserName = requestedUserNameTextBox.Text;
try
{
ServerServiceInvoker.Instance.SendFriendRequest(fr);
RefreshSentRequests();
MessageBox.Show("Pedido enviado com sucesso.");
}
catch (ServiceUnavailableException se)
{
MessageBox.Show(se.Message + "\r\nPor favor tente mais tarde.");
}
}
}
public void RejectFriendRequest(FriendRequest fr)
{
FriendRequestList pl = (FriendRequestList)ServerManager.Instance.ServerInstance.ReadDomainObject("SentFriendRequests");
if (pl != null)
{
pl.RemoveFriendRequest(fr);
ServerManager.Instance.ServerInstance.WriteDomainObject(pl);
}
}
public void ReceiveFriendRequest(FriendRequest fr)
{
//Return if we're already friends
Friends friends = (Friends)ServerManager.Instance.ServerInstance.ReadDomainObject("Friends");
if (friends != null && friends.FriendsInfo.ContainsKey(fr.RequestingUserName))
return;
FriendRequestList pl = (FriendRequestList)ServerManager.Instance.ServerInstance.ReadDomainObject("ReceivedFriendRequests");
if (pl == null)
{
pl = new FriendRequestList("ReceivedFriendRequests");
ServerManager.Instance.ServerInstance.WriteDomainObject(pl);
}
pl.AddFriendRequest(fr);
ServerManager.Instance.ServerInstance.WriteDomainObject(pl);
}
public void RejectFriendRequest(FriendRequest f)
{
try
{
ServerManager.Instance.ServerInstance.ServerRequestInvoker.RejectFriendRequest(f);
f.FriendRequestState = FriendRequest.RequestState.REJECTED;
FriendRequestList receivedReqs = GetReceivedFriendRequests();
receivedReqs.RemoveFriendRequest(f);
ServerManager.Instance.ServerInstance.WriteDomainObject(receivedReqs);
}
catch (ServiceUnavailableException)
{
throw new ServiceUnavailableException("Não foi possível enviar o pedido.");
}
catch (RemotingException)
{
throw new ServiceUnavailableException("Não foi possível enviar o pedido.");
}
}
public void SendFriendRequest(FriendRequest f)
{
//Return if we're already friends
Friends friends = GetFriendList();
foreach (Friend friend in friends.FriendsInfo.Values)
if (friend.Address == f.SendTo && friend.Port == f.SendToPort)
return;
try
{
ServerManager.Instance.ServerInstance.ServerRequestInvoker.SendFriendRequest(f);
}
catch (ServiceUnavailableException)
{
throw new ServiceUnavailableException("Não foi possível enviar o pedido.Por favor tente mais tarde.");
}
catch (RemotingException)
{
throw new ServiceUnavailableException("Não foi possível enviar o pedido.");
}
FriendRequestList pl = GetSentFriendRequests();
pl.AddFriendRequest(f);
ServerManager.Instance.ServerInstance.WriteDomainObject(pl);
}
public void CreateFriendRequest(FriendRequest friendRequest)
{
this.friendRequests.Add(friendRequest);
this.friendRequests.Save();
}
public void AcceptFriendRequest(FriendRequest fr)
{
//Remove request
FriendRequestList pl = (FriendRequestList)ServerManager.Instance.ServerInstance.ReadDomainObject("SentFriendRequests");
if (pl != null)
{
pl.RemoveFriendRequest(fr);
ServerManager.Instance.ServerInstance.WriteDomainObject(pl);
}
//Add friend
Friends plist = (Friends)ServerManager.Instance.ServerInstance.ReadDomainObject("Friends");
if (plist == null)
{
plist = new Friends("Friends");
}
// Add only if we're not already friends
if (!plist.FriendsInfo.ContainsKey(fr.RequestedUserName))
{
plist.AddFriend(fr.RequestedUserName, fr.SendTo, fr.SendToPort);
ServerManager.Instance.ServerInstance.WriteDomainObject(plist);
//Add post
Post p = new Post("PADIBook de " + fr.RequestingUserName, fr.RequestedUserName + " ficou seu amigo.O seu endereço é " + fr.SendTo + ":" + fr.SendToPort);
PostList postl = (PostList)ServerManager.Instance.ServerInstance.ReadDomainObject("PostList");
if (postl == null)
{
postl = new PostList("PostList");
ServerManager.Instance.ServerInstance.WriteDomainObject(postl);
}
postl.AddPost(p);
ServerManager.Instance.ServerInstance.WriteDomainObject(postl);
}
}
public void DeleteFriendRequest(FriendRequest friendRequest)
{
friendRequest.IsDeleted = true;
this.friendRequests.Save();
}
public async Task<StatusData<string>> UnFriendRequest(FriendRequest request, SystemSession session)
{
var result = new StatusData<string>();
var response = await Task.Factory.StartNew(() => Client.UserService.UnFriend(session.UserName, request.FriendId, session.GetSession(), request.FriendId)).ConfigureAwait(false);
result.Data = response.CTag;
result.Status = (SystemDbStatus)response.DbStatusCode;
result.Message = response.DbStatusMsg;
return result;
}
