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