public virtual async Task <Status> Run([HttpTrigger(AuthorizationLevel.Admin)] HttpRequest req, ILogger log,
[SignalR(HubName = AmblOnState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[Blob("state-api/{headers.lcu-ent-lookup}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob,
[Blob("state-api/{headers.lcu-ent-lookup}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/locations", FileAccess.ReadWrite)] CloudBlockBlob locationStateBlob)
{
var status = await stateBlob.WithStateHarness <UsersState, EditTopListRequest, UsersStateHarness>(req, signalRMessages, log,
async (harness, reqData, actReq) =>
{
log.LogInformation($"EditTopList");
var stateDetails = StateUtils.LoadStateDetails(req);
var username = stateDetails.Username;
await harness.EditTopList(amblGraph, stateDetails.Username, stateDetails.EnterpriseLookup, reqData.TopList);
var locationStateDetails = StateUtils.LoadStateDetails(req);
locationStateDetails.StateKey = "locations";
var exActReq = await req.LoadBody <ExecuteActionRequest>();
return(await locationStateBlob.WithStateHarness <LocationsState, EditTopListRequest, LocationsStateHarness>(locationStateDetails, exActReq, signalRMessages, log,
async(newharness, reqData, actReq) =>
{
log.LogInformation($"EditTopList Location Refresh");
await newharness.RefreshLocations(amblGraph, locationStateDetails.EnterpriseLookup, username);
return Status.Success;
}));
});
return(status);
}
public static async Task <ConnectToStateResponse> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequest req, ILogger log,
ClaimsPrincipal claimsPrincipal, //[LCUStateDetails]StateDetails stateDetails,
[SignalR(HubName = LimitedTrialState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[SignalR(HubName = LimitedTrialState.HUB_NAME)] IAsyncCollector <SignalRGroupAction> signalRGroupActions,
[Blob("state-api/{headers.lcu-ent-lookup}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
var stateDetails = StateUtils.LoadStateDetails(req);
if (stateDetails.StateKey == "data-apps")
{
return(await signalRMessages.ConnectToState <LimitedDataAppsManagementState>(req, log, claimsPrincipal, stateBlob, signalRGroupActions));
}
else if (stateDetails.StateKey == "data-flow")
{
return(await signalRMessages.ConnectToState <LimitedDataFlowManagementState>(req, log, claimsPrincipal, stateBlob, signalRGroupActions));
}
else if (stateDetails.StateKey == "journeys")
{
return(await signalRMessages.ConnectToState <LimitedJourneysManagementState>(req, log, claimsPrincipal, stateBlob, signalRGroupActions));
}
else
{
throw new Exception("A valid State Key must be provided (data-apps, data-flow).");
}
}
public virtual async Task <HttpResponseMessage> Run([HttpTrigger] HttpRequest req,
[SignalR(HubName = IoTEnsembleState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[Blob("state-api/{headers.lcu-ent-lookup}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
var queried = new ListAllDeviceNamesResponse()
{
Status = Status.GeneralError
};
var status = await stateBlob.WithStateHarness <IoTEnsembleSharedState, ListAllDeviceNamesRequest, IoTEnsembleSharedStateHarness>(req, signalRMessages, log,
async (harness, dataReq, actReq) =>
{
log.LogInformation($"Running a ListAllDeviceNames Query: {dataReq}");
var stateDetails = StateUtils.LoadStateDetails(req);
if (dataReq == null)
{
dataReq = new ListAllDeviceNamesRequest();
}
queried.DeviceNames = await harness.ListAllDeviceNames(appIoTArch, dataReq.ChildEntLookup, dataReq.Filter);
queried.Status = Status.Success;
return(queried.Status);
}, preventStatusException : true, withLock : false);
var statusCode = status ? HttpStatusCode.OK : HttpStatusCode.InternalServerError;
return(new HttpResponseMessage(statusCode)
{
Content = new StringContent(queried.ToJSON(), Encoding.UTF8, "application/json")
});
}
public static async Task <ConnectToStateResponse> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequest req, ILogger log,
ClaimsPrincipal claimsPrincipal, //[LCUStateDetails]StateDetails stateDetails,
[SignalR(HubName = AmblOnState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[SignalR(HubName = AmblOnState.HUB_NAME)] IAsyncCollector <SignalRGroupAction> signalRGroupActions,
[Blob("state-api/{headers.lcu-ent-lookup}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
var stateDetails = StateUtils.LoadStateDetails(req);
if (stateDetails.StateKey == "users")
{
return(await signalRMessages.ConnectToState <UsersState>(req, log, claimsPrincipal, stateBlob, signalRGroupActions));
}
else if (stateDetails.StateKey == "itineraries")
{
return(await signalRMessages.ConnectToState <ItinerariesState>(req, log, claimsPrincipal, stateBlob, signalRGroupActions));
}
else if (stateDetails.StateKey == "locations")
{
return(await signalRMessages.ConnectToState <LocationsState>(req, log, claimsPrincipal, stateBlob, signalRGroupActions));
}
else
{
throw new Exception("A valid State Key must be provided (amblon, itineraries, locations).");
}
}
public virtual async Task <HttpResponseMessage> Run([HttpTrigger] HttpRequest req,
[SignalR(HubName = IoTEnsembleState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[Blob("state-api/{headers.lcu-ent-lookup}/iotensemble/{headers.x-ms-client-principal-id}/shared", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
List <IoTEnsembleTelemetryPayload> payloads = null;
req.Headers.Add("lcu-hub-name", "iotensemble");
req.Headers.Add("lcu-state-key", "shared");
var status = await stateBlob.WithStateHarness <IoTEnsembleSharedState, GetDevicesTelemetrySyncRequest, IoTEnsembleSharedStateHarness>(req, signalRMessages, log,
async (harness, enrollReq, actReq) =>
{
log.LogInformation($"GetDevicesTelemetrySync");
var stateDetails = StateUtils.LoadStateDetails(req);
payloads = harness.State.Telemetry?.Payloads?.OrderByDescending(p => p.Timestamp).ToList() ?? new List <IoTEnsembleTelemetryPayload>();
return(Status.Success);
}, withLock : false);
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(
content: payloads.ToJSON(),
encoding: System.Text.Encoding.UTF8,
mediaType: "application/json")
});
}
public virtual async Task <Status> Run([HttpTrigger] HttpRequest req,
[SignalR(HubName = IoTEnsembleState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[Blob("state-api/{headers.lcu-ent-lookup}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
var status = await stateBlob.WithStateHarness <IoTEnsembleSharedState, SendCloudMessageRequest, IoTEnsembleSharedStateHarness>(req, signalRMessages, log,
async (harness, dataReq, actReq) =>
{
log.LogInformation($"Setting Loading device telemetry from UpdateTelemetrySync...");
harness.State.Telemetry.Loading = true;
return(Status.Success);
}, preventStatusException : true, withLock : false);
if (status)
{
status = await stateBlob.WithStateHarness <IoTEnsembleSharedState, SendCloudMessageRequest, IoTEnsembleSharedStateHarness>(req, signalRMessages, log,
async (harness, dataReq, actReq) =>
{
log.LogInformation($"SendCloudMessage");
var stateDetails = StateUtils.LoadStateDetails(req);
await harness.SendCloudMessage(appIoTArch, dataReq.DeviceName, dataReq.Message);
harness.State.Telemetry.Loading = false;
return(Status.Success);
}, withLock : false);
}
return(status);
}
private void StartWaitingStateIfPossible(Entity weapon)
{
if (InputManager.CheckAction(ShotActions.SHOT))
{
StateUtils.SwitchEntityState <ShaftWaitingStateComponent>(weapon, this.weaponStates);
}
}
public virtual async Task <Status> Run([HttpTrigger] HttpRequest req, ILogger log,
[SignalR(HubName = GuidedTourState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[Blob("state-api/{headers.lcu-ent-api-key}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
var stateDetails = StateUtils.LoadStateDetails(req);
if (stateDetails.StateKey == "journeys")
{
return(await stateBlob.WithStateHarness <JourneysManagementState, RefreshRequest, JourneysManagementStateHarness>(req, signalRMessages, log,
async (harness, refreshReq, actReq) =>
{
log.LogInformation($"Refreshing Journeys state");
return await refreshJourneys(harness, log, stateDetails);
}));
}
else if (stateDetails.StateKey == "tours")
{
return(await stateBlob.WithStateHarness <ToursManagementState, RefreshRequest, ToursManagementStateHarness>(req, signalRMessages, log,
async (harness, refreshReq, actReq) =>
{
log.LogInformation($"Refreshing Tours state");
return await refreshTours(harness, log, stateDetails);
}));
}
else
{
throw new Exception("A valid State Key must be provided (journeys, tours).");
}
}
public async Task <IActionResult> Index(OAuthTesterViewModel oAuthTesterViewModel)
{
var state = StateUtils.Generate();
var oAuthClientConfiguration = oAuthTesterViewModel.OAuthClientConfiguration;
var oAuthFlows = _oAuthFlowsFactory.CreateOAuthFlows(oAuthClientConfiguration.Name);
var response = await oAuthFlows.RunFlow(oAuthClientConfiguration, state, oAuthTesterViewModel.Username, oAuthTesterViewModel.Password, ResponseModes.FormPost);
switch (response)
{
case OAuthRedirect oAuthRedirect:
TempData[Common.State] = oAuthRedirect.State;
TempData[Common.CodeVerifier] = oAuthRedirect.CodeVerifier;
TempData[TempDataNames.OAuthTesterConfigurationName] = oAuthTesterViewModel.ConfigurationName;
return(Redirect(oAuthRedirect.Uri));
case AccessTokenResponse accessTokenResponse:
oAuthTesterViewModel.AccessTokenResponse = Utils.Mappers.OAuthMapper.Map(accessTokenResponse);
break;
case DeviceCodeResponse deviceCodeResponse:
TempData[TempDataNames.OAuthTesterConfigurationName] = oAuthTesterViewModel.ConfigurationName;
TempData.Write(TempDataNames.DeviceCodeResponse, deviceCodeResponse);
return(RedirectToAction(nameof(PingDeviceToken)));
case ErrorResponse errorResponse:
return(ProcessOAuthClientErrorResponse(errorResponse));
}
return(View(oAuthTesterViewModel));
}
protected virtual async Task <Status> handleAdminRevoke(HttpRequest req, ILogger log,
IAsyncCollector <SignalRMessage> signalRMessages, CloudBlockBlob stateBlob)
{
var status = await stateBlob.WithStateHarness <IoTEnsembleAdminState, UpdateTelemetrySyncRequest, IoTEnsembleAdminStateHarness>(req, signalRMessages, log,
async (harness, dataReq, actReq) =>
{
log.LogInformation($"Setting Loading device telemetry from UpdateTelemetrySync...");
harness.State.Loading = true;
return(Status.Success);
}, preventStatusException : true, withLock : false);
if (status)
{
status = await stateBlob.WithStateHarness <IoTEnsembleAdminState, RevokeDeviceEnrollmentRequest, IoTEnsembleAdminStateHarness>(req, signalRMessages, log,
async (harness, enrollReq, actReq) =>
{
log.LogInformation($"RevokeDeviceEnrollment");
var stateDetails = StateUtils.LoadStateDetails(req);
await harness.RevokeDeviceEnrollment(appIoTArch, entMgr, idMgr, stateDetails.EnterpriseLookup, enrollReq.DeviceID);
harness.State.Loading = false;
return(Status.Success);
}, withLock : false);
}
return(status);
}
public IOAuthClientResponse CreateAuthorizationCodeWithPkceRedirect(IEnumerable <string> scopes = null, string state = null)
{
var codeVerifier = PkceUtils.GenerateCodeVerifier();
var queryStringParams = new Dictionary <string, string>
{
{ Common.ResponseType, ResponseTypes.Code },
{ Common.ClientId, _configuration.ClientId },
{ Common.RedirectUri, _configuration.RedirectUri },
{ Common.State, state ?? StateUtils.Generate() },
{ Common.CodeChallenge, PkceUtils.GenerateCodeChallenge(codeVerifier) },
{ Common.CodeChallengeMethod, CodeChallengeMethodTypes.S256 }
}.AddScopes(scopes);
var redirectUri = QueryHelpers.AddQueryString(_configuration.AuthorizeEndpoint, queryStringParams);
var response = new OAuthRedirect
{
Uri = redirectUri,
State = state,
CodeVerifier = codeVerifier
};
return(response);
}
public virtual async Task <Status> Run([HttpTrigger] HttpRequest req, ILogger log,
[SignalR(HubName = UserManagementState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[Blob("state-api/{headers.lcu-ent-api-key}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
var stateDetails = StateUtils.LoadStateDetails(req);
if (stateDetails.StateKey == "billing")
{
return(await stateBlob.WithStateHarness <UserBillingState, RefreshBillingRequest, UserBillingStateHarness>(req, signalRMessages, log,
async (harness, refreshReq, actReq) =>
{
log.LogInformation($"Refreshing user billing state");
return await refreshUserBilling(harness, log, stateDetails, refreshReq);
}));
}
else
{
return(await stateBlob.WithStateHarness <UserManagementState, RefreshUserRequest, UserManagementStateHarness>(req, signalRMessages, log,
async (harness, refreshReq, actReq) =>
{
log.LogInformation($"Refreshing user management state");
return await refreshUserManagement(harness, log, stateDetails, refreshReq);
}));
}
}
public virtual async Task <Status> Run([HttpTrigger] HttpRequest req, ILogger log,
[SignalR(HubName = LowCodeUnitSharedState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[Blob("state-api/{headers.lcu-ent-lookup}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
var status = await stateBlob.WithStateHarness <LowCodeUnitSharedState, EnrollDeviceRequest, LowCodeUnitSharedStateHarness>(req, signalRMessages, log,
async (harness, dataReq, actReq) =>
{
log.LogInformation($"Setting Loading device telemetry from UpdateTelemetrySync...");
harness.State.HomePage.Loading = true;
return(Status.Success);
}, preventStatusException : true);
if (status)
{
status = await stateBlob.WithStateHarness <LowCodeUnitSharedState, EnrollDeviceRequest, LowCodeUnitSharedStateHarness>(req, signalRMessages, log,
async (harness, enrollReq, actReq) =>
{
log.LogInformation($"EnrollDevice");
var stateDetails = StateUtils.LoadStateDetails(req);
await harness.EnrollDevice(appArch);
harness.State.HomePage.Loading = false;
return(Status.Success);
});
}
return(status);
}
private void MakeQuickShot(Entity weapon)
{
StateUtils.SwitchEntityState <ShaftIdleStateComponent>(weapon, this.weaponStates);
if (weapon.HasComponent <ShootableComponent>())
{
base.ScheduleEvent <BeforeShotEvent>(weapon);
base.ScheduleEvent <ShotPrepareEvent>(weapon);
}
}
private void MakeAimingShot(Entity weapon, Vector3 workingDir)
{
StateUtils.SwitchEntityState <ShaftAimingWorkFinishStateComponent>(weapon, this.weaponStates);
if (weapon.HasComponent <ShootableComponent>())
{
base.ScheduleEvent <BeforeShotEvent>(weapon);
base.ScheduleEvent(new ShaftAimingShotPrepareEvent(workingDir), weapon);
}
}
private void AddOrChangeWeaponBlockedComponent(Entity weapon, RaycastHit hitInfo)
{
WeaponBlockedComponent component = !weapon.HasComponent <WeaponBlockedComponent>() ? ((WeaponBlockedComponent)weapon.CreateNewComponentInstance(typeof(WeaponBlockedComponent))) : weapon.GetComponent <WeaponBlockedComponent>();
component.BlockPoint = PhysicsUtil.GetPulledHitPoint(hitInfo);
component.BlockGameObject = hitInfo.collider.gameObject;
component.BlockNormal = hitInfo.normal;
StateUtils.SwitchEntityState(weapon, component, this.weaponStates);
}
protected virtual async Task <StateDetails> handleInput(LCUStateDetailsAttribute attr, ValueBindingContext valBinding)
{
var context = (HttpContext)valBinding.FunctionContext.InstanceServices.GetService(typeof(HttpContext));
// var context = httpContextAccessor.HttpContext;
var stateDetails = StateUtils.LoadStateDetails(context.Request, context.User);
return(stateDetails);
}
private bool CheckHandleWeaponIntersectionStatus(Entity weapon)
{
bool flag = weapon.HasComponent <WeaponUndergroundComponent>();
if (flag)
{
StateUtils.SwitchEntityState <ShaftIdleStateComponent>(weapon, this.weaponStates);
}
return(flag);
}
public void CheckWorkFinishState(TimeUpdateEvent evt, ShaftAimingWorkFinishWeaponControllerNode weapon)
{
if (weapon.shaftAimingWorkFinishState.FinishTimer < weapon.shaftStateConfig.FinishToIdleTransitionTimeSec)
{
weapon.shaftAimingWorkFinishState.FinishTimer += evt.DeltaTime;
}
else
{
StateUtils.SwitchEntityState <ShaftIdleStateComponent>(weapon.Entity, this.weaponStates);
}
}
public override void EnterStructIncr(LatteParser.StructIncrContext context)
{
var objectType = new ExpressionTypeVisitor().GetFieldType(context.expr(), context.ID().GetText(), context.start.Line);
if (!objectType.Equals(new LatteParser.TIntContext()))
{
StateUtils.InterruptWithMessage(
context.start.Line,
context.ID().Symbol.Column,
ErrorMessages.DecrFieldOnlyOnInt(objectType.GetText(), context.ID().GetText()));
}
}
public override void EnterStructAss(LatteParser.StructAssContext context)
{
var expressionVisitor = new ExpressionTypeVisitor();
var objectType = expressionVisitor.GetFieldType(context.expr()[0], context.ID().GetText(), context.start.Line);
var exprType = new ExpressionTypeVisitor().Visit(context.expr()[1]);
if (!objectType.Equals(exprType) && !IsTypeParent(exprType, objectType))
{
StateUtils.InterruptWithMessage(
context.start.Line,
context.ID().Symbol.Column,
ErrorMessages.FieldExprTypesMismatch(objectType.GetText(), context.ID().GetText()));
}
}
public virtual async Task <Status> Run([HttpTrigger] HttpRequest req, ILogger log,
[SignalR(HubName = FathymForecastState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[Blob("state-api/{headers.lcu-ent-api-key}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
return(await stateBlob.WithStateHarness <FathymForecastState, CreateAPISubscriptionRequest, FathymForecastStateHarness>(req, signalRMessages, log,
async (harness, refreshReq, actReq) =>
{
log.LogInformation($"CreateAPISubscription");
var stateDetails = StateUtils.LoadStateDetails(req);
return await harness.CreateAPISubscription(entArch, stateDetails.EnterpriseAPIKey, stateDetails.Username);
}));
}
private void StartWorkActivationStateIfPossible(ShaftWaitingWeaponControllerNode weapon, float dt)
{
if (!weapon.Entity.HasComponent <WeaponUndergroundComponent>())
{
if (weapon.shaftWaitingState.WaitingTimer < weapon.shaftStateConfig.WaitingToActivationTransitionTimeSec)
{
weapon.shaftWaitingState.WaitingTimer += dt;
}
else if (weapon.weaponEnergy.Energy >= 1f)
{
StateUtils.SwitchEntityState <ShaftAimingWorkActivationStateComponent>(weapon.Entity, this.weaponStates);
}
}
}
public virtual async Task <Status> Run([HttpTrigger] HttpRequest req,
[SignalR(HubName = IoTEnsembleState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[Blob("state-api/{headers.lcu-ent-lookup}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
var stateDetails = StateUtils.LoadStateDetails(req);
if (stateDetails.StateKey.StartsWith("admin"))
{
return(await handleAdminRevoke(req, log, signalRMessages, stateBlob));
}
else
{
return(await handleSharedRevoke(req, log, signalRMessages, stateBlob));
}
}
public virtual async Task <Status> Run([HttpTrigger] HttpRequest req, ILogger log,
[SignalR(HubName = ApplicationManagementState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[Blob("state-api/{headers.lcu-ent-api-key}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
return(await stateBlob.WithStateHarness <ApplicationManagementState, SaveDataAppRequest, ApplicationManagementStateHarness>(req, signalRMessages, log,
async (harness, reqData, actReq) =>
{
var stateDetails = StateUtils.LoadStateDetails(req);
log.LogInformation($"Setting Active App: {reqData.App.Name}");
await harness.SetActiveApp(appMgr, stateDetails.EnterpriseAPIKey, reqData.App);
return Status.Success;
}));
}
public virtual async Task <Status> Run([HttpTrigger(AuthorizationLevel.Admin)] HttpRequest req, ILogger log,
[SignalR(HubName = AmblOnState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[Blob("state-api/{headers.lcu-ent-lookup}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
return(await stateBlob.WithStateHarness <ItinerariesState, AddItineraryRequest, ItinerariesStateHarness>(req, signalRMessages, log,
async (harness, reqData, actReq) =>
{
log.LogInformation($"AddItinerary");
var stateDetails = StateUtils.LoadStateDetails(req);
await harness.AddItinerary(amblGraph, stateDetails.Username, stateDetails.EnterpriseLookup, reqData.Itinerary);
return Status.Success;
}));
}
public virtual async Task <Status> Run([HttpTrigger(AuthorizationLevel.Admin)] HttpRequest req, ILogger log,
[SignalR(HubName = UsersState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[Blob("state-api/{headers.lcu-ent-api-key}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
return(await stateBlob.WithStateHarness <UsersState, AddPhotoRequest, UsersStateHarness>(req, signalRMessages, log,
async (harness, reqData, actReq) =>
{
log.LogInformation($"AddPhoto");
var stateDetails = StateUtils.LoadStateDetails(req);
await harness.AddPhoto(entMgr, appMgr, amblGraph, stateDetails.Username, stateDetails.EnterpriseAPIKey, stateDetails.ApplicationID, reqData.Photo, reqData.AlbumID, reqData.LocationID);
return Status.Success;
}));
}
public virtual async Task <Status> Run([HttpTrigger] HttpRequest req, ILogger log,
[SignalR(HubName = DataFlowManagementState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[Blob("state-api/{headers.lcu-ent-api-key}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
return(await stateBlob.WithStateHarness <DataFlowManagementState, AddIoTInfrastructureRequest, DataFlowManagementStateHarness>(req, signalRMessages, log,
async (harness, reqData, actReq) =>
{
log.LogInformation($"Adding IoT Infrastructure");
var stateDetails = StateUtils.LoadStateDetails(req);
await harness.AddIoTInfrastructure(devOpsArch, stateDetails.EnterpriseAPIKey, stateDetails.Username);
return Status.Success;
}));
}
public virtual async Task <Status> Run([HttpTrigger] HttpRequest req, ILogger log,
[SignalR(HubName = IDEManagementState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[Blob("state-api/{headers.lcu-ent-api-key}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
return(await stateBlob.WithStateHarness <IDESettingsState, ToggleAddNewActivityRequest, IDESettingsStateHarness>(req, signalRMessages, log,
async (harness, reqData, actReq) =>
{
log.LogInformation($"ToggleAddNewActivity");
var stateDetails = StateUtils.LoadStateDetails(req);
await harness.ToggleAddNew(AddNewTypes.Activity);
return Status.Success;
}));
}
public virtual async Task <Status> Run([HttpTrigger(AuthorizationLevel.Admin)] HttpRequest req, ILogger log,
[SignalR(HubName = AmblOnState.HUB_NAME)] IAsyncCollector <SignalRMessage> signalRMessages,
[Blob("state-api/{headers.lcu-ent-lookup}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
return(await stateBlob.WithStateHarness <UsersState, GlobalSearchRequest, UsersStateHarness>(req, signalRMessages, log,
async (harness, reqData, actReq) =>
{
log.LogInformation($"GlobalSearch");
var stateDetails = StateUtils.LoadStateDetails(req);
//await harness.GlobalSearch(reqData.SearchTerm);
return Status.Success;
}));
}
