/// <summary>
    /// 创建实例
    /// </summary>
    public static RemoveFriendRequest create(long playerID)
    {
        RemoveFriendRequest re = (RemoveFriendRequest)BytesControl.createRequest(dataID);

        re.playerID = playerID;
        return(re);
    }
Beispiel #2
0
        public override Task <RemoveFriendResponse> RemoveFriend(RemoveFriendRequest request, ServerCallContext context)
        {
            _friendsService.RemoveFriend(Guid.Parse(request.UserId), Guid.Parse(request.FriendId));
            var response = new RemoveFriendResponse();

            return(Task.FromResult(response));
        }
Beispiel #3
0
    private void handleremovefriend(string name)
    {
        string id      = friends.FirstOrDefault(f => f.TitleDisplayName == name).FriendPlayFabId;
        var    request = new RemoveFriendRequest {
            FriendPlayFabId = id
        };

        PlayFabClientAPI.RemoveFriend(request, onfriendremovedseccess, onfailure);
    }
Beispiel #4
0
    private void HandleRemoveFriend(string name)
    {
        string id = friends.FirstOrDefault(f => f.TitleDisplayName == name).FriendPlayFabId;

        print("remove friend" + name + id);
        var request = new RemoveFriendRequest {
            FriendPlayFabId = id
        };

        PlayFabClientAPI.RemoveFriend(request, OnFriendRemoveSuccess, OnFailure);
    }
Beispiel #5
0
 private void RemoveLocalFriendConfirm()
 {
     foreach (SpaceNationFriend SNfriend in SpaceNationFriendList)
     {
         if (SNfriend.name.Equals(friendToRemove))
         {
             RemoveFriendRequest request = new RemoveFriendRequest();
             request.FriendPlayFabId = SNfriend.playfabId;
             friendIDToRemove        = SNfriend.playfabId;
             PlayFabClientAPI.RemoveFriend(request, OnRemoveFriendSuccess, OnPlayFabError);
             break;
         }
     }
 }
        public RemoveFriendResponse RemoveFriend(RemoveFriendRequest input)
        {
            if (!this.ModelState.IsValid)
            {
                return new RemoveFriendResponse
                {
                    Status = new Status
                    {
                        Code = 601,
                        Message = this.ModelState.Values.First().Errors.First().ErrorMessage
                    }
                };
            }

            if (input == null)
            {
                return new RemoveFriendResponse(Status.MISSING_PARRAMETERS);
            }

            ////check for register user by Token
            User currentUser = null;
            try
            {
                currentUser = this.Users.SingleOrDefault(a => a.Token == input.Token); ////TOKEN must be unique
                if (currentUser == null)
                {
                    return new RemoveFriendResponse(Status.INVALID_TOKEN);
                }
            }
            catch (Exception)
            {
                return new RemoveFriendResponse(Status.INTERNAL_ERROR);
            }

            ////check for exist friend
            var friends = currentUser.Friends;
            if (friends.Count > 0)
            {
                var friend = friends.FirstOrDefault(a => a.Email == input.Email);
                if (friend != null)
                {
                    friends.Remove(friend);
                    this.Users.Update(currentUser);

                    return new RemoveFriendResponse(Status.REMOVEFRIEND_SUCCESS);
                }
            }

            return new RemoveFriendResponse(Status.REMOVEFRIEND_NOT_EXIST_IN_LIST);
        }
Beispiel #7
0
    public static void RemoveFriend(string id, UnityAction callback = null)
    {
        var request = new RemoveFriendRequest {
            FriendPlayFabId = id
        };

        PlayFabClientAPI.RemoveFriend(request, result =>
        {
            if (callback != null)
            {
                callback();
            }
            PF_Bridge.RaiseCallbackSuccess(string.Empty, PlayFabAPIMethods.RemoveFriend, MessageDisplayStyle.none);
        }, PF_Bridge.PlayFabErrorCallback);
    }
    public void removeFriendRequest(string id, GameObject friend)
    {
        Debug.Log("REMOVE CLICK");

        RemoveFriendRequest request = new RemoveFriendRequest()
        {
            FriendPlayFabId = id
        };

        PlayFabClientAPI.RemoveFriend(request, (result) =>
        {
            Debug.Log("Removed friend successfully");
            friend.SetActive(false);
        }, (error) =>
        {
            Debug.Log("Error removing friend: " + error.Error);
        }, null);
    }
Beispiel #9
0
        public async Task RemoveFriendAsync(Guid userId, Guid friendId)
        {
            var channel = new Channel(channelTarget, ChannelCredentials.Insecure);

            try
            {
                var client  = new FriendsGrpcService.FriendsGrpcServiceClient(channel);
                var request = new RemoveFriendRequest()
                {
                    UserId   = userId.ToString(),
                    FriendId = friendId.ToString()
                };

                var response = await client.RemoveFriendAsync(request);

                return;
            }
            finally
            {
                await channel.ShutdownAsync();
            }
        }
        public override async Task <RemoveFriendResponse> RemoveFriend(RemoveFriendRequest request, ServerCallContext context)
        {
            DbUserModel dbUserModel = context.UserState["user"] as DbUserModel;

            if (dbUserModel == null)
            {
                return new RemoveFriendResponse()
                       {
                           Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED)
                       }
            }
            ;

            DbUserModel friend = await DbUserModel.GetUserFromGuid(request.FriendId);

            if (friend == null)
            {
                return new RemoveFriendResponse()
                       {
                           Status = ResponseFactory.createResponse(ResponseType.PLAYER_DOES_NOT_EXIST)
                       }
            }
            ;

            if (!await dbUserModel.IsFriend(friend))
            {
                return new RemoveFriendResponse()
                       {
                           Status = ResponseFactory.createResponse(ResponseType.INVALID_REQUEST)
                       }
            }
            ;

            await dbUserModel.RemoveFriend(friend);

            return(new RemoveFriendResponse());
        }
        /// <summary>
        /// フレンドを削除する。
        /// </summary>
        /// <param name="playFabId"></param>
        /// <returns></returns>
        public static async UniTask <(bool isSuccess, string message)> RemoveFriendAsync(string playFabId)
        {
            var request = new RemoveFriendRequest
            {
                FriendPlayFabId = playFabId
            };

            var response = await PlayFabClientAPI.RemoveFriendAsync(request);

            if (response.Error != null)
            {
                switch (response.Error.Error)
                {
                case PlayFabErrorCode.AccountNotFound:
                case PlayFabErrorCode.InvalidParams:
                    return(false, "指定されたユーザーが見つかりませんでした。");

                default:
                    throw new PlayFabErrorException(response.Error);
                }
            }

            return(true, "フレンドを解除しました。");
        }
Beispiel #12
0
 BattlenetRpcErrorCode HandleRemoveFriend(RemoveFriendRequest request, NoData response)
 {
     Log.outError(LogFilter.ServiceProtobuf, "{0} Client tried to call not implemented method FriendsService.RemoveFriend: {1}",
                  GetCallerInfo(), request.ToString());
     return(BattlenetRpcErrorCode.RpcNotImplemented);
 }
 /// <summary>
 /// If the TPS service no longer wants to interact anymore with an existing friend, the TPS can break the friendship
 /// relation. Immediately after this call, messaging is no longer possible between the service and the friend in
 /// either direction.
 /// </summary>
 /// <returns> RemoveFriendResponse object</returns>
 /// <param name="request"> RemoveFriendRequest object</param>
 public RemoveFriendResponse RemoveFriend(RemoveFriendRequest request)
 {
     return RemoveFriend(request, Guid.NewGuid().ToString());
 }
 /// <summary>
 /// If the TPS service no longer wants to interact anymore with an existing friend, the TPS can break the friendship
 /// relation. Immediately after this call, messaging is no longer possible between the service and the friend in
 /// either direction.
 /// </summary>
 /// <returns> RemoveFriendResponse object</returns>
 /// <param name="request"> RemoveFriendRequest object</param>
 /// <param name='jsonRpcCallId'>
 /// The json rpc call identifier. This is a string generated by the client, which can be used to correlate the response to the request. Max length is 256 characters. A JSON-RPC id must be generated on a per call invocation basis. The Rogerthat platform uses the id of the call to store the call result for a certain amount of time so that if something fails during the communication, the same call (having the same JSON-RPC id) can be resent to the Rogerthat service, allowing to fetch the result, without actually executing the call again. This avoids annoying problems such as duplicate delivery of messages.
 /// 
 /// You should use a different JSON-RPC id for every call you make.
 /// 
 /// In case of an intermittent failure such as a network connectivity problem, you can retry the same call using the same JSON-RPC id, without running the risk of duplicate execution of your call (e.g. duplicate message delivery).
 /// </param>
 public RemoveFriendResponse RemoveFriend(RemoveFriendRequest request, string jsonRpcCallId)
 {
     RemoveFriendResponse result = new RemoveFriendResponse();
     WireRequest(0, jsonRpcCallId, "friend.break_up", (writer) =>
     {
         request.Write(writer, false);
     }, (reader) =>
     {
         result.Read(reader);
     }
     );
     return result;
 }
Beispiel #15
0
 public static IEnumerator <RemoveFriendResult> Do(RemoveFriendRequest request)
 {
     // should update the cached list after it's done
     return(Do <RemoveFriendRequest, RemoveFriendResult>(request, PlayFabClientAPI.RemoveFriend));
 }
 public UnityTask <RemoveFriendResult> Do(RemoveFriendRequest request)
 {
     // should update the cached list after it's done
     return(this.Do <RemoveFriendRequest, RemoveFriendResult>(request, PlayFabClientAPI.RemoveFriendAsync));
 }
Beispiel #17
0
        public override void CallServerMethod(uint token, uint methodId, CodedInputStream stream)
        {
            switch (methodId)
            {
            case 1:
            {
                SubscribeRequest request = new SubscribeRequest();
                request.MergeFrom(stream);

                SubscribeResponse     response = new SubscribeResponse();
                BattlenetRpcErrorCode status   = HandleSubscribe(request, response);
                Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method FriendsService.Subscribe(bgs.protocol.friends.v1.SubscribeRequest: {1}) returned bgs.protocol.friends.v1.SubscribeResponse: {2} status: {3}.",
                             GetCallerInfo(), request.ToString(), response.ToString(), status);
                if (status == 0)
                {
                    SendResponse(token, response);
                }
                else
                {
                    SendResponse(token, status);
                }
                break;
            }

            case 2:
            {
                SendInvitationRequest request = new SendInvitationRequest();
                request.MergeFrom(stream);

                NoData response = new NoData();
                BattlenetRpcErrorCode status = HandleSendInvitation(request, response);
                Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method FriendsService.SendInvitation(bgs.protocol.SendInvitationRequest: {1}) returned bgs.protocol.NoData: {2} status: {3}.",
                             GetCallerInfo(), request.ToString(), response.ToString(), status);
                if (status == 0)
                {
                    SendResponse(token, response);
                }
                else
                {
                    SendResponse(token, status);
                }
                break;
            }

            case 3:
            {
                AcceptInvitationRequest request = new AcceptInvitationRequest();
                request.MergeFrom(stream);

                NoData response = new NoData();
                BattlenetRpcErrorCode status = HandleAcceptInvitation(request, response);
                Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method FriendsService.AcceptInvitation(bgs.protocol.GenericInvitationRequest: {1}) returned bgs.protocol.NoData: {2} status: {3}.",
                             GetCallerInfo(), request.ToString(), response.ToString(), status);
                if (status == 0)
                {
                    SendResponse(token, response);
                }
                else
                {
                    SendResponse(token, status);
                }
                break;
            }

            case 4:
            {
                RevokeInvitationRequest request = new RevokeInvitationRequest();
                request.MergeFrom(stream);

                NoData response = new NoData();
                BattlenetRpcErrorCode status = HandleRevokeInvitation(request, response);
                Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method FriendsService.RevokeInvitation(bgs.protocol.GenericInvitationRequest: {1}) returned bgs.protocol.NoData: {2} status: {3}.",
                             GetCallerInfo(), request.ToString(), response.ToString(), status);
                if (status == 0)
                {
                    SendResponse(token, response);
                }
                else
                {
                    SendResponse(token, status);
                }
                break;
            }

            case 5:
            {
                DeclineInvitationRequest request = new DeclineInvitationRequest();
                request.MergeFrom(stream);

                NoData response = new NoData();
                BattlenetRpcErrorCode status = HandleDeclineInvitation(request, response);
                Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method FriendsService.DeclineInvitation(bgs.protocol.GenericInvitationRequest: {1}) returned bgs.protocol.NoData: {2} status: {3}.",
                             GetCallerInfo(), request.ToString(), response.ToString(), status);
                if (status == 0)
                {
                    SendResponse(token, response);
                }
                else
                {
                    SendResponse(token, status);
                }
                break;
            }

            case 6:
            {
                IgnoreInvitationRequest request = new IgnoreInvitationRequest();
                request.MergeFrom(stream);

                NoData response = new NoData();
                BattlenetRpcErrorCode status = HandleIgnoreInvitation(request, response);
                Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method FriendsService.IgnoreInvitation(bgs.protocol.GenericInvitationRequest: {1}) returned bgs.protocol.NoData: {2} status: {3}.",
                             GetCallerInfo(), request.ToString(), response.ToString(), status);
                if (status == 0)
                {
                    SendResponse(token, response);
                }
                else
                {
                    SendResponse(token, status);
                }
                break;
            }

            case 8:
            {
                RemoveFriendRequest request = new RemoveFriendRequest();
                request.MergeFrom(stream);

                NoData response = new NoData();
                BattlenetRpcErrorCode status = HandleRemoveFriend(request, response);
                Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method FriendsService.RemoveFriend(bgs.protocol.friends.v1.GenericFriendRequest: {1}) returned bgs.protocol.friends.v1.GenericFriendResponse: {2} status: {3}.",
                             GetCallerInfo(), request.ToString(), response.ToString(), status);
                if (status == 0)
                {
                    SendResponse(token, response);
                }
                else
                {
                    SendResponse(token, status);
                }
                break;
            }

            case 9:
            {
                ViewFriendsRequest request = new ViewFriendsRequest();
                request.MergeFrom(stream);

                ViewFriendsResponse   response = new ViewFriendsResponse();
                BattlenetRpcErrorCode status   = HandleViewFriends(request, response);
                Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method FriendsService.ViewFriends(bgs.protocol.friends.v1.ViewFriendsRequest: {1}) returned bgs.protocol.friends.v1.ViewFriendsResponse: {2} status: {3}.",
                             GetCallerInfo(), request.ToString(), response.ToString(), status);
                if (status == 0)
                {
                    SendResponse(token, response);
                }
                else
                {
                    SendResponse(token, status);
                }
                break;
            }

            case 10:
            {
                UpdateFriendStateRequest request = new UpdateFriendStateRequest();
                request.MergeFrom(stream);

                NoData response = new NoData();
                BattlenetRpcErrorCode status = HandleUpdateFriendState(request, response);
                Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method FriendsService.UpdateFriendState(bgs.protocol.friends.v1.UpdateFriendStateRequest: {1}) returned bgs.protocol.NoData: {2} status: {3}.",
                             GetCallerInfo(), request.ToString(), response.ToString(), status);
                if (status == 0)
                {
                    SendResponse(token, response);
                }
                else
                {
                    SendResponse(token, status);
                }
                break;
            }

            case 11:
            {
                UnsubscribeRequest request = new UnsubscribeRequest();
                request.MergeFrom(stream);

                NoData response = new NoData();
                BattlenetRpcErrorCode status = HandleUnsubscribe(request, response);
                Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method FriendsService.Unsubscribe(bgs.protocol.friends.v1.UnsubscribeRequest: {1}) returned bgs.protocol.NoData: {2} status: {3}.",
                             GetCallerInfo(), request.ToString(), response.ToString(), status);
                if (status == 0)
                {
                    SendResponse(token, response);
                }
                else
                {
                    SendResponse(token, status);
                }
                break;
            }

            case 12:
            {
                RevokeAllInvitationsRequest request = new RevokeAllInvitationsRequest();
                request.MergeFrom(stream);

                NoData response = new NoData();
                BattlenetRpcErrorCode status = HandleRevokeAllInvitations(request, response);
                Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method FriendsService.RevokeAllInvitations(bgs.protocol.friends.v1.GenericFriendRequest: {1}) returned bgs.protocol.NoData: {2} status: {3}.",
                             GetCallerInfo(), request.ToString(), response.ToString(), status);
                if (status == 0)
                {
                    SendResponse(token, response);
                }
                else
                {
                    SendResponse(token, status);
                }
                break;
            }

            default:
                Log.outError(LogFilter.ServiceProtobuf, "Bad method id {0}.", methodId);
                SendResponse(token, BattlenetRpcErrorCode.RpcInvalidMethod);
                break;
            }
        }