private async void button_Check_Click(object sender, EventArgs e)
{
// Check if Pincode Selected
if (comboBox_Pincode.SelectedIndex < 0)
{
MessageBox.Show("Invalid Pincode!", "Error!", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
// Calculate & Populate Duration & Sort Seller List
DistanceMatrixRequest y = new DistanceMatrixRequest();
y.ApiKey = Program.szGoogleMapsAPI_key;
y.Origins = new string[] { comboBox_Pincode.Text };
y.Mode = DistanceMatrixTravelModes.driving;
List <string> Destinations = new List <string>();
foreach (DataGridViewRow x in dataGridView_SellerList.Rows)
{
CSeller_Inventory temp = (CSeller_Inventory)(x.Cells["extra_1"].Value);
Destinations.Add(temp.pincode.ToString());
}
y.Destinations = Destinations.ToArray <string>();
DistanceMatrixResponse z = await GoogleMapsApi.GoogleMaps.DistanceMatrix.QueryAsync(y);
for (int i = 0; i < z.Rows.ElementAt <Row>(0).Elements.Count <Element>(); ++i)
{
Element x = z.Rows.ElementAt <Row>(0).Elements.ElementAt <Element>(i);
dataGridView_SellerList.Rows[i].Cells["shipping_time"].Value = (x.Duration.Value.Days + 1) + " Day(s) " + (x.Duration.Value.Hours) + " Hour(s)";
}
dataGridView_SellerList.Sort(dataGridView_SellerList.Columns["shipping_time"], ListSortDirection.Ascending);
}
private void OutputDistanceResponse(DistanceMatrixResponse response)
{
if (IsStatusOk(response.Status))
{
int i = 0;
Console.WriteLine($"{string.Join('/', response.OriginAddresses)}-->{string.Join('/', response.DestinationAddresses)}");
foreach (var row in response.Rows)
{
foreach (var element in row.Elements)
{
if (IsStatusOk(element.Status))
{
Console.WriteLine($"#{++i}=>Distance: {element.Distance.Text}, Duration: {element.Duration.Text}");
}
else
{
Console.WriteLine($"Result: {element.Status}");
return;
}
}
}
}
else
{
Console.WriteLine($"Response error: {response.Status}");
}
}
public void DoWork()
{
Initialize();
Console.WriteLine("Please, enter coordinates in form <latitude>, <longitude>. For ex.:37.4224764, -122.0842499.");
Console.WriteLine("Enter <Q> when you done input.");
Console.WriteLine("Origin coordinates:");
string[] origins = ReadConsoleStrings();
Console.WriteLine("Destination coordinates:");
string[] destinations = ReadConsoleStrings();
DistanceMatrixParameters distanceParameters = new DistanceMatrixParameters
{
Origins = new string[] { string.Join('|', origins) },
Destinactions = new string[] { string.Join('|', destinations) },
Units = "metric",
Mode = "driving",
Language = "en-US"
};
DistanceMatrixResponse distanceResponse = distanceMatrixClient.GetDistance(distanceParameters);
OutputDistanceResponse(distanceResponse);
WriteToFile(_outputFileName, distanceResponse);
Console.WriteLine("Please, press any key to exit");
Console.ReadKey();
}
/// <summary>
/// If the response status indicates fail because of quota exceeded - mark test as inconclusive.
/// </summary>
public static void NotExceedQuota(DistanceMatrixResponse response)
{
if (response?.Status == DistanceMatrixStatusCodes.OVER_QUERY_LIMIT)
{
throw new InconclusiveException(QuotaExceedMessage);
}
}
public DistanceMatrixResponse Run(string ID, string AddressList, bool AvoidHighways, bool AvoidTolls, bool AvoidFerries, string Mode, string Unit)
{
string avoid = "";
if (AvoidHighways)
{
avoid = "highways|";
}
if (AvoidTolls)
{
avoid = "tolls|";
}
if (AvoidFerries)
{
avoid = "ferries|";
}
if (!string.IsNullOrWhiteSpace(avoid))
{
avoid = avoid.Remove(avoid.LastIndexOf('|'));
}
DistanceMatrixResponse result = GoogleAPIHelper.GetDistanceMatrix(AddressList, Mode.ToLowerInvariant(), avoid, Unit.ToLowerInvariant());
return(result);
}
public int ObtainDurationFromMatrix(DistanceMatrixResponse gMatrixTransporter)
{
var firstRow = gMatrixTransporter.Rows.First();
var firstElement = firstRow.Elements.First();
if (firstElement.Status == GoogleDistanceMatrixResponseStatus.Ok)
{
return(firstElement.Duration.Value);
}
return(-1);
}
public DistanceResult DistanceMatrix(Place origin, List <Place> destinations)
{
DistanceMatrixRequest req = new DistanceMatrixRequest();
req.AddOrigin(new Google.Maps.Waypoint((decimal)origin.GeoLocation.Latitude, (decimal)origin.GeoLocation.Longitude));
var index = 0;
var reverseLookup = new Dictionary <int, int>();
for (int j = 0; j < destinations.Count; j++)
{
var dest = destinations[j];
//if (dest.Visited) { continue; }
if (!Init(dest, origin))
{
continue;
}
req.AddDestination(new Google.Maps.Waypoint((decimal)dest.GeoLocation.Latitude, (decimal)dest.GeoLocation.Longitude));
reverseLookup.Add(index, j);
++index;
}
req.Sensor = false;
req.Units = Google.Maps.Units.imperial;
DistanceMatrixResponse response = GoogleServiceRequest(req);
if (response.Rows == null || response.Rows.Count() == 0)
{
throw new InvalidOperationException(string.Format("Error: No rows returned, Status {0}", response.Status));
}
foreach (var row in response.Rows)
{
var resultPos = 0;
foreach (var cell in row.Elements)
{
var which = reverseLookup[resultPos];
var dest = destinations[which];
var name = dest.Name;
var distText = cell.distance.Text;
var distVal = Convert(cell.distance.Value);
var durText = cell.duration.Text;
var durVal = Convert(cell.duration.Value);
SetDistance(origin, resultPos, dest, name, distText, distVal, durText, durVal);
resultPos++;
}
}
List <Place> distSort = CreateSortByDistance(destinations);
List <Place> durSort = CreateSortByDuration(destinations);
return(new DistanceResult(response)
{
DistanceSort = distSort, DurationSort = durSort
});
}
public static int RequestDistance(string origin, string destination)
{
DistanceMatrixRequest request = new DistanceMatrixRequest()
{
Origins = new string[] { origin },
Destinations = new string[] { destination },
ApiKey = apiKey
};
DistanceMatrixResponse response = GoogleMapsApi.GoogleMaps.DistanceMatrix.Query(request);
int distance = response.Rows.ElementAt(0).Elements.ElementAt(0).Distance.Value;
return(distance);
}
public void Geocoding_GetDistance_statusOk()
{
DistanceMatrixParameters distanceParameters = new DistanceMatrixParameters
{
Origins = _originAdresses,
Destinactions = _destinationAddresses,
Units = _units,
Mode = _mode,
Language = _language
};
DistanceMatrixResponse response = _distanceClient.GetDistance(distanceParameters);
Assert.AreEqual(IsStatusOk(response.Status), true);
}
public DistanceMatrixViewModel CreateDistanceMatrix(string origin)
{
DistanceMatrixViewModel inputViewModel = new DistanceMatrixViewModel();
inputViewModel.DistanceMatrix = new List <DistanceMatrixViewModel>();
List <Location> destinationLocations = new List <Location>();
List <Lot> allLots = iLotRepo.ListAllLots();
foreach (Lot eachLot in allLots)
{
DistanceMatrixViewModel processingViewModel = new DistanceMatrixViewModel();
processingViewModel.LotID = eachLot.LotID;
processingViewModel.LotAddress = eachLot.LotAddress;
processingViewModel.LotNumber = eachLot.LotNumber;
processingViewModel.AvailableSpots = eachLot.MaxCapacity - eachLot.CurrentOccupancy;
processingViewModel.LotName = eachLot.LocationName;
inputViewModel.DistanceMatrix.Add(processingViewModel);
destinationLocations.Add(new Location(eachLot.LotAddress));
}
DistanceMatrixResponse response = FindDistanceAndDurationBetweenOriginAndDestinations(origin, destinationLocations);
Row row = response.Rows.FirstOrDefault();
List <Element> elements = row.Elements.ToList();
int distanceInMeters;
double distanceInMiles;
const double metersToMileConverter = 0.00062137;
int durationInSeconds;
int durationInMinutes;
int index = 0;
foreach (Element eachElement in elements)// need to do this for all 4
{
distanceInMeters = eachElement.Distance.Value;
distanceInMiles = Math.Round((distanceInMeters * metersToMileConverter), 2);
durationInSeconds = eachElement.Duration.Value;
durationInMinutes = durationInSeconds / 60;
inputViewModel.DistanceMatrix[index].DistanceInMiles = distanceInMiles;
inputViewModel.DistanceMatrix[index].DurationInMinutes = durationInMinutes;
index++;
}
return(inputViewModel);
}
public DistanceMatrix(DistanceMatrixResponse googleMatrix, int technicalObjectsCount)
{
TechnicalObjectsCount = technicalObjectsCount;
var n = googleMatrix.destination_addresses.Length;
Matrix = new int[n, n];
for (int i = 0; i < googleMatrix.rows.Length; i++)
{
var row = googleMatrix.rows[i];
for (int j = 0; j < row.elements.Length; j++)
{
var element = row.elements[j];
Matrix[i, j] = element.distance.value;
}
}
}
private static double[,] ConvertResponseToMatrix(DistanceMatrixResponse matrixResponse)
{
GeoData[] destinations = matrixResponse.resourceSets[0].resources[0].destinations.ToArray();
_geoPoints = destinations;
GeoData[] origins = matrixResponse.resourceSets[0].resources[0].origins.ToArray();
MatrixCalculationResult[] results = matrixResponse.resourceSets[0].resources[0].results.ToArray();
double[,] distanceMatrix = new double[destinations.Length, destinations.Length];
int resultsCounter = 0;
for (int i = 0; i < destinations.Length; ++i)
{
for (int j = 0; j < origins.Length; ++j)
{
distanceMatrix[i, j] = results[resultsCounter].travelDistance;
resultsCounter++;
}
}
return(distanceMatrix);
}
public DistanceMatrixResponse FindDistanceAndDurationBetweenOriginAndDestinations(string origin, List <Location> destinationLocations)
{
//string origin = "1601 University Ave, Morgantown, WV 26506";
//string destination = "2001 Rec Center Dr, Morgantown, WV 26506";
DistanceMatrixRequest request = new DistanceMatrixRequest();
request.Key = "AIzaSyBRT65jDLR_mhb4yzGbMBMaIZALz57028A";
List <Location> originLocations = new List <Location>();
Location originLocation = new Location(origin);
originLocations.Add(originLocation);
request.Origins = originLocations;
request.Destinations = destinationLocations;
DistanceMatrixResponse response = GoogleApi.GoogleMaps.DistanceMatrix.Query(request);
return(response);
}
public static DistanceMatrixResponse GetDistanceMatrix(string addressList, string mode, string avoid, string unit)
{
HttpClient client = new HttpClient();
client.BaseAddress = new Uri("https://maps.googleapis.com/maps/");
// Add an Accept header for JSON format.
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response = client.GetAsync(string.Format("api/distancematrix/json?origins={0}&destinations={0}&mode={1}&avoid={2}&units={3}&key={4}", addressList, mode, avoid, unit, CacheManager.ApiKey)).Result;
if (response.IsSuccessStatusCode)
{
string jsonresponse = response.Content.ReadAsStringAsync().Result;
DistanceMatrixResponse result = Newtonsoft.Json.JsonConvert.DeserializeObject <DistanceMatrixResponse>(jsonresponse);
return(result);
}
else
{
return(null);
}
}
public static DistanceMatrixResponse GetDistanceMatrix(string origin, string destination, DateTime departureTime)
{
Time time = new Time();
time.Value = departureTime;
if (!string.IsNullOrWhiteSpace(origin) && !string.IsNullOrWhiteSpace(destination) && departureTime != null)
{
DistanceMatrixRequest distanceRequest = new DistanceMatrixRequest()
{
Origins = new string[] { origin },
Destinations = new string[] { destination },
TrafficModel = DistanceMatrixTrafficModels.best_guess,
DepartureTime = time,
IsSSL = true,
};
distanceRequest.ApiKey = ConfigurationManager.AppSettings["GoogleMapsApiKey"].ToString();
try
{
DistanceMatrixResponse distances = GoogleMaps.DistanceMatrix.Query(distanceRequest);
//Sleep the thread so we dont go over the limit per seconds with google maps.
Thread.Sleep(100);
return(distances);
}
catch
{
Thread.Sleep(100);
return(null);
}
}
else
{
return(null);
}
}
public void ExecuteDistanceMatrix(IPluginExecutionContext pluginExecutionContext, IOrganizationService organizationService, ITracingService tracingService)
{
//Contains 2 fields (EntityCollection) for sources and targets
ParameterCollection InputParameters = pluginExecutionContext.InputParameters;
// Contains 1 field (EntityCollection) for results
ParameterCollection OutputParameters = pluginExecutionContext.OutputParameters;
//Contains 1 field (int) for status of previous and this plugin
ParameterCollection SharedVariables = pluginExecutionContext.SharedVariables;
tracingService.Trace("ExecuteDistanceMatrix started. InputParameters = {0},OutputParameters = {1}", InputParameters.Count().ToString(), OutputParameters.Count().ToString());
try
{
// If a plugin earlier in the pipeline has already retrieved a distance matrix successfully, quit
if (OutputParameters[MatrixKey] != null)
{
if (((EntityCollection)OutputParameters[MatrixKey]).Entities != null)
{
if (((EntityCollection)OutputParameters[MatrixKey]).Entities.Count > 0)
{
return;
}
}
}
// Make Distance Matrix call to Google API
WebClient client = new WebClient();
var url = String.Format($"https://{GoogleConstants.GoogleApiServer}{GoogleConstants.GoogleDistanceMatrixPath}/json"
+ "?units=imperial"
+ $"&origins={string.Join("|", ((EntityCollection)InputParameters[SourcesKey]).Entities.Select(e => e.GetAttributeValue<double?>("latitude") + "," + e.GetAttributeValue<double?>("longitude")))}"
+ $"&destinations={string.Join("|", ((EntityCollection)InputParameters[TargetsKey]).Entities.Select(e => e.GetAttributeValue<double?>("latitude") + "," + e.GetAttributeValue<double?>("longitude")))}"
+ $"&key={GoogleConstants.GoogleApiKey}");
tracingService.Trace($"Calling {url}\n");
string response = client.DownloadString(url); // Post ...
tracingService.Trace("Parsing response ...\n");
DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(DistanceMatrixResponse)); // Deserialize response json
object objResponse = jsonSerializer.ReadObject(new MemoryStream(Encoding.UTF8.GetBytes(response))); // Get response as an object
DistanceMatrixResponse distancematrixResponse = objResponse as DistanceMatrixResponse; // Unbox as our data contracted class for response
tracingService.Trace("Response Status = " + distancematrixResponse.Status + "\n");
if (distancematrixResponse.Status != "OK")
{
throw new ApplicationException($"Server {GoogleConstants.GoogleApiServer} application error (Status={distancematrixResponse.Status}). {distancematrixResponse.ErrorMessage}");
}
tracingService.Trace("Checking distancematrixResponse.Results...\n");
if (distancematrixResponse.Rows != null)
{
tracingService.Trace("Parsing distancematrixResponse.Results.Elements...\n");
// build and update output parameter
var result = new EntityCollection();
result.Entities.AddRange(distancematrixResponse.Rows.Select(r => ToEntity(r.Columns.Select(c => ToEntity(c.Status, c.Duration, c.Distance)).ToArray())));
OutputParameters[MatrixKey] = result;
}
else
{
throw new ApplicationException($"Server {GoogleConstants.GoogleApiServer} application error (missing Rows)");
}
}
catch (Exception ex)
{
// Signal to subsequent plugins in this message pipeline that retrieval of distance matrix failed here.
OutputParameters[MatrixKey] = null;
//TODO: You may need to decide which caught exceptions will rethrow and which ones will simply signal geocoding did not complete.
throw new InvalidPluginExecutionException(string.Format("Geocoding failed at {0} with exception -- {1}: {2}"
, GoogleConstants.GoogleApiServer, ex.GetType().ToString(), ex.Message), ex);
}
// For debugging purposes, throw an exception to see the details of the parameters
CreateExceptionWithDetails("Debugging...", InputParameters, OutputParameters, SharedVariables);
}
public static void SetDistanceMatrixResponse(DistanceMatrixResponse response)
{
_distanceMatrixResponse = response;
_matrix = ConvertResponseToMatrix(response);
_labels = GenerateLabels();
}
private async void tabControl_MAIN_SelectedIndexChanged(object sender, EventArgs e)
{
if (tabControl_MAIN.SelectedTab.Text.Equals("Inventory"))
{
dataGridView_Inventory.Rows.Clear();
List <CSeller_Inventory> inv_list = await CSeller_Inventory.RetrieveSellerInventoryList(CUser.cur_user.id);
foreach (CSeller_Inventory x in inv_list)
{
CProduct y = await CProduct.Retrieve(x.product_id);
dataGridView_Inventory.Rows.Add
(
new object[]
{
x.product_id,
y.name,
x.price,
x.quantity,
x.pincode,
x.warranty,
x,
y
}
);
}
}
else if (tabControl_MAIN.SelectedTab.Text.Equals("Orders"))
{
dataGridView_Orders.Rows.Clear();
List <COrder> order_list = await COrder.RetrieveOrdertBySellerID(CUser.cur_user.id);
DistanceMatrixRequest req = new DistanceMatrixRequest();
req.ApiKey = Program.szGoogleMapsAPI_key;
req.Mode = DistanceMatrixTravelModes.driving;
foreach (COrder x in order_list)
{
CProduct y = await CProduct.Retrieve(x.product_id);
CSeller_Inventory z = await CSeller_Inventory.Retrieve(x.seller_id, x.product_id);
CLocation c = await CLocation.Retrieve(x.pincode);
String address = x.street + ", " + c.city + ", " + c.state + ", " + c.country + ", " + x.pincode;
// Calculate ETA
req.Origins = new string[] { z.pincode.ToString() };
req.Destinations = new string[] { x.pincode.ToString() };
DistanceMatrixResponse resp = await GoogleMapsApi.GoogleMaps.DistanceMatrix.QueryAsync(req);
TimeSpan ts = resp.Rows.ElementAt <Row>(0).Elements.ElementAt <Element>(0).Duration.Value;
ts = ts - (DateTime.Now - x.started_at.AddDays(1));
dataGridView_Orders.Rows.Add
(
new object[]
{
x.id,
y.name,
z.price,
x.quantity,
address,
x.started_at,
(ts.Days) + " Day(s) " + (ts.Hours) + " Hour(s)",
x.order_status,
x,
y,
z,
c
}
);
}
}
}
public DistanceResult(DistanceMatrixResponse matrix)
{
this.Matrix = matrix;
}
