InviteToParty

InviteToParty.cs

    /// <summary>
    /// Invites Player to the caller's Party Group. If no Party Group exists yet, it creates it.
    /// </summary>
    public static class InviteToParty
    {
        [FunctionName("InviteToParty")]
        public static async Task<dynamic> Run(
           [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
           ILogger log)
        {
            var context = await SharedLogic.InitializeFunction(req, log);

            ListMembershipRequest listMembershipRequest = new ListMembershipRequest()
            {
                AuthenticationContext = context.PlayFabAuthenticationContext,
                Entity = context.CallerEntity
            };

            var listMembershipResponse = await PlayFabGroupsAPI.ListMembershipAsync(listMembershipRequest);

            var groupWithRoles = listMembershipResponse.Result.Groups.SingleOrDefault(g => g.GroupName.StartsWith(Constants.PartyGroupPrefix));

            var group = groupWithRoles?.Group;
            // Create group if it does not exist
            if (group == null)
            {
                var createGroupRequest = new CreateGroupRequest()
                {
                    AuthenticationContext = context.PlayFabAuthenticationContext,
                    Entity = context.CallerEntity,
                    GroupName = $"{Constants.PartyGroupPrefix}{context.CallerEntity.Id}",
                };

                var createGroupResult = await PlayFabGroupsAPI.CreateGroupAsync(createGroupRequest);
                log.LogInformation($"createGroupResult: {JsonConvert.SerializeObject(createGroupResult)}");

                if (createGroupResult.Error != null)
                {
                    log.LogCritical(createGroupResult.Error.ErrorMessage);
                    return new { Success = false, ErrorMessage = createGroupResult.Error.ErrorMessage };
                }

                group = createGroupResult.Result.Group;
            }

            var getUserAccountInfoRequest = new GetUserAccountInfoRequest()
            {
                AuthenticationContext = context.PlayFabAuthenticationContext,
                PlayFabId = context.FunctionArgument.FriendPlayFabMasterId
            };

            var getUserAccountInfoResult = await PlayFabServerAPI.GetUserAccountInfoAsync(getUserAccountInfoRequest);

            if (getUserAccountInfoResult.Error != null)
            {
                log.LogCritical(getUserAccountInfoResult.Error.ErrorMessage);
                return new { Success = false, ErrorMessage = getUserAccountInfoResult.Error.ErrorMessage };
            }

            var friendEntity = ClassConverter<PlayFab.ServerModels.EntityKey, PlayFab.GroupsModels.EntityKey>.Convert(getUserAccountInfoResult.Result.UserInfo.TitleInfo.TitlePlayerAccount);
            var inviteToGroupRequest = new InviteToGroupRequest()
            {
                AuthenticationContext = context.PlayFabAuthenticationContext,
                Group = group,
                Entity = friendEntity
            };
            log.LogInformation($"inviteToGroupRequest: {JsonConvert.SerializeObject(inviteToGroupRequest)}");

            var inviteToGroupResult = await PlayFabGroupsAPI.InviteToGroupAsync(inviteToGroupRequest);

            log.LogInformation($"inviteToGroupResult: {JsonConvert.SerializeObject(inviteToGroupResult)}");

            if (inviteToGroupResult.Error != null)
            {
                log.LogCritical(inviteToGroupResult.Error.ErrorMessage);
                return new { Success = false, ErrorMessage = inviteToGroupResult.Error.ErrorMessage };
            }

            return new { Success = true, Group = group };
        }
    }

SharedLogic.cs

  public class GroupsFunctionExecutionContext
    {
        public PlayFab.GroupsModels.EntityKey CallerEntity { get; set; }
        public PlayFabAuthenticationContext PlayFabAuthenticationContext { get; set; }
        public dynamic FunctionArgument { get; set; }
    }
    
    public static class SharedLogic
    {
        public static void InitPlayFabSettings()
        {
            PlayFabSettings.staticSettings.TitleId = Constants.TitleId;
            PlayFabSettings.staticSettings.DeveloperSecretKey = Constants.DeveloperSecretKey;
        }

        public static async Task<GroupsFunctionExecutionContext> InitializeFunction(HttpRequest req, ILogger log)
        {
            InitPlayFabSettings();

            var reqString = await req.ReadAsStringAsync();
            log.LogInformation($"HttpRequest: {reqString}");

            GroupsFunctionExecutionContext context = new GroupsFunctionExecutionContext();

            var playStreamExecutionContext = JsonConvert.DeserializeObject<PlayerPlayStreamFunctionExecutionContext<dynamic>>(reqString);

            if (playStreamExecutionContext?.PlayStreamEventEnvelope != null)
            {
                context.PlayFabAuthenticationContext = ClassConverter<TitleAuthenticationContext, PlayFabAuthenticationContext>.Convert(playStreamExecutionContext.TitleAuthenticationContext);

                var masterPlayerAccountId = playStreamExecutionContext.PlayerProfile.PlayerId;
                PlayFab.ProfilesModels.GetTitlePlayersFromMasterPlayerAccountIdsRequest getTitlePlayersFromMasterPlayerAccountIdsRequest = new PlayFab.ProfilesModels.GetTitlePlayersFromMasterPlayerAccountIdsRequest()
                {
                    MasterPlayerAccountIds = new List<string>() { masterPlayerAccountId },
                    TitleId = Constants.TitleId,
                    AuthenticationContext = context.PlayFabAuthenticationContext
                };
                var titlePlayersResult = await PlayFabProfilesAPI.GetTitlePlayersFromMasterPlayerAccountIdsAsync(getTitlePlayersFromMasterPlayerAccountIdsRequest);
                var titlePlayerAccount = titlePlayersResult.Result.TitlePlayerAccounts[masterPlayerAccountId];
                context.CallerEntity = ClassConverter<PlayFab.ProfilesModels.EntityKey, PlayFab.GroupsModels.EntityKey>.Convert(titlePlayerAccount);
                context.FunctionArgument = playStreamExecutionContext.FunctionArgument;
            }
            else
            {
                var functionExecutionContext = JsonConvert.DeserializeObject<FunctionExecutionContext<dynamic>>(reqString);

                context.CallerEntity = ClassConverter<PlayFab.ProfilesModels.EntityKey, PlayFab.GroupsModels.EntityKey>.Convert(functionExecutionContext.CallerEntityProfile.Entity);
                context.PlayFabAuthenticationContext = ClassConverter<TitleAuthenticationContext, PlayFabAuthenticationContext>.Convert(functionExecutionContext.TitleAuthenticationContext);
                context.FunctionArgument = functionExecutionContext.FunctionArgument;
            }

            return context;
        }
    }