C# execute function has compile errors

[ashkan-saeedi-mazdeh]

Hi
This function has compile errors.
https://github.com/PlayFab/pf-af-devfuncs/blob/main/csharp/ExecuteFunction.cs
When I remove the static keyword from the class it mostly works but the script does not return the values I return from my function to unity. The deployed version works correctly.

[PinkPointer]

I have the same issue, how did you fix it?

[ashkan-saeedi-mazdeh]

Never solved it @PinkPointer Just deploy when need to test the return values. Also the json serializer's default settings don't serialize fields and only properties so be aware of that.

[PinkPointer]

I was able to fix it, had to change the parameter to HttpRequestData:

// Copyright (C) Microsoft Corporation. All rights reserved.

namespace PlayFab.AzureFunctions
{
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using PlayFab.Internal;
using PlayFab.Json;
using PlayFab.ProfilesModels;
using System.Net;
using System.Net.Http.Headers;
using System.Linq;
using System.Text;
using System.Net.Http;
using System.IO;
using System.Diagnostics;
using System;
using System.Threading.Tasks;

public class LocalExecuteFunction
{
    private static ILogger logger;

    private const string DEV_SECRET_KEY = "PLAYFAB_DEV_SECRET_KEY";
    private const string TITLE_ID_KEY = "PLAYFAB_TITLE_ID_KEY";
    private const string CLOUD_NAME = "PLAYFAB_CLOUD_NAME";
    private const string _defaultRoutePrefix = "api";
    private static readonly HttpClient httpClient = new HttpClient();

    [Function("ExecuteFunction")]
    public async Task<HttpResponseData> ExecuteFunction(
        [HttpTrigger(AuthorizationLevel.Function, "post", Route = "CloudScript/ExecuteFunction")] HttpRequestData request,
        FunctionContext executionContext)
    {
        logger = executionContext.GetLogger("LocalExecuteFunction");

        // Extract the caller's entity token
        var callerEntityToken = request.Headers.Contains("X-EntityToken")
            ? request.Headers.GetValues("X-EntityToken").FirstOrDefault()
            : null;

        // Extract the request body and deserialize
        var body = await new StreamReader(request.Body).ReadToEndAsync();
        var execRequest = PlayFabSimpleJson.DeserializeObject<ExecuteFunctionRequest>(body);
        EntityKey entityKey = execRequest.Entity != null ? new EntityKey { Id = execRequest.Entity?.Id, Type = execRequest.Entity?.Type } : null;

        // Create a FunctionContextInternal as the payload to send to the target function
        var functionContext = new FunctionContextInternal
        {
            CallerEntityProfile = await GetEntityProfile(callerEntityToken, entityKey),
            TitleAuthenticationContext = new TitleAuthenticationContext
            {
                Id = Environment.GetEnvironmentVariable(TITLE_ID_KEY, EnvironmentVariableTarget.Process),
                EntityToken = await GetTitleEntityToken()
            },
            FunctionArgument = execRequest.FunctionParameter
        };

        // Serialize the request to the Azure function and add headers
        var functionRequestContent = new StringContent(PlayFabSimpleJson.SerializeObject(functionContext));
        functionRequestContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");

        var azureFunctionUri = ConstructLocalAzureFunctionUri(execRequest.FunctionName, request.Url.Host, request.Url.Port);

        var sw = new Stopwatch();
        sw.Start();

        // Execute the local Azure function
        var functionResponseMessage = await httpClient.PostAsync(azureFunctionUri, functionRequestContent);

        sw.Stop();

        // Prepare a response to reply back to client with and include function execution results
        var functionResult = new ExecuteFunctionResult
        {
            FunctionName = execRequest.FunctionName,
            FunctionResult = await ExtractFunctionResult(functionResponseMessage.Content),
            ExecutionTimeMilliseconds = (int)sw.ElapsedMilliseconds,
            FunctionResultTooLarge = false
        };

        // Reply back to client with final results
        var output = new PlayFabJsonSuccess<ExecuteFunctionResult>
        {
            code = 200,
            status = "OK",
            data = functionResult
        };

        // Serialize the output and return it
        var outputStr = PlayFabSimpleJson.SerializeObject(output);

        var response = request.CreateResponse(HttpStatusCode.OK);
        response.Headers.Add("Content-Type", "application/json");
        await response.WriteStringAsync(outputStr);
        return response;
    }

    /// <summary>
    /// Fetch's an entity's profile from the PlayFab server
    /// </summary>
    /// <param name="callerEntityToken">The entity token of the entity profile being fetched</param>
    /// <returns>The entity's profile</returns>
    private static async Task<EntityProfileBody> GetEntityProfile(string callerEntityToken, EntityKey entity)
    {
        // Construct the PlayFabAPI URL for GetEntityProfile
        var getProfileUrl = GetServerApiUri("/Profile/GetProfile");

        // Create the get entity profile request
        var profileRequest = new GetEntityProfileRequest
        {
            Entity = entity
        };

        // Prepare the request headers
        var profileRequestContent = new StringContent(PlayFabSimpleJson.SerializeObject(profileRequest));
        profileRequestContent.Headers.Add("X-EntityToken", callerEntityToken);
        profileRequestContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");

        PlayFabJsonSuccess<GetEntityProfileResponse> getProfileResponseSuccess = null;
        GetEntityProfileResponse getProfileResponse = null;

        // Execute the get entity profile request
        using (var profileResponseMessage = await httpClient.PostAsync(getProfileUrl, profileRequestContent))
        {
            using (var profileResponseContent = profileResponseMessage.Content)
            {
                string profileResponseString = await profileResponseContent.ReadAsStringAsync();

                // Deserialize the http response
                getProfileResponseSuccess =
                    PlayFabSimpleJson.DeserializeObject<PlayFabJsonSuccess<GetEntityProfileResponse>>(profileResponseString);

                // Extract the actual get profile response from the deserialized http response
                getProfileResponse = getProfileResponseSuccess?.data;
            }
        }

        // If response object was not filled it means there was an error
        if (getProfileResponseSuccess?.data == null || getProfileResponseSuccess?.code != 200)
        {
            throw new Exception($"Failed to get Entity Profile: code: {getProfileResponseSuccess?.code}");
        }

        return getProfileResponse.Profile;
    }

    /// <summary>
    /// Grabs the developer secret key from the environment variable (expected to be set) and uses it to
    /// ask the PlayFab server for a title entity token.
    /// </summary>
    /// <returns>The title's entity token</returns>
    private static async Task<string> GetTitleEntityToken()
    {
        var titleEntityTokenRequest = new PlayFab.AuthenticationModels.GetEntityTokenRequest();

        var getEntityTokenUrl = GetServerApiUri("/Authentication/GetEntityToken");

        // Grab the developer secret key from the environment variables (app settings) to use as header for GetEntityToken
        var secretKey = Environment.GetEnvironmentVariable(DEV_SECRET_KEY, EnvironmentVariableTarget.Process);

        if (string.IsNullOrEmpty(secretKey))
        {
            // Environment variable was not set on the app
            throw new Exception("Could not fetch the developer secret key from the environment. Please set \"PLAYFAB_DEV_SECRET_KEY\" in your app's local.settings.json file.");
        }

        var titleEntityTokenRequestContent = new StringContent(PlayFabSimpleJson.SerializeObject(titleEntityTokenRequest));
        titleEntityTokenRequestContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
        titleEntityTokenRequestContent.Headers.Add("X-SecretKey", secretKey);
        using (var titleEntityTokenResponseMessage =
            await httpClient.PostAsync(getEntityTokenUrl, titleEntityTokenRequestContent))
        {
            using (var titleEntityTokenResponseContent = titleEntityTokenResponseMessage.Content)
            {
                string titleEntityTokenResponseString = await titleEntityTokenResponseContent.ReadAsStringAsync();

                // Deserialize the http response
                var titleEntityTokenResponseSuccess =
                    PlayFabSimpleJson.DeserializeObject<PlayFabJsonSuccess<PlayFab.AuthenticationModels.GetEntityTokenResponse>>(titleEntityTokenResponseString);

                // Extract the actual get title entity token header
                var titleEntityTokenResponse = titleEntityTokenResponseSuccess.data;

                return titleEntityTokenResponse.EntityToken;
            }
        }
    }

    /// <summary>
    /// Constructs a function's local url given its name and the current function app's host. Assumes that the
    /// function is located in the same function app as the application host provided.
    /// </summary>
    /// <param name="functionName">The name of the function to construct a URL for</param>
    /// <param name="appHost">The function's application host</param>
    /// <returns>The function's URI</returns>
    private static string ConstructLocalAzureFunctionUri(string functionName, string host, int port)
    {
        // Assemble the target function's path in the current App
        string routePrefix = GetHostRoutePrefix();
        string functionPath = routePrefix != null ? routePrefix + "/" + functionName
            : functionName;

        // Build URI of Azure Function based on current host
        var uriBuilder = new UriBuilder
        {
            Host = host,
            Port = port != 0 ? port : 80,
            Path = functionPath
        };

        return uriBuilder.Uri.AbsoluteUri;
    }

    private static async Task<object> ExtractFunctionResult(HttpContent content)
    {
        string responseContent = await content.ReadAsStringAsync();

        if (!string.IsNullOrWhiteSpace(responseContent))
        {
            // JSON object or array
            if (responseContent.StartsWith("{") || responseContent.StartsWith("["))
            {
                return PlayFabSimpleJson.DeserializeObject(responseContent);
            }
            // JSON number
            else if (float.TryParse(responseContent, out float f))
            {
                return f;
            }
            // JSON true or false
            else if (bool.TryParse(responseContent, out bool b))
            {
                return b;
            }
            else // JSON string
            {
                return responseContent;
            }
        }

        return null;
    }


    private static string GetServerApiUri(string endpoint)
    {
        var sb = new StringBuilder();

        // Append the title name if applicable
        string title = Environment.GetEnvironmentVariable(TITLE_ID_KEY, EnvironmentVariableTarget.Process);
        if (!string.IsNullOrEmpty(title))
        {
            sb.Append(title).Append(".");
        }
        // Append the cloud name if applicable
        string cloud = Environment.GetEnvironmentVariable(CLOUD_NAME, EnvironmentVariableTarget.Process);
        if (!string.IsNullOrEmpty(cloud))
        {
            sb.Append(cloud).Append(".");
        }
        // Append base PF API address
        sb.Append("playfabapi.com");

        var uriBuilder = new UriBuilder
        {
            Scheme = "https",
            Host = sb.ToString(),
            Path = endpoint
        };

        return uriBuilder.Uri.AbsoluteUri;
    }

    #region Utility Functions
    private static string ReadAllFileText(string filename)
    {
        var sb = new StringBuilder();

        if (!File.Exists(filename))
        {
            return string.Empty;
        }

        if (sb == null)
        {
            sb = new StringBuilder();
        }
        sb.Length = 0;

        using (var fs = new FileStream(filename, FileMode.Open))
        {
            using (var br = new BinaryReader(fs))
            {
                while (br.BaseStream.Position != br.BaseStream.Length)
                {
                    sb.Append(br.ReadChar());
                }
            }
        }

        return sb.ToString();
    }

    private static string GetHostRoutePrefix()
    {
        string hostFileContent = null;
        string currDir = Directory.GetCurrentDirectory();
        string currDirHostFile = Path.Combine(currDir, "host.json");

        if (File.Exists(currDirHostFile))
        {
            hostFileContent = ReadAllFileText(currDirHostFile);
        }

        var hostModel = PlayFabSimpleJson.DeserializeObject<HostJsonModel>(hostFileContent);
        return hostModel?.extensions?.http?.routePrefix ?? _defaultRoutePrefix;
    }        

    private static byte[] StreamToBytes(Stream input)
    {
        input.Seek(0, SeekOrigin.Begin);
        byte[] buffer = new byte[4 * 1024];
        using (var output = new MemoryStream())
        {
            int read;
            while ((read = input.Read(buffer, 0, buffer.Length)) > 0)
            {
                output.Write(buffer, 0, read);
            }
            return output.ToArray();
        }
    }
    #endregion
}

#region Models
public class TitleAuthenticationContext
{
    public string Id;
    public string EntityToken;
}

public class FunctionContextInternal : FunctionContextInternal<object>
{
}

public class FunctionContextInternal<TFunctionArgument>
{
    public TitleAuthenticationContext TitleAuthenticationContext { get; set; }
    public EntityProfileBody CallerEntityProfile { get; set; }
    public TFunctionArgument FunctionArgument { get; set; }
}

public class ExecuteFunctionRequest : PlayFabRequestCommon
{
    public PlayFab.ClientModels.EntityKey Entity { get; set; }

    public string FunctionName { get; set; }

    public object FunctionParameter { get; set; }

    public bool? GeneratePlayStreamEvent { get; set; }
}

public class ExecuteFunctionResult : PlayFabResultCommon
{
    public int ExecutionTimeMilliseconds;
    public string FunctionName;
    public object FunctionResult;
    public bool? FunctionResultTooLarge;
}

public class HostJsonModel
{
    public string version { get; set; }
    public HostJsonExtensionsModel extensions { get; set; }

    public class HostJsonExtensionsModel
    {
        public HostJsonHttpModel http { get; set; }
    }

    public class HostJsonHttpModel
    {
        public string routePrefix { get; set; }
    }
}
#endregion

}

[ashkan-saeedi-mazdeh]

Ah fantastic. Maybe submit a pull request for the playfab team then. I would give it a try as well and will close the issue if it was working.

[ashkan-saeedi-mazdeh]

This does not work for me @PinkPointer

[ashkan-saeedi-mazdeh]

@PinkPointer Are you using the isolated model as well?

[PinkPointer]

@PinkPointer Are you using the isolated model as well?

Yes

This does not work for me @PinkPointer

What is happening exactly?

[ashkan-saeedi-mazdeh]

@PinkPointer
The requests are not even arrive at my function codes.

[PinkPointer]

@PinkPointer The requests are not even arrive at my function codes.

Are you testing locally first?

If not, it will probably be easier to make it work locally first:
https://learn.microsoft.com/en-us/gaming/playfab/live-service-management/service-gateway/automation/cloudscript-af/local-debugging-for-cloudscript-using-azure-functions

[ashkan-saeedi-mazdeh]

The only issue is locally. When I did the changes you mentioned, I no longer could test locally. We successfully test on Azure Functions on the server.

Also without your changes I can test locally up to processing the return value because the local executer returns empty responses