public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req,
                                                           ILogger log)
        {
            IEnumerable <Venue> results  = null;
            HttpResponseMessage response = req.CreateResponse(HttpStatusCode.InternalServerError);

            try {
                // Get passed argument (from query if present, if from JSON posted in body if not)
                log.LogInformation($"GetVenuesByPRN starting");

                // NOTE: This is a dirty fix as a workaround to make sure this function works with both "POST" and "GET" properly.
                // This is needed to fix a bug with this when using "GET" to keep Dev CD app working whilst API-M changes are going in.
                // TODO: Refactor this eventually.
                var PRN = string.Empty;

                try
                {
                    dynamic args = await(dynamic) req.Content.ReadAsAsync <object>();
                    PRN = req.RequestUri.ParseQueryString()["prn"]?.ToString() ?? args?.PRN;
                }
                catch (Exception e)
                {
                    PRN = req.RequestUri.ParseQueryString()["prn"]?.ToString();
                }

                if (PRN == null)
                {
                    //throw new FunctionException("Missing PRN argument", "GetVenuesByPRN", null);
                    response = req.CreateResponse(HttpStatusCode.BadRequest, ResponseHelper.ErrorMessage("Missing PRN argument"));
                }
                else if (!int.TryParse(PRN, out int parsed))
                {
                    //throw new FunctionException("Invalid PRN argument", "GetVenuesByPRN", null);
                    response = req.CreateResponse(HttpStatusCode.BadRequest, ResponseHelper.ErrorMessage("Invalid PRN argument"));
                }
                else
                {
                    // Get data
                    results = new VenueStorage().GetByPRN(parsed, log);
                    log.LogInformation($"GetVenuesByPRN returning { results.LongCount() } venues");

                    // Return results
                    response         = req.CreateResponse(results.Any() ? HttpStatusCode.OK : HttpStatusCode.NoContent);
                    response.Content = new StringContent(JsonConvert.SerializeObject(results), Encoding.UTF8, "application/json");
                }
            } catch (Exception ex) {
                throw ex;
            }
            return(response);
        }
        public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req,
                                                           ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed UpdateLocationIds request");

            // Store venue location ids in Cosmos DB collection
            Task <IEnumerable <Venue> > task = new VenueStorage().UpdateLocationIdsAsync(new LogHelper(log));

            task.Wait();

            // Return results
            log.LogInformation($"UpdateLocationIds returning results");
            HttpResponseMessage response = req.CreateResponse(HttpStatusCode.OK);

            response.Content = new StringContent(JsonConvert.SerializeObject(task.Result), Encoding.UTF8, "application/json");
            return(response);
        }
Exemple #3
0
        public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req,
                                                           ILogger log)
        {
            IEnumerable <Venue> results  = null;
            HttpResponseMessage response = req.CreateResponse(HttpStatusCode.InternalServerError);

            try {
                // Get passed argument (from query if present, if from JSON posted in body if not)
                log.LogInformation($"GetVenuesByPRNAndName starting");
                //dynamic args = await (dynamic)req.Content.ReadAsAsync<object>();
                string PRN  = req.RequestUri.ParseQueryString()["prn"];  //?.ToString() ?? args?.PRN;
                string name = req.RequestUri.ParseQueryString()["name"]; //?.ToString() ?? args?.Name;

                if (PRN == null)
                {
                    //throw new FunctionException("Missing PRN argument", "GetVenuesByPRNAndName", null);
                    response = req.CreateResponse(HttpStatusCode.BadRequest, ResponseHelper.ErrorMessage("Missing PRN argument"));
                }
                else if (name == null)
                {
                    //throw new FunctionException("Missing ProviderName argument", "GetVenuesByPRNAndName", null);
                    response = req.CreateResponse(HttpStatusCode.BadRequest, ResponseHelper.ErrorMessage("Missing Name argument"));
                }
                else if (!int.TryParse(PRN, out int parsed))
                {
                    //throw new FunctionException("Invalid PRN argument", "GetVenuesByPRNAndName", null);
                    response = req.CreateResponse(HttpStatusCode.BadRequest, ResponseHelper.ErrorMessage("Invalid PRN argument"));
                }
                else
                {
                    // Get data
                    results = new VenueStorage().GetByPRN(parsed, log)
                              .Where(p => p.VENUE_NAME.ToLower().StartsWith(name.ToLower()) && p.VENUE_NAME.Length == name.Length);


                    // Return results
                    response         = req.CreateResponse(results.Any() ? HttpStatusCode.OK : HttpStatusCode.NoContent);
                    response.Content = new StringContent(JsonConvert.SerializeObject(results), Encoding.UTF8, "application/json");
                }
            } catch (Exception ex) {
                throw ex;
            }
            return(response);
        }
        public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req,
                                                           ILogger log)
        {
            HttpResponseMessage response = req.CreateResponse(HttpStatusCode.InternalServerError);

            try {
                log.LogInformation("GetAllVenues starting");
                Task <IEnumerable <Venue> > task = new VenueStorage().GetAllAsync(new LogHelper(log));

                // Return results
                log.LogInformation($"GetAllVenues returning results");
                response = req.CreateResponse(HttpStatusCode.OK);
                task.Wait();
                response.Content = new StringContent(JsonConvert.SerializeObject(task.Result), Encoding.UTF8, "application/json");
            } catch (Exception ex) {
                throw ex;
            }
            return(response);
        }
        public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req,
                                                           ILogger log)
        {
            IEnumerable <Venue> results  = null;
            HttpResponseMessage response = req.CreateResponse(HttpStatusCode.InternalServerError);

            try
            {
                // Get passed argument (from query if present, if from JSON posted in body if not)
                log.LogInformation($"GetVenuesByUKPRNAndPostCode starting");
                string UKPRN    = req.RequestUri.ParseQueryString()["UKPRN"];    //?.ToString() ?? (await (dynamic)req.Content.ReadAsAsync<object>())?.UKPRN;
                string PostCode = req.RequestUri.ParseQueryString()["PostCode"]; //?.ToString() ?? (await (dynamic)req.Content.ReadAsAsync<object>())?.PostCode;

                if (UKPRN == null)
                {
                    response = req.CreateResponse(HttpStatusCode.BadRequest, ResponseHelper.ErrorMessage("Missing UKPRN argument"));
                }
                else if (PostCode == null)
                {
                    response = req.CreateResponse(HttpStatusCode.BadRequest, ResponseHelper.ErrorMessage("Missing PostCode argument"));
                }
                else if (!int.TryParse(UKPRN, out int parsedUKPRN))
                {
                    response = req.CreateResponse(HttpStatusCode.BadRequest, ResponseHelper.ErrorMessage("Invalid UKPRN argument"));
                }
                else
                {
                    PostCode = PostCode.Replace(" ", string.Empty).Trim().ToLower();
                    // Get data
                    results = new VenueStorage().GetByPRN(parsedUKPRN, log)
                              .Where(p => p.POSTCODE.Replace(" ", string.Empty).Trim().ToLower() == PostCode);

                    // Return results
                    response         = req.CreateResponse(results.Any() ? HttpStatusCode.OK : HttpStatusCode.NoContent);
                    response.Content = new StringContent(JsonConvert.SerializeObject(results), Encoding.UTF8, "application/json");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(response);
        }
        public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req,
                                                           ILogger log)
        {
            Venue v = null;
            HttpResponseMessage response = req.CreateResponse(HttpStatusCode.InternalServerError);

            try
            {
                // Get passed argument (from query if present, if from JSON posted in body if not)
                log.LogInformation($"GetVenueByVenueId starting");
                string venueId = req.RequestUri.ParseQueryString()["venueId"]?.ToString()
                                 ?? (await(dynamic) req.Content.ReadAsAsync <object>())?.venueId;
                if (string.IsNullOrEmpty(venueId))
                {
                    log.LogInformation($"GetVenueByVenueId has missing venueId argument");
                    response = req.CreateResponse(HttpStatusCode.BadRequest, ResponseHelper.ErrorMessage("Missing venueId argument"));
                }
                else if (!int.TryParse(venueId, out int parsedVenueId))
                {
                    log.LogInformation($"GetVenueByVenueId has invalid venueId argument");
                    response = req.CreateResponse(HttpStatusCode.BadRequest, ResponseHelper.ErrorMessage("Invalid venueId argument"));
                }
                else
                {
                    // Get data
                    v = new VenueStorage().GetByVenueId(parsedVenueId, log);
                    log.LogInformation($"GetVenueByVenueId returning { v?.VENUE_NAME ?? "no results"}");

                    // Return results
                    response         = req.CreateResponse(v == null ? HttpStatusCode.NoContent : HttpStatusCode.OK);
                    response.Content = new StringContent(JsonConvert.SerializeObject(v), Encoding.UTF8, "application/json");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(response);
        }
        public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req,
                                                           ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed SyncVenues request");
            IEnumerable <Venue> venues = new VenueStorage().Sync(new LogHelper(log), out int count);

            //task.Wait();

            // Store venues in Cosmos DB collection
            log.LogInformation($"Inserting {count} providers to CosmosDB providers collection");
            Task <bool> task = new VenueStorage().InsertDocsAsync(venues, new LogHelper(log));

            task.Wait();
            //return req.CreateResponse<string>(HttpStatusCode.OK, JsonConvert.SerializeObject(output));

            // Return results
            log.LogInformation($"SyncVenues returning results");
            HttpResponseMessage response = req.CreateResponse(HttpStatusCode.OK);

            response.Content = new StringContent(JsonConvert.SerializeObject(venues), Encoding.UTF8, "application/json");
            return(response);
        }