private static async Task PostFunctionResultToPlayFab(FunctionExecutionContext ctx, object result, long executionTime, ILogger log)
{
if (ctx.GeneratePlayStreamEvent.HasValue && ctx.GeneratePlayStreamEvent.Value)
{
await HelperFunctions.PostResults(ctx, nameof(IdentityQueued), result, (int)executionTime, log);
}
}
/// <inheriteddoc />
public IFunctionExecutionContext Execute(IEnumerable <KeyValuePair <string, object> > parameters,
bool autoStart)
{
FunctionExecutionContext result = new FunctionExecutionContext();
result.Function = this;
// prepare and check input parameters
{
IEnumerable <KeyValuePair <string, object> > normalizedParams = parameters ?? CollectionHelper.Empty <KeyValuePair <string, object> >();
IDictionary <string, object> paramsDict = this.CreateEmptyParameterCollection();
foreach (KeyValuePair <string, object> item in normalizedParams)
{
paramsDict.Add(item.Key ?? string.Empty,
this.ParseValueForParameter(item.Value));
}
result.InputParameters = new TMReadOnlyDictionary <string, object>(paramsDict);
if (this.CheckInputParameters(result.InputParameters) == false)
{
throw new ArgumentException("parameters");
}
}
if (autoStart)
{
result.Start();
}
return(result);
}
public async Task ExecuteAsync(FunctionExecutionContext context)
{
var invoker = context.FunctionDefinition.Invoker;
object?instance = invoker.CreateInstance(context.InstanceServices);
object?result = await invoker.InvokeAsync(instance, context.FunctionDefinition.Parameters.Select(p => p.Value).ToArray());
context.InvocationResult = result;
}
/// <summary>
/// Modify response
/// </summary>
/// <param name="context"></param>
private void ModifyResponse(FunctionExecutionContext context)
{
var response = context.InvocationResult as HttpResponseData;
response.Body += "\n <h2> Modified Response from a middleware </h2>";
context.Logger?.Log(LogLevel.Information, "Modified Response from middleware");
}
/// <summary>
/// Pass through respose stage of Bypass middleware
/// </summary>
/// <param name="context"></param>
private void ResponseStage(FunctionExecutionContext context)
{
var response = context.InvocationResult as HttpResponseData;
response.Body += "\n Response stage - Bypass midddleware!";
context.Logger?.Log(LogLevel.Information, "outside Bypass middleware");
}
public HttpResponseData Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestData req,
FunctionExecutionContext executionContext)
{
var logger = executionContext.Logger;
logger.LogInformation("message logged");
return(_responderService.ProcessRequest(req));
}
// インベントリカスタムデータを更新
private static async Task UpdateUserInventoryCustomDataAsync(FunctionExecutionContext <dynamic> context, DevelopUpdateUserInventoryCustomDataApiRequest request)
{
var serverApi = new PlayFabServerInstanceAPI(context.ApiSettings, context.AuthenticationContext);
var result = await serverApi.UpdateUserInventoryItemCustomDataAsync(new UpdateUserInventoryItemDataRequest()
{
PlayFabId = context.CallerEntityProfile.Lineage.MasterPlayerAccountId,
ItemInstanceId = request.itemInstanceId,
Data = request.data,
});
}
// 指定したキーのユーザーデータを更新
// key : ex) UserDataKey.userMonsterList
// value : ex) new List<UserMonsterInfo>(){ }
public static async Task UpdateUserDataAsync(FunctionExecutionContext <dynamic> context, Dictionary <UserDataKey, object> dict)
{
var serverApi = new PlayFabServerInstanceAPI(context.ApiSettings, context.AuthenticationContext);
var data = dict.ToDictionary(kvp => kvp.Key.ToString(), kvp => JsonConvert.SerializeObject(kvp.Value));
var result = await serverApi.UpdateUserDataAsync(new UpdateUserDataRequest()
{
PlayFabId = context.CallerEntityProfile.Lineage.MasterPlayerAccountId,
Data = data,
});
}
public static async Task <object> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] FunctionExecutionContext req,
HttpRequest httpRequest,
ILogger log)
{
string body = await httpRequest.ReadAsStringAsync();
log.LogInformation($"HTTP POST Body: {body}");
return(await Task.FromResult(req.FunctionArgument));
}
// ドロップテーブルから取得するアイテムを抽選
private static async Task <string> EvaluateRandomResultTable(FunctionExecutionContext <dynamic> context, dynamic dropTableName)
{
var serverApi = new PlayFabServerInstanceAPI(context.ApiSettings, context.AuthenticationContext);
var result = await serverApi.EvaluateRandomResultTableAsync(new EvaluateRandomResultTableRequest()
{
TableId = dropTableName
});
return(result.Result.ResultItemId);
}
// 指定したモンスターのカスタムデータを更新
public static async Task UpdateUserMonsterCustomDataAsync(FunctionExecutionContext <dynamic> context, string itemInstanceId, UserMonsterCustomData customData)
{
var serverApi = new PlayFabServerInstanceAPI(context.ApiSettings, context.AuthenticationContext);
var customDataDict = UserDataUtil.GetCustomDataDict(customData);
var result = await serverApi.UpdateUserInventoryItemCustomDataAsync(new UpdateUserInventoryItemDataRequest()
{
PlayFabId = context.CallerEntityProfile.Lineage.MasterPlayerAccountId,
ItemInstanceId = itemInstanceId,
Data = customDataDict,
});
}
// ドロップテーブルから取得するアイテムを抽選
private static async Task <List <GrantedItemInstance> > GrantItemsToUserTask(FunctionExecutionContext <Dictionary <string, List <string> > > context, dynamic itemIdList)
{
var serverApi = new PlayFabServerInstanceAPI(context.ApiSettings, context.AuthenticationContext);
var result = await serverApi.GrantItemsToUserAsync(new GrantItemsToUserRequest()
{
PlayFabId = context.CallerEntityProfile.Lineage.MasterPlayerAccountId,
ItemIds = itemIdList
});
return(result.Result.ItemGrantResults);
}
// 指定したアイテムを消費します
public static async Task <ConsumeItemResult> ConsumeItemAsync(FunctionExecutionContext <dynamic> context, string itemInstanceId, int consumeCount)
{
var serverApi = new PlayFabServerInstanceAPI(context.ApiSettings, context.AuthenticationContext);
var result = await serverApi.ConsumeItemAsync(new ConsumeItemRequest()
{
PlayFabId = context.CallerEntityProfile.Lineage.MasterPlayerAccountId,
ItemInstanceId = itemInstanceId,
ConsumeCount = consumeCount,
});
return(result.Result);
}
// ユーザーインベントリ情報を取得する
public static async Task <UserInventoryInfo> GetUserInventoryAsync(FunctionExecutionContext <dynamic> context)
{
var serverApi = new PlayFabServerInstanceAPI(context.ApiSettings, context.AuthenticationContext);
var result = await serverApi.GetUserInventoryAsync(new GetUserInventoryRequest()
{
PlayFabId = context.CallerEntityProfile.Lineage.MasterPlayerAccountId,
});
var userInventory = UserDataUtil.GetUserInventory(result.Result);
return(userInventory);
}
// ユーザーデータを取得する
public static async Task <UserDataInfo> GetUserDataAsync(FunctionExecutionContext <dynamic> context)
{
var serverApi = new PlayFabServerInstanceAPI(context.ApiSettings, context.AuthenticationContext);
var result = await serverApi.GetUserDataAsync(new GetUserDataRequest()
{
PlayFabId = context.CallerEntityProfile.Lineage.MasterPlayerAccountId,
});
// ユーザーデータのパラム名とそのデータのJsonの辞書にしてユーザーデータを取得
var userData = UserDataUtil.GetUserData(result.Result.Data);
return(userData);
}
public static async Task <GetObjectsResponse> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] FunctionExecutionContext req,
HttpRequest httpRequest,
ILogger log)
{
string body = await httpRequest.ReadAsStringAsync();
log.LogInformation($"HTTP POST Body: {body}");
log.LogInformation($"callingEntityKey: {JsonConvert.SerializeObject(req.CallerEntityProfile.Entity)}");
log.LogInformation($"currentEntity: {JsonConvert.SerializeObject(req.CallerEntityProfile)}");
var titleSettings = new PlayFabApiSettings
{
TitleId = req.TitleAuthenticationContext.Id,
//VerticalName = Settings.Cloud
DeveloperSecretKey = Settings.TitleSecret
};
var titleAuthContext = new PlayFabAuthenticationContext();
titleAuthContext.EntityToken = req.TitleAuthenticationContext.EntityToken;
var api = new PlayFabDataInstanceAPI(titleSettings, titleAuthContext);
var getObjectsRequest = new GetObjectsRequest
{
Entity = new DataModels.EntityKey
{
Id = req.CallerEntityProfile.Entity.Id,
Type = req.CallerEntityProfile.Entity.Type
}
};
Stopwatch sw = Stopwatch.StartNew();
PlayFabResult <GetObjectsResponse> getObjectsResponse = await api.GetObjectsAsync(getObjectsRequest);
sw.Stop();
if (getObjectsResponse.Error != null)
{
throw new InvalidOperationException($"GetObjectsAsync failed: {getObjectsResponse.Error.GenerateErrorReport()}");
}
else
{
log.LogInformation($"GetObjectsAsync succeeded in {sw.ElapsedMilliseconds}ms");
log.LogInformation($"GetObjectsAsync returned. ProfileVersion: {getObjectsResponse.Result.ProfileVersion}. Entity: {getObjectsResponse.Result.Entity.Id}/{getObjectsResponse.Result.Entity.Type}. NumObjects: {getObjectsResponse.Result.Objects.Count}.");
return(getObjectsResponse.Result);
}
}
/// <summary>
/// Invoke Pass through middleware
/// </summary>
/// <param name="context"></param>
/// <param name="next"></param>
/// <returns></returns>
public async Task Invoke(FunctionExecutionContext context, FunctionExecutionDelegate next)
{
context.Logger?.Log(LogLevel.Information, "Inside pass-through middleware");
context.InvocationResult = new HttpResponseData(HttpStatusCode.OK);
var response = context.InvocationResult as HttpResponseData;
response.Body += "\n Request stage - Pass-through middleware";
await next.Invoke(context);
ResponseStage(context);
}
public static async Task <EntityProfileBody> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] FunctionExecutionContext req,
HttpRequest httpRequest,
ILogger log)
{
string body = await httpRequest.ReadAsStringAsync();
log.LogInformation($"HTTP POST Body: {body}");
log.LogInformation($"callingEntityKey: {JsonConvert.SerializeObject(req.CallerEntityProfile.Entity)}");
log.LogInformation($"currentEntity: {JsonConvert.SerializeObject(req.CallerEntityProfile)}");
return(await Task.FromResult(req.CallerEntityProfile));
}
/// <summary>
/// Invoke Bypass middleware
/// </summary>
/// <param name="context"></param>
/// <param name="next"></param>
/// <returns></returns>
public async Task Invoke(FunctionExecutionContext context, FunctionExecutionDelegate next)
{
context.Logger?.Log(LogLevel.Information, "Inside Bypass middleware");
context.InvocationResult = new HttpResponseData(HttpStatusCode.Unauthorized);
var response = context.InvocationResult as HttpResponseData;
response.Body += "\n Request stage - Bypass middleware";
await Task.FromResult(Task.CompletedTask);
ResponseStage(context);
}
public static HttpResponseData ServerlessMiddleware([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "middleware")] HttpRequestData req,
FunctionExecutionContext executionContext)
{
var logger = executionContext.Logger;
logger.LogInformation("Executed serverless middleware function successfully");
var response = executionContext.InvocationResult as HttpResponseData;
response.Body += "\n <h1> Welcome to Serverless midlleware in azure functions ! </h1>";
//throw new Exception("testing exception handler middleware");
return(response);
}
private static async Task <List <MonsterMB> > GetTitleData(FunctionExecutionContext <dynamic> context)
{
var serverApi = new PlayFabServerInstanceAPI(context.ApiSettings, context.AuthenticationContext);
var result = await serverApi.GetTitleDataAsync(new PlayFab.ServerModels.GetTitleDataRequest()
{
Keys = new List <string>()
{
"MonsterMB"
},
});
var monsterList = JsonConvert.DeserializeObject <List <MonsterMB> >(result.Result.Data["MonsterMB"]);
return(monsterList);
}
public static async Task Run(
[QueueTrigger("identity", Connection = "AzureWebJobsStorage")] string msg,
ILogger log)
{
Stopwatch sw = Stopwatch.StartNew();
log.LogInformation($"{nameof(IdentityQueued)} C# queue trigger function processed a request; {msg}");
FunctionExecutionContext ctx = JsonConvert.DeserializeObject <FunctionExecutionContext>(msg);
// Simulate work
await Task.Delay(IdentityQueued.delayMilliseconds);
// Post results
await PostFunctionResultToPlayFab(ctx, ctx.FunctionArgument, sw.ElapsedMilliseconds, log);
}
public static HttpResponseData Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestData req,
FunctionExecutionContext executionContext)
{
var logger = executionContext.Logger;
logger.LogInformation("message logged");
var response = new HttpResponseData(HttpStatusCode.OK);
var headers = new Dictionary <string, string>();
headers.Add("Date", "Mon, 18 Jul 2016 16:06:00 GMT");
headers.Add("Content", "Content - Type: text / html; charset = utf - 8");
response.Headers = headers;
response.Body = "Welcome to .NET 5!!";
return(response);
}
// ユーザーにアイテムを付与する
// ユーザーにアイテムを付与するときは直接GrantItemsToUserを呼ぶんじゃなくてこれを呼ぶ
public static async Task <List <GrantedItemInstance> > GrantItemsToUserAsync(FunctionExecutionContext <dynamic> context, List <string> itemIdList)
{
var serverApi = new PlayFabServerInstanceAPI(context.ApiSettings, context.AuthenticationContext);
// アイテム付与前のインベントリ情報を保持しておく
var beforeUserInventory = await DataProcessor.GetUserInventoryAsync(context);
var result = await serverApi.GrantItemsToUserAsync(new GrantItemsToUserRequest()
{
PlayFabId = context.CallerEntityProfile.Lineage.MasterPlayerAccountId,
ItemIds = itemIdList
});
var grantedItemList = result.Result.ItemGrantResults;
// 付与したアイテムが未所持モンスターだった場合新規でモンスターデータを作成し追加
var monsterList = grantedItemList.Where(i => ItemUtil.GetItemType(i) == ItemType.Monster).ToList();
if (monsterList.Any())
{
var monsterMasterList = await DataProcessor.GetMasterAsyncOf <MonsterMB>(context);
var notHaveMonsterList = monsterList.Where(i => !beforeUserInventory.userMonsterList.Any(u => u.monsterId == ItemUtil.GetItemId(i))).ToList();
// 未所持のモンスターデータを作成する
foreach (var itemInstance in notHaveMonsterList)
{
var level = 1;
var monster = monsterMasterList.First(m => m.id == ItemUtil.GetItemId(itemInstance));
var status = MonsterUtil.GetMonsterStatus(monster, level);
var customData = new UserMonsterCustomData()
{
level = level,
exp = 0,
hp = status.hp,
attack = status.attack,
heal = status.heal,
grade = monster.initialGrade,
};
await DataProcessor.UpdateUserMonsterCustomDataAsync(context, itemInstance.ItemInstanceId, customData);
}
}
return(grantedItemList);
}
/// <summary>
/// スタミナを消費する
/// </summary>
public static async Task <int> ConsumeAsync(FunctionExecutionContext <dynamic> context, int consumeStamina)
{
var response = await CalculateAndSetCurrentStaminaAsync(context);
PMApiUtil.ErrorIf(response.currentStamina < consumeStamina, PMErrorCode.Unknown, "not enough stamina.", new Dictionary <string, object>()
{
{ "currentStamina", response.currentStamina },
{ "consumeStamina", consumeStamina },
});
var remainStamina = response.currentStamina - consumeStamina;
// スタミナ消費時は時間の更新は行わない
await DataProcessor.UpdateUserDataAsync(context, new Dictionary <UserDataKey, object>(){
{ UserDataKey.stamina, remainStamina }
});
return(remainStamina);
}
// マスタデータを取得する
public static async Task <List <T> > GetMasterAsyncOf <T>(FunctionExecutionContext <dynamic> context) where T : MasterBookBase
{
var serverApi = new PlayFabServerInstanceAPI(context.ApiSettings, context.AuthenticationContext);
var masterDataName = TextUtil.GetDescriptionAttribute <T>();
var result = await serverApi.GetTitleDataAsync(new GetTitleDataRequest()
{
Keys = new List <string>()
{
masterDataName
},
});
var masterDataJson = result.Result.Data[masterDataName];
var masterDataList = JsonConvert.DeserializeObject <List <T> >(masterDataJson);
return(masterDataList);
}
public static Task PostResults(FunctionExecutionContext ctx, string functionName, object functionResult, int executionTime, ILogger log)
{
var request = new PostFunctionResultForFunctionExecutionRequest
{
Entity = new EntityKey
{
Id = ctx.CallerEntityProfile.Entity.Id,
Type = ctx.CallerEntityProfile.Entity.Type,
},
FunctionResult = new ExecuteFunctionResult
{
ExecutionTimeMilliseconds = executionTime,
Error = null,
FunctionName = functionName,
FunctionResult = functionResult
}
};
// TODO: Replace this code with an SDK call once an SDK is published that supports PostFunctionResultForFunctionExecution
return(CallPostResultApi("PostFunctionResultForFunctionExecution", ctx.TitleAuthenticationContext, request, log));
}
public Task Invoke(FunctionExecutionContext context, FunctionExecutionDelegate next)
{
foreach (var param in context.FunctionDefinition.Parameters)
{
if (param.Type == typeof(FunctionExecutionContext))
{
context.Logger = new InvocationLogger(context.Invocation.InvocationId, _channel.Channel.Writer);
param.Value = context;
}
else
{
object?source = context.Invocation.ValueProvider.GetValue(param.Name);
var converterContext = new DefaultConverterContext(param, source, context);
if (TryConvert(converterContext, out object?target))
{
param.Value = target;
continue;
}
}
}
return(next(context));
}
public static void Run([CosmosDBTrigger(
databaseName: "%CosmosDb%",
collectionName: "%CosmosCollIn%",
ConnectionStringSetting = "CosmosConnection",
LeaseCollectionName = "leases",
CreateLeaseCollectionIfNotExists = true)] IReadOnlyList <MyDocument> input,
[CosmosDB(
databaseName: "%CosmosDb%",
collectionName: "%CosmosCollOut%",
ConnectionStringSetting = "CosmosConnection",
CreateIfNotExists = true)] OutputBinding <IEnumerable <object> > output,
FunctionExecutionContext context)
{
if (input != null && input.Count > 0)
{
foreach (var doc in input)
{
context.Logger.LogInformation($"id: {doc.Id}");
}
output.SetValue(input.Select(p => new { id = p.Id }));
}
}
/// <summary>
/// Invoke ExceptionHandler middleware
/// </summary>
/// <param name="context"></param>
/// <param name="next"></param>
/// <returns></returns>
public async Task Invoke(FunctionExecutionContext context, FunctionExecutionDelegate next)
{
context.Logger?.Log(LogLevel.Information, "Inside ExceptionHandler middleware");
context.InvocationResult = new HttpResponseData(HttpStatusCode.Unauthorized);
var response = context.InvocationResult as HttpResponseData;
response.Body += "\n Request stage - ExceptionHandler middleware";
try
{
await next.Invoke(context);
}
catch (Exception ex)
{
context.Logger?.Log(LogLevel.Error, "Catched unhandled exceptions: " + ex.Message);
await Task.CompletedTask;
}
ResponseStage(context);
}
