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 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).");
}
}
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 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 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,
[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);
}
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);
}
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);
}
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);
}
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);
}));
}
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 = 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, DeleteSideBarSectionRequest, IDESettingsStateHarness>(req, signalRMessages, log,
async (harness, reqData, actReq) =>
{
log.LogInformation($"Deleting SideBar Section: {reqData.Section}");
var stateDetails = StateUtils.LoadStateDetails(req);
await harness.DeleteSideBarSection(appDev, appMgr, stateDetails.EnterpriseAPIKey, reqData.Section);
return Status.Success;
}));
}
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-lookup}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
return(await stateBlob.WithStateHarness <UserManagementState, ValidateSubscriptionRequest, UserManagementStateHarness>(req, signalRMessages, log,
async (harness, reqData) =>
{
log.LogInformation($"Executing ValidateSubscription Action.");
var stateDetails = StateUtils.LoadStateDetails(req);
var status = await harness.ValidateSubscription(engMgr, idMgr, stateDetails.EnterpriseLookup, stateDetails.Username, reqData.SubscriptionID);
return status;
}));
}
public virtual async Task <Status> Run([HttpTrigger] HttpRequest req, ILogger log,
[SignalR(HubName = InfrastructureManagementState.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 <InfrastructureManagementState, RefreshRequest, InfrastructureManagementStateHarness>(req, signalRMessages, log,
async (harness, refreshReq, actReq) =>
{
log.LogInformation($"Refresh");
var stateDetails = StateUtils.LoadStateDetails(req);
await harness.GetFathymDashboardURL(secMgr, stateDetails.EnterpriseLookup);
return Status.Success;
}));
}
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-lookup}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
return(await stateBlob.WithStateHarness <ToursManagementState, RecordStepRequest, ToursManagementStateHarness>(req, signalRMessages, log,
async (harness, reqData, actReq) =>
{
log.LogInformation($"Recording step for {reqData.TourLookup}: {reqData.CurrentStep}");
var stateDetails = StateUtils.LoadStateDetails(req);
await harness.Reset(idMgr, stateDetails.EnterpriseLookup, stateDetails.Username);
return Status.Success;
}));
}
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)
{
return(await stateBlob.WithStateHarness <IoTEnsembleSharedState, ToggleDetailsPaneRequest, IoTEnsembleSharedStateHarness>(req, signalRMessages, log,
async (harness, refreshReq, actReq) =>
{
log.LogInformation($"ToggleDetailsPane");
var stateDetails = StateUtils.LoadStateDetails(req);
await harness.ToggleDetailsPane(secMgr);
return Status.Success;
}, withLock : false));
}
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(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;
}));
}
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)
{
return(await stateBlob.WithStateHarness <IoTEnsembleAdminState, UpdateEnterprisesSyncRequest, IoTEnsembleAdminStateHarness>(req, signalRMessages, log,
async (harness, dataReq, actReq) =>
{
log.LogInformation($"UpdateEnterprisesSync");
var stateDetails = StateUtils.LoadStateDetails(req);
await harness.UpdateEnterprisesSync(entMgr, appIoTArch, idMgr, stateDetails.EnterpriseLookup, dataReq.Page, dataReq.PageSize);
return Status.Success;
}, withLock : false));
}
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, RemoveSelectedLayerRequest, UsersStateHarness>(req, signalRMessages, log,
async (harness, reqData, actReq) =>
{
log.LogInformation($"LoadLocationsFromJSON");
var stateDetails = StateUtils.LoadStateDetails(req);
//await harness.LoadCuratedLocationsIntoDB("*****@*****.**", json, new Guid("4704a25b-049b-49a9-90b0-2551b40045c3"));
return Status.Success;
}));
}
public virtual async Task <Status> Run([HttpTrigger] HttpRequest req, ILogger log,
[SignalR(HubName = LimitedTrialState.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 <LimitedDataFlowManagementState, ToggleIsCreatingRequest, LimitedDataFlowManagementStateHarness>(req, signalRMessages, log,
async (harness, reqData, actReq) =>
{
log.LogInformation($"Refresh");
var stateDetails = StateUtils.LoadStateDetails(req);
await harness.ToggleIsCreating();
return Status.Success;
}));
}
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-lookup}/{headers.lcu-hub-name}/{headers.x-ms-client-principal-id}/{headers.lcu-state-key}", FileAccess.ReadWrite)] CloudBlockBlob stateBlob)
{
return(await stateBlob.WithStateHarness <DataAppsManagementState, DeleteDataDAFAppRequest, DataAppsManagementStateHarness>(req, signalRMessages, log,
async (harness, reqData, actReq) =>
{
var stateDetails = StateUtils.LoadStateDetails(req);
log.LogInformation($"Deleting Data DAF App: {reqData.ToJSON()}");
await harness.DeleteDAFApp(appDev, appMgr, stateDetails.EnterpriseLookup, reqData.ApplicationID, reqData.Lookups);
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 <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 = GuidedTourState.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 <JourneysManagementState, MoreDetailsRequest, JourneysManagementStateHarness>(req, signalRMessages, log,
async (harness, reqData, actReq) =>
{
log.LogInformation($"Setting Active Tour to: {reqData.JourneyLookup}");
var stateDetails = StateUtils.LoadStateDetails(req);
await harness.MoreDetails(reqData.JourneyLookup);
return Status.Success;
}));
}
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] 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)
{
return(await stateBlob.WithStateHarness <UserManagementState, dynamic, UserManagementStateHarness>(req, signalRMessages, log,
async (harness, reqData) =>
{
log.LogInformation($"Executing RequestUserAccess Action.");
var stateDetails = StateUtils.LoadStateDetails(req);
var status = await harness.RequestAuthorization(secMgr, appMgr, idMgr, stateDetails.Username, stateDetails.EnterpriseAPIKey, stateDetails.Host);
return status;
}));
}
