コード例 #1
0
 public IActionResult ItineraryWebApp([FromBody] Token token_object)
 {
     if (UserManagementService.ValidateUserToken(token_object.access_token))
     {
         Itinerary            userItinerary        = JsonConvert.DeserializeObject <Itinerary>(token_object.Object_To_Server);
         ItineraryRiskWrapper itineraryRiskWrapper = ItineraryService.ProcessItinerary(userItinerary, token_object.access_token);
         return(Ok(JsonConvert.SerializeObject(itineraryRiskWrapper.TotalItineraryRisk)));
     }
     else
     {
         return(Unauthorized("Invalid Token"));
     }
 }
コード例 #2
0
        public async Task <ItineraryRisk> ProcessItinerary(Itinerary userItinerary)
        {
            if (retryCount == 5)
            {
                return(null);
            }
            else
            {
                bool retry = false;
                using (Anoroc_Client = new HttpClient(clientHandler))
                {
                    if (UserItineraries == null)
                    {
                        UserItineraries = new List <ItineraryRisk>();
                    }

                    Anoroc_Client.Timeout = TimeSpan.FromSeconds(30);

                    Uri   Anoroc_Uri   = new Uri(Constants.AnorocURI + "Itinerary/ProcessItinerary");
                    Token token_object = new Token();

                    token_object.access_token = (string)Xamarin.Forms.Application.Current.Properties["TOKEN"];

                    token_object.Object_To_Server = JsonConvert.SerializeObject(new ItineraryWrap(userItinerary));

                    var data = JsonConvert.SerializeObject(token_object);

                    var content = new StringContent(data, Encoding.UTF8, "application/json");
                    content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");

                    HttpResponseMessage responseMessage;

                    try
                    {
                        responseMessage = await Anoroc_Client.PostAsync(Anoroc_Uri, content);

                        ItineraryRiskWrapper itineraryRisk = null;
                        if (responseMessage != null)
                        {
                            if (responseMessage.IsSuccessStatusCode)
                            {
                                var json = await responseMessage.Content.ReadAsStringAsync();

                                itineraryRisk = JsonConvert.DeserializeObject <ItineraryRiskWrapper>(json);
                                var convertedItinerary = itineraryRisk.toItineraryRisk();
                                SaveItineraryRisk(convertedItinerary);
                                UserItineraries.Add(convertedItinerary);
                            }
                            else if (responseMessage.StatusCode == System.Net.HttpStatusCode.Unauthorized)
                            {
                                retry = true;
                            }

                            if (!retry)
                            {
                                return(itineraryRisk.toItineraryRisk());
                            }
                            else
                            {
                                retryCount++;
                                return(await ProcessItinerary(userItinerary));
                            }
                        }
                        else
                        {
                            return(null);
                        }
                    }
                    catch (Exception e) when(e is TaskCanceledException || e is OperationCanceledException)
                    {
                        return(null);
                    }
                }
            }
        }