public WaterContainerResponse ResultWaterContainer(CoordinateDTO request)
{
validateLength(request.CoordinateY);
int length = this.arrayAreaServices.getLength(request.CoordinateY);
var response = new WaterContainerResponse();
response.Result = CalculateResult(length, request.CoordinateY);
return(response);
int CalculateResult(int _length, int[] _coordinates)
{
int output = 0;
for (int i = 0; i < _length; i++)
{
for (int j = _length - 1; j > i; j--)
{
int baser = (j - i);
int height = (_coordinates[i] < _coordinates[j]) ? _coordinates[i] : _coordinates[j];
int area = this.arrayAreaServices.calculateArea(baser, height);
output = (area > output) ? area : output;
}
}
return(output);
}
}
public IHttpActionResult Update([FromBody] CoordinateDTO coordinates)
{
var _userWithData = (RegisterUserDTO)HttpContext.Current.Items["user"];
new LocationServices().UpdatePosition(_userWithData.user_id, coordinates);
return(Json(new StatusChangeDTO(_userWithData.status)));
}
public static DbGeography GenerateDBGeographyFromCoordinates(CoordinateDTO coordinates)
{
string conversion = "POINT(" + coordinates.longitude + " " + coordinates.latitude + ")";
conversion = conversion.Replace(",", ".");
var myLocation = DbGeography.FromText(conversion);
return(myLocation);
}
public int return_response_correct_with_coordinates(int[] arg)
{
CoordinateDTO request = new CoordinateDTO();
request.CoordinateY = arg;
int result = waterContainerOperator.Object.ResultWaterContainer(request).Result;
return(result);
}
public void return_error_if_dont_have_coordinates()
{
CoordinateDTO request = new CoordinateDTO();
request.CoordinateY = new int[] { 1 };
Assert.Throws <WaterContainerException>(
() =>
{
waterContainerOperator.Object.ResultWaterContainer(request);
});
}
public IHttpActionResult NearUntakenServicesCount([FromBody] CoordinateDTO coordinates)
{
var _userWithData = (RegisterUserDTO)HttpContext.Current.Items["user"];
if (_userWithData.is_provider == 1)
{
new LocationServices().UpdatePosition(_userWithData.user_id, coordinates);
return(Json(new NearUntakenServicesCountDTO()
{
count = new LocationServices().GetNearUntakenServices(coordinates).Count
}));
}
return(Conflict());
}
public string timeLeft(CoordinateDTO origin, CoordinateDTO destination)
{
HttpClient clientRequest = new HttpClient();
//clientRequest.Timeout = TimeSpan.FromSeconds(GlobalData.TimeoutWebRequests);
var requestWebsite = "https://maps.googleapis.com/maps/api/distancematrix/json?units=imperial&origins=" +
origin.latitude.ToString().Replace(",", ".") + "," + origin.longitude.ToString().Replace(",", ".") + "&destinations=" + destination.latitude.ToString().Replace(",", ".") +
"," + destination.longitude.ToString().Replace(",", ".") + "&key=" + googleApiKey;
var contents = clientRequest.GetStringAsync(requestWebsite).Result;
var result = JsonConvert.DeserializeObject <GoogleMapQuery>(contents);
return(result.Rows.FirstOrDefault().Elements.FirstOrDefault().Duration.Text);
}
static void Main(string[] args)
{
try
{
var factory = new ConnectionFactory
{
Uri = new Uri("amqp://*****:*****@localhost:5672"),
ConsumerDispatchConcurrency = 32, // max 32 kanal paralel calisma oalbilsin.
DispatchConsumersAsync = true //Async calisabilme icin
};
using var connection = factory.CreateConnection();
using var channel = connection.CreateModel();
channel.QueueDeclare("demo-queue",
durable: true,
exclusive: false,
autoDelete: false,
arguments: null
);
var consumer = new AsyncEventingBasicConsumer(channel); // TPL icin..
logger.Log(NLog.LogLevel.Info, "S_latitude|S_longitude|D_latitude|D_longitude|Distance");
logger.Log(NLog.LogLevel.Info, " ");
consumer.Received += async(sender, e) => {
var body = e.Body.ToArray();
var message = Encoding.UTF8.GetString(body);
CoordinateDTO aa = JsonConvert.DeserializeObject <CoordinateDTO>(message);
Console.WriteLine(aa.Source_latitude + " | " + aa.Source_longitude + " | " + aa.Destination_latitude + " | " + aa.Destination_longitude + " | " + aa.Distance);
logger.Log(NLog.LogLevel.Info, aa.Source_latitude + " | " + aa.Source_longitude + " | " + aa.Destination_latitude + " | " + aa.Destination_longitude + " | " + aa.Distance);
//await WriteTextAsync(aa.Source_latitude + " | " + aa.Source_longitude + " | " + aa.Destination_latitude + " | " + aa.Destination_longitude + " | " + aa.Distance);
};
channel.BasicConsume("demo-queue", true, consumer);
Console.ReadLine();
}
catch (Exception ex)
{
lock (locker)
{
logger.Error(ex, "ERROR at Main");
}
}
}
public void TestThatTourGetsStartedCorrectly()
{
UserTour activeTour = null;
POI nextPOI = new POI
{
Id = 4,
Name = "POIName",
Description = "POIDesc",
VisitDuration = 23,
Coordinates = DbGeography.PointFromText("POINT(49 23)", 4326)
};
_userTourRepoMock.Setup(m => m.GetActiveTour(1)).Returns((int userId) => activeTour);
_userTourRepoMock.Setup(m => m.StartUserTour(1, 2)).Callback(() => activeTour = new UserTour {
Id = 3
});
_userPoiRepoMock.Setup(m => m.GetNextPOI(3)).Returns(nextPOI);
CoordinateDTO coordinate1 = new CoordinateDTO {
Latitude = 14, Longitude = 39
};
CoordinateDTO coordinate2 = new CoordinateDTO {
Latitude = 16, Longitude = 40
};
_geoLocationServiceMock.Setup(m => m.GetRoute(It.IsInRange(7.9, 8.1, Range.Inclusive),
It.IsInRange(84.9, 85.1, Range.Inclusive), It.IsInRange(22.9, 23.1, Range.Inclusive),
It.IsInRange(48.9, 49.1, Range.Inclusive)))
.Returns(new CoordinateDTO[] { coordinate1, coordinate2 });
RouteToPointOfInterestDTO routeToPointOfInterestDto = _target.StartUserTour(1, 2, 8, 85);
Assert.IsNotNull(routeToPointOfInterestDto);
Assert.IsNotNull(routeToPointOfInterestDto.NextPOI);
Assert.IsNotNull(routeToPointOfInterestDto.RouteToNextPOI);
Assert.AreEqual(nextPOI.Id, routeToPointOfInterestDto.NextPOI.Id);
Assert.AreEqual(nextPOI.Description, routeToPointOfInterestDto.NextPOI.Description);
Assert.AreEqual(nextPOI.VisitDuration, routeToPointOfInterestDto.NextPOI.VisitDuration);
Assert.AreEqual(23.0, routeToPointOfInterestDto.NextPOI.Latitude, 0.1);
Assert.AreEqual(49.0, routeToPointOfInterestDto.NextPOI.Longitude, 0.1);
Assert.AreEqual(2.0, routeToPointOfInterestDto.RouteToNextPOI.Count());
Assert.AreEqual(14.0, routeToPointOfInterestDto.RouteToNextPOI.ElementAt(0).Latitude, 0.1);
Assert.AreEqual(39.0, routeToPointOfInterestDto.RouteToNextPOI.ElementAt(0).Longitude, 0.1);
Assert.AreEqual(16.0, routeToPointOfInterestDto.RouteToNextPOI.ElementAt(1).Latitude, 0.1);
Assert.AreEqual(40.0, routeToPointOfInterestDto.RouteToNextPOI.ElementAt(1).Longitude, 0.1);
}
public List <ServicePinDTO> GetNearUntakenServices(CoordinateDTO coordinates)
{
var response = new List <ServicePinDTO>();
var currentLocation = GenerateDBGeographyFromCoordinates(coordinates);
using (var entities = new UCAInvestDBEntities())
{
var Services = (from u in entities.user_services
where u.taken_timestamp == 0 && u.completed_timestamp == 0 && u.location.Distance(currentLocation) <= CommonConfig.IncidenceRadiusInM
orderby u.location.Distance(currentLocation)
select u);
foreach (var service in Services)
{
response.Add(new ServicePinDTO(service.ServiceUser.username, new CoordinateDTO((double)service.location.Latitude, (double)service.location.Longitude), service.ServiceUser.plate, service.description, (long)service.request_timestamp, 2, service.ServiceUser.user_id, service.service_id));
}
}
return(response);
}
public List <MapPinDTO> GetNearCranes(CoordinateDTO coordinates)
{
var response = new List <MapPinDTO>();
var currentLocation = GenerateDBGeographyFromCoordinates(coordinates);
using (var entities = new UCAInvestDBEntities())
{
var Cranes = (from u in entities.user_locations
where u.users.is_provider == 1 &&
u.location.Distance(currentLocation) <= CommonConfig.IncidenceRadiusInM
orderby u.location.Distance(currentLocation)
select u);
foreach (var crane in Cranes)
{
response.Add(new MapPinDTO(crane.users.username,
new CoordinateDTO((double)crane.location.Latitude, (double)crane.location.Longitude),
crane.users.plate, "", (long)crane.timestamp, (int)crane.users.is_provider, crane.user_id));
}
}
return(response);
}
public CurrentServicePositionsDTO ServicePosition(int userId)
{
CurrentServicePositionsDTO response = null;
using (var entities = new UCAInvestDBEntities())
{
var serviceDbResponse =
entities.user_services.SingleOrDefault(t =>
(t.crane_user_id == userId || t.client_user_id == userId) && t.completed_timestamp == 0);
if (serviceDbResponse != null)
{
response = new CurrentServicePositionsDTO();
var cranePosition = new CoordinateDTO(
(double)serviceDbResponse.CraneUser.user_locations.location.Latitude,
(double)serviceDbResponse.CraneUser.user_locations.location.Longitude);
if (userId == serviceDbResponse.crane_user_id)
{
response.OtherUser = new UsersServices().PublicUserById((int)serviceDbResponse.client_user_id);
response.OtherUserPosition = new CoordinateDTO((double)serviceDbResponse.ServiceUser.user_locations.location.Latitude,
(double)serviceDbResponse.ServiceUser.user_locations.location.Longitude);
}
else
{
response.OtherUser = new UsersServices().PublicUserById((int)serviceDbResponse.crane_user_id);
response.OtherUserPosition = cranePosition;
}
response.RequestedPosition = new CoordinateDTO((double)serviceDbResponse.location.Latitude,
(double)serviceDbResponse.location.Longitude);
response.ServiceId = serviceDbResponse.service_id;
response.TimeRemaining = new GoogleTimeService().timeLeft(cranePosition, response.RequestedPosition);
}
}
return(response);
}
public void UpdatePosition(int userId, CoordinateDTO coordinates)
{
using (var entities = new UCAInvestDBEntities())
{
var dbResponse = entities.user_locations.SingleOrDefault(t => t.user_id == userId);
var currentLocation = GenerateDBGeographyFromCoordinates(coordinates);
var currentTimestamp = (long?)TimeFunctions.DateTimeToUnixTimestamp(DateTime.Now);
if (dbResponse != null)
{
dbResponse.location = currentLocation;
dbResponse.timestamp = currentTimestamp;
}
else
{
entities.user_locations.Add(new UserLocation()
{
location = currentLocation,
timestamp = currentTimestamp,
user_id = userId
});
}
entities.SaveChanges();
}
}
public void TestThatRouteToNextPOIIsReturnedCorrectly()
{
SetupActiveTourAndNextPOI(8, 13, 28);
var point1 = new CoordinateDTO {
Latitude = 2.4, Longitude = 33.4
};
var point2 = new CoordinateDTO {
Latitude = 2.7, Longitude = 33.7
};
var route = new CoordinateDTO[] { point1, point2 };
_geoLocationServiceMock.Setup(m => m.GetRoute(It.IsInRange(1.9, 2.1, Range.Inclusive),
It.IsInRange(32.9, 33.1, Range.Inclusive), It.IsInRange(2.9, 3.1, Range.Inclusive),
It.IsInRange(33.9, 34.1, Range.Inclusive))).Returns(route);
IEnumerable <CoordinateDTO> result = _target.GetRouteToNextPOI(8, 2.0, 33.0);
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count());
Assert.AreEqual(2.4, result.ElementAt(0).Latitude, 0.1);
Assert.AreEqual(33.4, result.ElementAt(0).Longitude, 0.1);
Assert.AreEqual(2.7, result.ElementAt(1).Latitude, 0.1);
Assert.AreEqual(33.7, result.ElementAt(1).Longitude, 0.1);
}
public async Task <ActionResult <string> > Get()
{
var res = "";
try
{
// KEY cache te tutulacak unique key uret :
//string memCacheKey = (geoCoordinateRecord.destination_latitude.ToString() + geoCoordinateRecord.destination_longitude.ToString()
// + geoCoordinateRecord.source_latitude.ToString() + geoCoordinateRecord.source_longitude.ToString()).Trim().ToLower();
var cacheExpOptions = new MemoryCacheEntryOptions
{
AbsoluteExpiration = DateTime.Now.AddMinutes(60), //60dk cachete tut
Size = 50
};
// 1.KONTROL: Cache e bak
//if (!_memoryCache.TryGetValue(memCacheKey, out GeoCoordinateRecord cachedWeatherRecord)) //cachte kayit yok ise
{
//var dbRecord = await _geoCoordinateRepository.GetWeatherData(memCacheKey);
List <GeoCoordinateRecord> recordList = new List <GeoCoordinateRecord>();
List <CoordinateDTO> recordListForQueu = new List <CoordinateDTO>();
GeoCoordinateRecord rec;
CoordinateDTO Queu;
Random myRandom;
{ }
for (int i = 0; i < 10000; i++)
{
myRandom = new Random();
rec = new GeoCoordinateRecord();
Queu = new CoordinateDTO();
//-------------------- Colelction for DB Insert -----------------------------------
rec.gcSource_latitude = Convert.ToDecimal(String.Format("{0:0.000000}", myRandom.NextDouble(36.000000, 42.000000)));
rec.gcSource_longitude = Convert.ToDecimal(String.Format("{0:0.000000}", myRandom.NextDouble(26.000000, 45.000000)));
rec.gcDestination_latitude = Convert.ToDecimal(String.Format("{0:0.000000}", myRandom.NextDouble(36.000000, 42.000000)));
rec.gcDestination_longitude = Convert.ToDecimal(String.Format("{0:0.000000}", myRandom.NextDouble(26.000000, 45.000000)));
rec.gcInsertDate = DateTime.Now;
recordList.Add(rec);
//-----------------------------------------------------------------------------------
//-------------------- Colelction for Log Queu with distance in KM ----------------
Queu.Source_latitude = rec.gcSource_latitude;
Queu.Source_longitude = rec.gcSource_longitude;
Queu.Destination_latitude = rec.gcDestination_latitude;
Queu.Destination_longitude = rec.gcDestination_longitude;
//Calculate Distance between 2 points
var locA = new GeoCoordinate(Convert.ToDouble(rec.gcSource_latitude), Convert.ToDouble(rec.gcSource_longitude));
var locB = new GeoCoordinate(Convert.ToDouble(rec.gcDestination_latitude), Convert.ToDouble(rec.gcDestination_longitude));
double distance = locA.GetDistanceTo(locB) / 1000; // kilometres
Queu.Distance = Convert.ToInt32(distance);
recordListForQueu.Add(Queu);
//-----------------------------------------------------------------------------------
}
// DB Insert
res = await _geoCoordinateRepository.AddRecordsToDB(recordList);
// Queu Insert
res += await _geoCoordinateRepository.AddRecordsToQueu(recordListForQueu);
}
//else // Kayit Cache de mevcut ise bunu kullan..
{
}
return(Ok(res));
}
catch (Exception ex)
{
return(NotFound("ERROR at Try(GetWeatherData): " + ex.Message));
}
}
public WaterContainerResponse GetWaterContainerResult(CoordinateDTO request)
{
return(this.waterContainerSolution.ResultWaterContainer(request));
}
