public static IHttpResponse GetAsync( IApplication application, ContentTypeResponse <Configuration[]> onFound) { var configs = application.ConfigurationTypes .SelectMany(configurationType => configurationType.Key.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy) .Where(member => member.ContainsCustomAttribute <ConfigKeyAttribute>()) .Select(member => member.GetCustomAttribute <ConfigKeyAttribute>().PairWithKey(member))) .Select( memberAttrKvp => { var member = memberAttrKvp.Key; var attr = memberAttrKvp.Value; return(new Configuration() { deploymentOverride = attr.DeploymentOverride, deploymentSecurityConcern = attr.DeploymentSecurityConcern, description = attr.Description, location = attr.Location, moreInfo = attr.MoreInfo, name = $"{member.DeclaringType.FullName}.{member.Name}", PrivateRepositoryOnly = attr.PrivateRepositoryOnly, type = member.GetMemberType(), value = (member.GetValue(null) as string).ConfigurationString( v => v, why => "Not defined"), }); }) .ToArray(); return(onFound(configs)); }
public async static Task <IHttpResponse> GetByIdAsync( [QueryParameter(Name = IntegrationIdPropertyName)] IRef <XIntegration> integrationRef, IAuthApplication application, SessionToken security, ContentTypeResponse <XIntegration> onFound, NotFoundResponse onNotFound, UnauthorizedResponse onUnauthorized) { if (!security.accountIdMaybe.HasValue) { return(onUnauthorized()); } var accountId = security.accountIdMaybe.Value; return(await await integrationRef.StorageGetAsync( integration => { return Auth.Method.ById(integration.Method, application, method => { integration.methodName = method.name; return onFound(integration); }, () => onNotFound()); }, () => onNotFound().AsTask())); }
public static Task <IHttpResponse> WebhookAsync( [Resource] object appInsightsCallback, ContentTypeResponse <EventsExceptionResult[]> onResults) { return(AppSettings.ApplicationInsights.ApplicationId.ConfigurationString( applicationId => { return AppSettings.ApplicationInsights.ClientSecret.ConfigurationString( async token => { // Authenticate with client secret (app key) var clientCred = new ApiKeyClientCredentials(token); // New up a client with credentials and AI application Id var client = new ApplicationInsightsDataClient(clientCred); client.AppId = applicationId; var exceptionEvents = await client.GetExceptionEventsAsync( timespan: TimeSpan.FromMinutes(240.0), top: 10, format: "application/json;odata.metadata=full"); var requestEvents = await client.GetRequestEventsAsync( timespan: TimeSpan.FromMinutes(30.0)); return onResults(exceptionEvents.Value.ToArray()); }); })); }
[Api.HttpGet] //(MatchAllBodyParameters = false)] public static async Task <HttpResponseMessage> GetAsync( EastFive.Api.SessionToken security, Api.Azure.AzureApplication application, UrlHelper urlHelper, ContentTypeResponse <Whoami> onFound) { async Task <string> GetName() { if (!security.accountIdMaybe.HasValue) { return(string.Empty); } return(await application.GetActorNameDetailsAsync(security.accountIdMaybe.Value, (first, last, email) => { return $"{first} {last} [{email}]"; }, () => string.Empty)); } var whoami = new Whoami() { session = security.sessionId.AsRef <Session>(), account = security.accountIdMaybe, name = await GetName(), }; return(onFound(whoami)); }
public static IHttpResponse FindAsync( //Security security, HttpApplication application, IHttpRequest request, IProvideUrl url, ContentTypeResponse <WebIdManifest> onFound, ContentTypeResponse <Api.Resources.Manifest> onContent, ViewFileResponse <Api.Resources.Manifest> onHtml) { if (request.GetAcceptTypes().Where(accept => accept.MediaType.ToLower().Contains("html")).Any()) { return(HtmlContent(application, request, url, onHtml)); } LocateControllers(); var endpoints = Manifest.lookup .Select( type => { var endpoint = url.GetWebId(type, "x-com.orderowl:ordering"); return(endpoint); }) .ToArray(); var manifest = new WebIdManifest() { Id = Guid.NewGuid(), Endpoints = endpoints, }; return(onFound(manifest)); }
public static async Task <IHttpResponse> SendToPostman( [QueryId] IRef <MonitoringRequest> monitoringRequestRef, [QueryParameter(Name = WhenPropertyName)] DateTime when, Security security, ContentTypeResponse <Meta.Postman.Resources.Collection.Item> onContent, NotFoundResponse onNotFound, GeneralFailureResponse onFailure) { return(await await monitoringRequestRef .StorageGetAsync( additionalProperties : (query) => query.Where(item => item.when == when), onFound : async itemToCreateOrUpdate => { var postmanItem = await itemToCreateOrUpdate.ConvertToPostmanItemAsync(); return await Collection.CreateOrUpdateMonitoringCollectionAsync( $"MonitoringRequest - {itemToCreateOrUpdate.when}", itemToCreateOrUpdate.url, collectionToModify => { return collectionToModify .AppendItem(postmanItem, folderName: itemToCreateOrUpdate.folderName); }, onCreatedOrUpdated: (discard) => onContent(postmanItem), onFailure: why => onFailure(why)); }, onDoesNotExists : () => onNotFound().AsTask())); }
private ContentResult GetContent <T>(T data, ContentTypeResponse contentType) { if (data == null) { return(Content("")); } try { if (Request.Headers["Accept"] != null && Request.Headers["Accept"].IndexOf("application/xml", StringComparison.Ordinal) > -1) { return(Content(GetXml(data), "application/xml")); } switch (contentType) { case ContentTypeResponse.JSON: return(Content(GetJson(data), "application/json")); case ContentTypeResponse.XML: return(Content(GetXml(data), "application/xml")); default: return(Content(string.Empty)); } } catch { return(GetContent(new { Message = data.ToString() }, contentType)); } }
public static IHttpResponse ListFlows( [OptionalQueryParameter] string flow, [OptionalQueryParameter] string collections, [OptionalQueryParameter] bool?preferJson, //Security security, IInvokeApplication invokeApplication, HttpApplication httpApp, IHttpRequest request, IProvideUrl url, ContentTypeResponse <string []> onSuccess, NotFoundResponse onNotFound) { var lookups = httpApp .GetResources() .ToArray(); var manifest = new EastFive.Api.Resources.Manifest(lookups, httpApp); var flows = manifest.Routes .SelectMany(route => route.Methods) .SelectMany(method => method.MethodPoco .GetAttributesInterface <IDefineFlow>(multiple: true) .Select(attr => (method, attr))) .GroupBy(methodAndFlow => methodAndFlow.attr.FlowName) .Where(grp => grp.Key.HasBlackSpace()) .Select(grp => grp.Key) .ToArray(); return(onSuccess(flows)); }
public static Task <IHttpResponse> QueryByIdAsync( [QueryId(Name = IdPropertyName)] IRef <Profile> profileRef, ContentTypeResponse <Profile> onFound, NotFoundResponse onNotFound) { return(profileRef.HttpGetAsync(onFound, onNotFound)); }
[Api.HttpGet] //(MatchAllBodyParameters = false)] public static async Task <IHttpResponse> GetAsync( EastFive.Api.SessionToken security, IHttpRequest request, IAuthApplication application, [WorkflowVariable("Session", SessionPropertyName)] [WorkflowVariable2("Account", AccountPropertyName)] ContentTypeResponse <Whoami> onFound) { async Task <string> GetName() { if (!security.accountIdMaybe.HasValue) { return(string.Empty); } return(await application.GetActorNameDetailsAsync(security.accountIdMaybe.Value, (first, last, email) => { return $"{first} {last} [{email}]"; }, () => string.Empty)); } request.TryParseJwt(out System.IdentityModel.Tokens.Jwt.JwtSecurityToken securityToken); var whoami = new Whoami() { session = security.sessionId.AsRef <Session>(), account = security.accountIdMaybe, name = await GetName(), securityToken = securityToken, }; return(onFound(whoami)); }
public static async Task <IHttpResponse> SendCollectionToPostman( [WorkflowParameterFromVariable(Value = EastFive.Azure.Workflows.MonitoringFlow.Variables.FolderName)] [QueryParameter(Name = FolderNamePropertyName)] string folderName, [OptionalQueryParameter(Name = WhenPropertyName)] DateTime?whenMaybe, IHttpRequest httpRequest, Security security, ContentTypeResponse <CollectionSummary> onPosted, GeneralFailureResponse onFailure) { //var postmanItems = await when // .StorageGetBy((MonitoringRequest mr) => mr.when) // .Where(mr => String.Equals(mr.folderName, folderName, StringComparison.CurrentCultureIgnoreCase)) // .Select(mr => mr.ConvertToPostmanItemAsync()) // .Await() // .ToArrayAsync(); var postmanItems = await folderName .StorageGetBy((MonitoringRequest mr) => mr.folderName) .Where(mr => whenMaybe.HasValue? whenMaybe.EqualToDay(mr.when) : true) .Select(mr => mr.ConvertToPostmanItemAsync()) .Await() .ToArrayAsync(); return(await Collection.CreateOrUpdateMonitoringCollectionAsync( $"MonitoringRequest - {folderName}", httpRequest.RequestUri, collectionToModify => { return collectionToModify .AppendItems(postmanItems, folderName: folderName); }, onCreatedOrUpdated : (collection) => onPosted(collection), why => onFailure(why))); }
public static async Task <IHttpResponse> GetAsync( [QueryParameter(Name = SessionIdPropertyName, CheckFileName = true)] IRef <Session> sessionRef, EastFive.Api.SessionTokenMaybe security, IAuthApplication application, ContentTypeResponse <Session> onFound, NotFoundResponse onNotFound, UnauthorizedResponse onUnauthorized, ConfigurationFailureResponse onConfigurationFailure) { if (!IsAnonSessionAllowed()) { if (security.sessionId != sessionRef.id) { return(onUnauthorized()); } } return(await await sessionRef.StorageGetAsync( (session) => { return Web.Configuration.Settings.GetUri( EastFive.Security.AppSettings.TokenScope, scope => { return Web.Configuration.Settings.GetDouble(Security.SessionServer.Configuration.AppSettings.TokenExpirationInMinutes, (tokenExpirationInMinutes) => { return GetClaimsAsync(application, session.authorization, (claims, accountIdMaybe, authorized) => { session.account = accountIdMaybe; session.authorized = authorized; return Api.Auth.JwtTools.CreateToken(session.id, scope, TimeSpan.FromMinutes(tokenExpirationInMinutes), claims, (tokenNew) => { session.token = tokenNew; return onFound(session); }, (missingConfig) => onConfigurationFailure("Missing", missingConfig), (configName, issue) => onConfigurationFailure(configName, issue)); }, (why) => onNotFound()); }, (why) => onConfigurationFailure("Missing", why).AsTask()); }, (why) => onConfigurationFailure("Missing", why).AsTask()); }, () => onNotFound().AsTask())); bool IsAnonSessionAllowed() { var appType = application.GetType(); if (!appType.TryGetAttributeInterface <IConfigureAuthorization>(out IConfigureAuthorization authConfig)) { return(false); } return(authConfig.IsAnonymousSessionAllowed); } }
public static async Task <IHttpResponse> PropertyInformation( [QueryParameter(Name = "table")] string tableName, [QueryParameter(Name = "property")] string propertyName, IApplication httpApp, ContentTypeResponse <PropertyLookupInformation[]> onFound, NotFoundResponse onNotFound, BadRequestResponse onPropertyDoesNotSupportFindBy) { return(await StorageTable.DiscoverStorageResources(httpApp.GetType()) .Where(table => table.name == tableName) .First( (storageTable, next) => { return storageTable.properties .Where(prop => prop.name == propertyName) .First( async(prop, next2) => { if (!prop.member.ContainsAttributeInterface <IProvideFindBy>()) { return onPropertyDoesNotSupportFindBy(); } var findBy = prop.member.GetAttributeInterface <IProvideFindBy>(); var information = await findBy.GetInfoAsync(prop.member); return onFound(information); }, () => onNotFound().AsTask()); }, () => onNotFound().AsTask())); }
public static IHttpResponse All( HttpApplication httpApp, ContentTypeResponse <StorageTable[]> onFound) { var tables = DiscoverStorageResources(httpApp.GetType()).ToArray(); return(onFound(tables)); }
public static IHttpResponse ManifestContent( HttpApplication httpApp, System.Net.Http.HttpRequestMessage request, IProvideUrl url, ContentTypeResponse <Api.Resources.Manifest> onContent) { var lookups = httpApp.GetResources(); var manifest = new EastFive.Api.Resources.Manifest(lookups, httpApp); return(onContent(manifest)); }
public static IHttpResponse FindAsync( IApplication app, ContentTypeResponse <Route[]> onContent) { var lookups = app.Resources.Select(res => res.type).ToArray(); var manifest = new Manifest(lookups, app as HttpApplication); return(onContent(manifest.Routes)); }
public static Task <IHttpResponse> GetByIdAsync( [QueryId] IRef <InvocationMessage> invocationMessageRef, ContentTypeResponse <InvocationMessage> onFound, NotFoundResponse onNotFound) { return(invocationMessageRef.StorageGetAsync( (InvocationMessage ent) => onFound(ent), () => onNotFound())); }
public static Task <HttpResponseMessage> QueryByIdAsync( [QueryId] IRef <Method> methodRef, Api.Azure.AzureApplication application, ContentTypeResponse <Method> onFound, NotFoundResponse onNotFound) { return(ById(methodRef, application, method => onFound(method), () => onNotFound())); }
public static async Task <IHttpResponse> LoadAsync( RequestMessage <TeamsNotification> teamsNotificationsStorage, ContentTypeResponse <TeamsNotification[]> onFound) { teamsNotifications = await teamsNotificationsStorage .StorageGet() .ToArrayAsync(); return(onFound(teamsNotifications)); }
public static async Task <IHttpResponse> ClearPostmanAsync( [WorkflowParameterFromVariable( Value = EastFive.Azure.Workflows.MonitoringFlow.Variables.FolderName, Disabled = true)] [OptionalQueryParameter(Name = TeamsNotification.CollectionPropertyName)] string collectionFolder, Security security, ContentTypeResponse <CollectionSummary> onCleared, NotFoundResponse onNotFound, GeneralFailureResponse onFailure) { return(await EastFive.Api.AppSettings.Postman.MonitoringCollectionId.ConfigurationString( async collectionId => { return await await EastFive.Api.Meta.Postman.Resources.Collection.Collection.GetAsync(collectionId, collection => { var collectionCleared = collectionFolder.HasBlackSpace() ? MutateCollectionWithFolderName(collectionFolder) : MutateCollection(); return collectionCleared.UpdateAsync <IHttpResponse>( (updatedCollection) => { return onCleared(updatedCollection); }, onFailure: (why) => onFailure(why)); Collection MutateCollection() { return new Collection { info = collection.info, item = new Item[] { }, variable = collection.variable, }; } Collection MutateCollectionWithFolderName(string folderName) { collection.item = collection.item .NullToEmpty() .Where(item => !collectionFolder.Equals(item.name)) .ToArray(); return collection; } }, () => onNotFound().AsTask(), onFailure: why => onFailure(why).AsTask()); }, onUnspecified : (why) => onFailure("Postman Monitoring not setup").AsTask())); }
public static Task <IHttpResponse> GetByIdAsync( [QueryId] IRef <MonitoringRequest> monitoringRequestRef, [QueryParameter(Name = WhenPropertyName)] DateTime when, Security security, ContentTypeResponse <MonitoringRequest> onContent, NotFoundResponse onNotFound) { return(monitoringRequestRef .StorageGetAsync( additionalProperties: (query) => query.Where(item => item.when == when), onFound: mr => onContent(mr), onDoesNotExists: () => onNotFound())); }
public static Task <IHttpResponse> UpdateAsync( [WorkflowParameter(Value = "{{TeamsNotification}}")] [UpdateId] IRef <TeamsNotification> teamsNotificationRef, [MutateResource] MutateResource <TeamsNotification> updated, ContentTypeResponse <TeamsNotification> onUpdated, NotFoundResponse onNotFound, UnauthorizedResponse onUnauthorized) { return(teamsNotificationRef .HttpPatchAsync(updated, onUpdated, onNotFound)); }
public static async Task <IHttpResponse> ReplayAsync( [QueryId(Name = AuthorizationIdPropertyName)] IRef <Authorization> authorizationRef, Api.Azure.AzureApplication application, IInvokeApplication endpoints, IHttpRequest request, ContentTypeResponse <Session> onReplayed, NotFoundResponse onNotFound, ForbiddenResponse onAuthorizationFailed, ServiceUnavailableResponse onServericeUnavailable, ForbiddenResponse onInvalidMethod, GeneralConflictResponse onFailure) { return(await await authorizationRef.StorageGetAsync( async (authorization) => { var methodRef = authorization.Method; return await await Auth.Method.ById(methodRef, application, async(method) => { var paramsUpdated = authorization.parameters .Append(authorizationRef.id.ToString().PairWithKey("state")) .ToDictionary(); //var authorizationRequestManager = application.AuthorizationRequestManager; return await await Redirection.AuthenticationAsync( method, paramsUpdated, application, request, endpoints, request.RequestUri, authorizationRef.Optional(), async(redirect, accountIdMaybe, modifier) => { var sessionRef = Ref <Session> .SecureRef(); var session = new Session() { sessionId = sessionRef, account = accountIdMaybe, authorization = authorizationRef.Optional(), }; var responseCreated = await Session.CreateAsync(sessionRef, authorizationRef.Optional(), session, application, (sessionCreated, contentType) => { var response = onReplayed(sessionCreated, contentType: contentType); response.SetLocation(redirect); return response; }, onAlreadyExists: default,
[Api.HttpPatch] //(MatchAllBodyParameters = false)] public async static Task <IHttpResponse> UpdateAsync( [Property(Name = IntegrationIdPropertyName)] IRef <XIntegration> integrationRef, [Property(Name = AuthorizationPropertyName)] IRef <Authorization> authorizationRef, Api.Azure.AzureApplication application, EastFive.Api.SessionToken security, ContentTypeResponse <XIntegration> onUpdated, NotFoundResponse onNotFound, ForbiddenResponse onForbidden, ReferencedDocumentDoesNotExistsResponse <Authorization> onAuthorizationDoesNotExist, UnauthorizedResponse onUnauthorized) { return(await integrationRef.StorageUpdateAsync( async (integration, saveAsync) => { var accountId = integration.accountId; if (!await application.CanAdministerCredentialAsync(accountId, security)) { return onUnauthorized(); } return await await authorizationRef.StorageGetAsync( async authorization => { if (!await application.ShouldAuthorizeIntegrationAsync(integration, authorization)) { return onForbidden().AddReason("Authorization is not accessable to this account."); } integration.Method = authorization.Method; // method is used in the .mappingId integration.authorization = authorizationRef.Optional(); integration.methodName = await Auth.Method.ById(authorization.Method, application, method => method.name, () => string.Empty); await saveAsync(integration); return onUpdated(integration); }, () => onAuthorizationDoesNotExist().AsTask()); }, () => onNotFound(), onModificationFailures: StorageConstraintUniqueAttribute.ModificationFailure( (XIntegration x) => x.authorization, () => { // TODO: Check if mapping is to this integration and reply already created. return onForbidden().AddReason("Authorization is already in use."); }).AsArray())); }
public static Task <IHttpResponse> UpdateByIdAsync( [UpdateId] IRef <InvocationMessage> invocationMessageRef, [Property(Name = ExecutionLimitPropertyName)] int executionLimit, // [Resource]InvocationMessage invocationMessage, ContentTypeResponse <InvocationMessage> onFound, NotFoundResponse onNotFound) { return(invocationMessageRef.StorageUpdateAsync( async(invocationMessage, saveAsync) => { invocationMessage.executionLimit = executionLimit; await saveAsync(invocationMessage); return onFound(invocationMessage); }, () => onNotFound())); }
public static async Task <HttpResponseMessage> UpdateAsync( [UpdateId(Name = AuthenticationPropertyName)] IRef <Authentication> authenticationRef, [OptionalQueryParameter(Name = "hold")] bool?hold, [Property(Name = UserIdentificationPropertyName)] string userIdentification, [Property(Name = PasswordPropertyName)] string password, HttpRequestMessage httpRequest, RedirectResponse onUpdated, ContentTypeResponse <string> onHeldup, NotFoundResponse onNotFound, GeneralConflictResponse onInvalidPassword) { return(await await authenticationRef.StorageUpdateAsync( (authentication, saveAsync) => { return userIdentification .MD5HashGuid() .AsRef <Account>() .StorageGetAsync( async account => { var passwordHash = Account.GeneratePasswordHash(userIdentification, password); if (passwordHash != account.password) { return onInvalidPassword("Incorrect username or password."); } authentication.userIdentification = userIdentification; authentication.authenticated = DateTime.UtcNow; await saveAsync(authentication); //var related = request // .Related<Login.Redirection>(); //var whered = related // .Where(redir => redir.state == authentication.state); //var authorizationUrl = whered // // .ById(authentication.st) // .RenderLocation(); var authorizationUrl = new Uri(httpRequest.RequestUri, $"/api/LoginRedirection?state={authentication.authenticationRef.id}&token={authentication.state}"); if (hold.HasValue && hold.Value) { return onHeldup(authorizationUrl.AbsoluteUri); } return onUpdated(authorizationUrl); }, () => onInvalidPassword("Incorrect username or password.").AsTask()); }, () => onNotFound().AsTask())); }
[Api.HttpPatch] //(MatchAllBodyParameters = false)] public async static Task <HttpResponseMessage> UpdateAsync( [Property(Name = IntegrationIdPropertyName)] IRef <Integration> integrationRef, [Property(Name = AuthorizationPropertyName)] IRef <Authorization> authorizationRef, Api.Azure.AzureApplication application, EastFive.Api.SessionToken security, ContentTypeResponse <Integration> onUpdated, NotFoundResponse onNotFound, NotModifiedResponse onNotModified, ForbiddenResponse onForbidden, ReferencedDocumentDoesNotExistsResponse <Authorization> onAuthenticationDoesNotExist, UnauthorizedResponse onUnauthorized) { return(await integrationRef.StorageUpdateAsync( async (integration, saveAsync) => { var accountId = integration.accountId; if (!await application.CanAdministerCredentialAsync(accountId, security)) { return onUnauthorized(); } return await await authorizationRef.StorageGetAsync( async authorization => { // TODO? This // var accountIdDidMatch = await await authorization.ParseCredentailParameters( integration.Method = authorization.Method; // method is used in the .mappingId integration.authorization = authorizationRef.Optional(); return await await SaveAuthorizationLookupAsync(integration.integrationRef, authorization.authorizationRef, async() => { await saveAsync(integration); return await SaveAccountLookupAsync(accountId, integration, () => onUpdated(integration)); }, () => { // TODO: Check if mapping is to this integration and reply already created. return onForbidden().AddReason("Authorization is already in use.").AsTask(); }); }, () => { return onNotModified().AsTask(); }); }, () => onNotFound())); }
public static async Task <HttpResponseMessage> GetAsync( [QueryParameter(Name = SessionIdPropertyName, CheckFileName = true)] IRef <Session> sessionRef, EastFive.Api.SessionToken security, Api.Azure.AzureApplication application, UrlHelper urlHelper, ContentTypeResponse <Session> onFound, NotFoundResponse onNotFound, UnauthorizedResponse onUnauthorized, ConfigurationFailureResponse onConfigurationFailure) { if (security.sessionId != sessionRef.id) { return(onUnauthorized()); } return(await await sessionRef.StorageGetAsync( (session) => { return Web.Configuration.Settings.GetUri( EastFive.Security.AppSettings.TokenScope, scope => { return Web.Configuration.Settings.GetDouble(Security.SessionServer.Configuration.AppSettings.TokenExpirationInMinutes, (tokenExpirationInMinutes) => { return GetClaimsAsync(application, session.authorization, (claims, accountIdMaybe, authorized) => { session.account = accountIdMaybe; session.authorized = authorized; return BlackBarLabs.Security.Tokens.JwtTools.CreateToken(session.id, scope, TimeSpan.FromMinutes(tokenExpirationInMinutes), claims, (tokenNew) => { session.token = tokenNew; return onFound(session); }, (missingConfig) => onConfigurationFailure("Missing", missingConfig), (configName, issue) => onConfigurationFailure(configName, issue)); }, (why) => onNotFound()); }, (why) => onConfigurationFailure("Missing", why).AsTask()); }, (why) => onConfigurationFailure("Missing", why).AsTask()); }, () => onNotFound().AsTask())); }
public static IHttpResponse OptionsAsync( IApplication application, ContentTypeResponse <Claim[]> onFound) { var claims = application.GetType() .GetAttributesInterface <IDeclareClaim>(true, true) .Select( attr => new Claim { name = attr.ClaimName, type = attr.ClaimType, value = string.Empty, }) .ToArray(); return(onFound(claims)); }
public static async Task <IHttpResponse> Information( [QueryParameter(Name = NamePropertyName)] string name, HttpApplication httpApp, ContentTypeResponse <TableInformation> onFound, NotFoundResponse onNotFound) { return(await DiscoverStorageResources(httpApp.GetType()) .Where(table => table.name == name) .First( async(storageTable, next) => { var information = await storageTable.type .StorageTableInformationAsync(storageTable.cloudTable); return onFound(information); }, () => onNotFound().AsTask())); }