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; })); }