private IList <EndpointProbe> GetEndpointProbeList(TestResources resources, TestConfig config) { BlockingCollection <EndpointProbe> list = new BlockingCollection <EndpointProbe>(); var test = Defaults.HttpMethods.Intersect(config.TestMethods, StringComparer.OrdinalIgnoreCase); Parallel.ForEach( resources.SwaggerDocument.Paths, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, path => { if (CheckIfPathAllowed(path.Key, config)) { Parallel.ForEach( Defaults.HttpMethods.Intersect(config.TestMethods, StringComparer.OrdinalIgnoreCase), new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, method => { CosmoOperation methodInfo = path.Value .GetType() .GetProperty(method) .GetValue(path.Value) as CosmoOperation; if (methodInfo != null) { dynamic payload = GetEndpointPayload(path.Key, method, resources.PayloadDictionary); list.Add( new EndpointProbe { Endpoint = path.Key, Method = new HttpMethod(method), AuthToken = GetEndpointAuthToken(path.Key, resources.AuthDictionary), Payload = payload, PayloadMIMEType = GetPayloadType(path.Key, methodInfo.Consumes, payload), ExpectedResponseMIMEType = GetResponseType(path.Key, methodInfo.Produces) } ); } }); } }); list.CompleteAdding(); return(list.ToList()); }
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log) { log.Info("GetAccess message received"); try { log.Info("Reading body message"); UserCredentials userCredentials = JsonConvert.DeserializeObject <UserCredentials>(await req.Content.ReadAsStringAsync()); if (userCredentials == null || string.IsNullOrWhiteSpace(userCredentials.Login) || string.IsNullOrWhiteSpace(userCredentials.Password)) { return(req.CreateResponse(HttpStatusCode.Unauthorized, "Missing credentials")); } log.Info("Getting User"); CosmoOperation cosmoOperation = await CosmosDBOperations.QueryDBAsync(new CosmoOperation() { Collection = Environment.GetEnvironmentVariable(Config.COSMOS_COLLECTION), Database = Environment.GetEnvironmentVariable(Config.COSMOS_DATABASE), Payload = $"SELECT * FROM c WHERE c.type = 'User' AND c.login = '******' AND c.password = '******'" }); if (cosmoOperation.Results == null || cosmoOperation.Results.Length == 0) { return(req.CreateResponse(HttpStatusCode.Unauthorized, "Invalid credentials")); } if (cosmoOperation.Results.Length > 1) { throw new Exception("More than one user has found"); } Dictionary <string, object> user = JsonConvert.DeserializeObject <Dictionary <string, object> >(cosmoOperation.Results[0].ToString()); string token = JwtTokenCreator.CreateJwtToken( (string)user["name"], (string)user["id"], new Dictionary <string, string>() { { "user", JsonConvert.SerializeObject(user) } }); return(await Task.Factory.StartNew(() => req.CreateResponse(HttpStatusCode.OK, token))); } catch (Exception ex) { log.Error("Erro: ", ex); return(req.CreateResponse(HttpStatusCode.BadRequest, ex.Message)); } }
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log) { log.Info("InsertIntentContent message received"); try { //Utils.ValidateAuthorizationHeader(req.Headers?.Authorization); string json = await req.Content.ReadAsStringAsync(); if (string.IsNullOrWhiteSpace(json)) { throw new Exception("Missing body"); } IntentContent intentContent = JsonConvert.DeserializeObject <IntentContent>(json); log.Info("Creating intentContent Id"); if (string.IsNullOrWhiteSpace(intentContent.id)) { intentContent.id = Guid.NewGuid().ToString(); } log.Info("Creating intentContent Partition key"); if (string.IsNullOrWhiteSpace(intentContent.partitionKey)) { intentContent.partitionKey = Utils.CreatePartitionKey(intentContent.type.Replace(" ", ""), intentContent.id); } CosmoOperation cosmoOperation = await CosmosDBOperations.UpsertDocumentAsync(new CosmoOperation() { Collection = Environment.GetEnvironmentVariable(Config.COSMOS_COLLECTION), Database = Environment.GetEnvironmentVariable(Config.COSMOS_DATABASE), Payload = intentContent }); return(req.CreateResponse(HttpStatusCode.OK, cosmoOperation.Results as object)); } catch (UnauthorizedAccessException ex) { log.Error("Unauthorized"); return(req.CreateResponse(HttpStatusCode.Unauthorized, ex.Message)); } catch (Exception ex) { log.Error($"Error: {ex.Message} ", ex); return(req.CreateResponse(HttpStatusCode.BadRequest, ex.Message)); } }
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log) { log.Info("GetIntentAnswer message received"); try { string intentName = req.GetQueryNameValuePairs() .FirstOrDefault(q => string.Compare(q.Key, "intent", true) == 0) .Value; string profile = req.GetQueryNameValuePairs() .FirstOrDefault(q => string.Compare(q.Key, "profile", true) == 0) .Value; string entity = req.GetQueryNameValuePairs() .FirstOrDefault(q => string.Compare(q.Key, "entity", true) == 0) .Value; string whereCondition = "WHERE d.type = 'IntentContent'"; if (!string.IsNullOrWhiteSpace(intentName)) { whereCondition = $"{whereCondition} AND d.intent = '{intentName}'"; } if (!string.IsNullOrWhiteSpace(entity)) { whereCondition = $"{whereCondition} AND e['value'] = '{entity}'"; } if (!string.IsNullOrWhiteSpace(profile)) { whereCondition = $"{whereCondition} AND p.id = '{profile}'"; } CosmoOperation cosmoOperation = await CosmosDBOperations.QueryDBAsync(new CosmoOperation() { Collection = Environment.GetEnvironmentVariable(Config.COSMOS_COLLECTION), Database = Environment.GetEnvironmentVariable(Config.COSMOS_DATABASE), Payload = $"SELECT d as document FROM Data d JOIN e IN d.entities JOIN p IN e.profiles {whereCondition}" }); return(req.CreateResponse(HttpStatusCode.OK, cosmoOperation.Results as object)); } catch (Exception ex) { log.Error("Error: ", ex); return(req.CreateResponse(HttpStatusCode.BadRequest, ex.Message)); } }
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log) { log.Info("InsertIntentContent message received"); try { string body = await req.Content.ReadAsStringAsync(); if (string.IsNullOrWhiteSpace(body)) { throw new Exception("Missing body"); } Dictionary <string, string> data = JsonConvert.DeserializeObject <Dictionary <string, string> >(body); if (!data.TryGetValue("id", out string id) || string.IsNullOrWhiteSpace(id)) { throw new Exception("Missing Id"); } if (!data.TryGetValue("partitionKey", out string partitionKey) || string.IsNullOrWhiteSpace(partitionKey)) { throw new Exception("Missing partitionKey"); } log.Info($"Deleting document with Id: {id}\tparitionKey: {partitionKey}"); CosmoOperation cosmoOperation = await CosmosDBOperations.DeleteDocumentAsync(new CosmoOperation() { Collection = Environment.GetEnvironmentVariable(Config.COSMOS_COLLECTION), Database = Environment.GetEnvironmentVariable(Config.COSMOS_DATABASE), Payload = new { id, partitionKey } }); return(req.CreateResponse(HttpStatusCode.OK, cosmoOperation.Results as object)); } catch (UnauthorizedAccessException ex) { log.Error("Unauthorized"); return(req.CreateResponse(HttpStatusCode.Unauthorized, ex.Message)); } catch (Exception ex) { log.Error($"Error: {ex.Message} ", ex); return(req.CreateResponse(HttpStatusCode.BadRequest, ex.Message)); } }
public ConcurrentDictionary <string, ConcurrentDictionary <string, dynamic> > GeneratePayloadDictionary( TestConfig config, SwaggerDocument swaggerDoc) { ConcurrentDictionary <string, ConcurrentDictionary <string, dynamic> > dict = new ConcurrentDictionary <string, ConcurrentDictionary <string, dynamic> >(Environment.ProcessorCount, 20); if (!config.DataFiles.Any()) { return(dict); } if (!File.Exists(config.DataFiles.First())) { Errors.Add( new SetupError { Severity = ErrorLevel.Fatal, Type = InitialiserErrorType.PayloadDictionarySetup, Message = InitialiserErrorMessages.PayloadDictionary_NoDataFile .Replace("[[File]]", config.DataFiles.First()) }); return(dict); } IList <EndpointData> endpointData = new List <EndpointData>(); try { using (StreamReader file = File.OpenText(config.DataFiles.First())) { JsonSerializer serializer = new JsonSerializer(); endpointData = (IList <EndpointData>)serializer .Deserialize(file, typeof(IList <EndpointData>)); } } catch (Exception ex) { Errors.Add( new SetupError { Severity = ErrorLevel.Fatal, Type = InitialiserErrorType.PayloadDictionarySetup, Message = InitialiserErrorMessages.PayloadDictionary_DataFileParseError .Replace("[[File]]", config.DataFiles.First()) .Replace("[[Message]]", ex.Message) }); return(dict); } Parallel.ForEach( swaggerDoc.Paths, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, path => { Parallel.ForEach( Defaults.HttpMethods, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, method => { CosmoOperation methodInfo = path.Value .GetType() .GetProperty(method) .GetValue(path.Value) as CosmoOperation; if (methodInfo != null) { ConcurrentDictionary <string, dynamic> methodDataDictionary = new ConcurrentDictionary <string, dynamic>(Environment.ProcessorCount, 2); dynamic methodData = endpointData.Where(x => x.URL == path.Key && x.Method.ToLower() == method.ToLower()) .FirstOrDefault()?.Data; methodDataDictionary.TryAdd(method, methodData); dict.AddOrUpdate( path.Key, methodDataDictionary, ((key, val) => val.TryAdd(method, methodData))); } } ); }); return(dict); }