public void TestProjectLocationFilterTypesAddedAsProjectProperties()
{
var focusArea = TestFramework.TestFocusArea.Create();
var project = Project.CreateNewBlank(
ProjectType.CreateNewBlank(TaxonomyBranch.CreateNewBlank(TaxonomyTrunk.CreateNewBlank())),
ProjectStage.Completed,
ProjectLocationSimpleType.None,
// TODO: Verify that "Approved" is the correct project state or use the correct value
ProjectApprovalStatus.Approved);
project.FocusArea = focusArea;
project.ProjectLocationPoint = DbGeometry.PointFromText("POINT(29.11 40.11)", 4326);
var feature = Project.MappedPointsToGeoJsonFeatureCollection(new List <Project> {
project
}, true, true).Features.First();
foreach (var projectLocationFilterType in ProjectLocationFilterType.All)
{
Assert.That(feature.Properties.ContainsKey(projectLocationFilterType.ProjectLocationFilterTypeNameWithIdentifier),
"ProjectLocationFilterType {0} not present as a property of Project.",
projectLocationFilterType.ProjectLocationFilterTypeNameWithIdentifier);
}
}
public static DbGeometry FromWkt(string type, string wkt, int systemid)
{
type = type.ToUpper();
switch (type)
{
case "POINT":
return(DbGeometry.PointFromText(wkt, systemid));
case "POLYGON":
return(DbGeometry.PolygonFromText(wkt, systemid));
case "LINE":
return(DbGeometry.LineFromText(wkt, systemid));
case "MULTIPOINT":
return(DbGeometry.MultiPointFromText(wkt, systemid));
case "MULTIPOLYGON":
return(DbGeometry.MultiPolygonFromText(wkt, systemid));
case "MULTILINE":
return(DbGeometry.MultiLineFromText(wkt, systemid));
default:
return(null);
}
}
private void GetStoreContainersOfPoint(ApplicationDbContext db, Point3D source, Point3D target, List <IHasEntrances> sourceContainers, List <IHasEntrances> targetContainers)
{
var levelPois = db.POIs.Include("Location").Where(x => x.Location.Level == source.Level | x.Location.Level == target.Level);
//var levelPois = BuildSet<IHasEntrances>().Where(x => ((POI)x).Location.Level == source.Level | ((POI)x).Location.Level == target.Level);
DbGeometry sourcePoint = DbGeometry.PointFromText("POINT (" + source.Longitude + " " + source.Latitude + ")", 4326);
DbGeometry targetPoint = DbGeometry.PointFromText("POINT (" + target.Longitude + " " + target.Latitude + ")", 4326);
List <POI> containers = new List <POI>();
foreach (var s in levelPois)
{
if (s is IHasEntrances)
{
//db.Entry(s).Reference("Location").Load();
if (((POI)s).Location.LocationG.Contains(sourcePoint))
{
sourceContainers.Add((IHasEntrances)(s));
}
if (((POI)s).Location.LocationG.Contains(targetPoint))
{
targetContainers.Add((IHasEntrances)(s));
}
}
//if (s is IHasEntrances && ((POI)s).Location.LocationG.Contains(targetPoint))
// targetContainers.Add((IHasEntrances)(s));
//if (s is IHasEntrances && GeoUtils.IsPointInPolygone(source, s.Location))
// sourceContainers.Add((IHasEntrances)(s));
//if (s is IHasEntrances && GeoUtils.IsPointInPolygone(target, s.Location))
// targetContainers.Add((IHasEntrances)(s));
}
}
/// <summary>
/// Create a GeoLocation point based on latitude and longitude
/// </summary>
/// <param name="latitude">latitude</param>
/// <param name="longitude">longitude</param>
/// <param name="sRid">spatial reference id, default is 4326</param>
/// <returns></returns>
public static DbGeometry CreatePoint(double latitude, double longitude, int sRid)
{
var text = $"POINT({longitude} {latitude})";
// 4326 is most common coordinate system used by GPS/Maps
return(DbGeometry.PointFromText(text, sRid));
}
public static DbGeometry MakeDbGeometryFromCoordinates(double xCoordinate, double yCoordinate, int coordinateSystemId)
{
var geometry = DbGeometry.PointFromText(string.Format("POINT({0} {1})", xCoordinate, yCoordinate),
coordinateSystemId);
return(geometry);
}
public void Test_GetDeliveryPointsCrossingOperationalObject()
{
DbGeometry operationalObjectPoint = DbGeometry.PointFromText("POINT (488938 197021)", 27700);
var actualResult = testCandidate.GetDeliveryPointsCrossingOperationalObject("POINT (488938 197021)", operationalObjectPoint);
Assert.IsNotNull(actualResult);
Assert.IsNotNull(actualResult.Count == 0);
}
/// <summary>
/// Create a GeoLocation point based on latitude and longitude
/// </summary>
/// <param name="latitudeLongitude">
/// String should be two values either single comma or space delimited
/// 45.710030,-121.516153
/// 45.710030 -121.516153
/// </param>
/// <param name="sRid">spatial reference id, default is 4326</param>
/// <returns></returns>
public static DbGeometry CreatePoint(string latitudeLongitude, int sRid)
{
var tokens = latitudeLongitude.Split(',', ' ');
if (tokens.Length != 2)
{
throw new ArgumentException("Invalid Location String Passed");
}
var text = $"POINT({tokens[1]} {tokens[0]})";
return(DbGeometry.PointFromText(text, sRid));
}
public void Test_GetDeliveryPointDistanceNegativeScenario()
{
try
{
DbGeometry point = DbGeometry.PointFromText("POINT (488938 197021)", 27700);
var result = testCandidate.GetDeliveryPointDistance(deliveryPointDataDTO, point);
Assert.Fail("An exception should have been thrown");
}
catch (ArgumentNullException ae)
{
Assert.AreEqual("Following arguments for the method are null Parameter name: deliveryPointDTO", ae.Message.Replace("\r\n", string.Empty));
}
}
public List <POI> GetByLocation(string lon, string lat, int level)
{
var levelStores = storeRepository.GetAll().Where(x => x.Floor == level);
DbGeometry point = DbGeometry.PointFromText("POINT (" + lon + " " + lat + ")", 4326);
List <POI> containers = new List <POI>();
foreach (Store s in levelStores)
{
if (s.Location.LocationG.Contains(point))
{
containers.Add(s);
}
}
return(containers);
}
private static void extractPoint(int noareas, JObject feature, Dictionary <string, Point3D> labeledPoints, List <Point3D> badPolygonsPoints)
{
Point3D toReturn = new Point3D();
toReturn.Level = int.Parse(feature["properties"]["level"].ToString());
toReturn.IsAccessible = Boolean.Parse(feature["properties"]["accessible"].ToString());
StringBuilder wktsb = new StringBuilder("POINT (");
var j = feature["geometry"]["coordinates"];
string lon = Regex.Match(j.ToString(), "34\\.\\d+").Value;
string lat = Regex.Match(j.ToString(), "32\\.\\d+").Value;
wktsb.Append(lon + " " + lat);
wktsb.Append(")");
toReturn.Wkt = wktsb.ToString();
toReturn.LocationG = DbGeometry.PointFromText(wktsb.ToString(), 4326);
toReturn.Name = feature["properties"]["attrs"]["name"].ToString();
toReturn.Latitude = Decimal.Parse(lat);
toReturn.Longitude = Decimal.Parse(lon);
if (feature["properties"]["attrs"]["Name2"] != null)
{
toReturn.Name2 = feature["properties"]["attrs"]["Name2"].ToString();
}
toReturn.Areas = new List <Area>();
if (feature["properties"]["attrs"]["AreaID"] != null)
{
Area area = new Area(feature["properties"]["attrs"]["AreaID"].ToString());
toReturn.Areas.Add(area);
int index = 2;
while (feature["properties"]["attrs"]["AreaID" + index] != null)
{
toReturn.Areas.Add(new Area(feature["properties"]["attrs"]["AreaID" + index++].ToString()));
}
}
else
{
noareas++;
}
if (toReturn.Name.ToUpper().Contains("PASSAGES") | toReturn.Name.ToUpper().Contains("ROADWALK"))
{
badPolygonsPoints.Add(toReturn);
}
else
{
labeledPoints.Add(toReturn.Wkt, toReturn);
}
}
public async Task Test_UpdateDeliveryPointLocationOnUDPRN()
{
deliveryPointDataDTO = new DeliveryPointDataDTO()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
MailVolume = 5,
PostalAddress = new PostalAddressDataDTO()
{
BuildingName = "bldg2",
BuildingNumber = 1,
SubBuildingName = "subbldg1",
OrganisationName = "org",
DepartmentName = "department",
Thoroughfare = "ThoroughFare1",
DependentThoroughfare = "DependentThoroughFare1",
Postcode = "PostcodeNew",
PostTown = "PostTown",
POBoxNumber = "POBoxNumber",
UDPRN = 12345,
PostcodeType = "xyz",
SmallUserOrganisationIndicator = "indicator",
DeliveryPointSuffix = "DeliveryPointSuffix",
PostCodeGUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A15"),
AddressType_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19"),
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19")
},
DeliveryPointStatus = new List <DeliveryPointStatusDataDTO>()
{
new DeliveryPointStatusDataDTO()
{
LocationID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13")
}
},
NetworkNode = new NetworkNodeDataDTO()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
Location = new LocationDataDTO()
{
Shape = DbGeometry.PointFromText("POINT (488938 197021)", 27700)
}
},
};
var result = await testCandidate.UpdateDeliveryPointLocationOnUDPRN(deliveryPointDataDTO);
Assert.IsTrue(result == 1);
}
public void Test_GetDeliveryPointDistancePositiveScenario()
{
deliveryPointDataDTO = new DeliveryPointDataDTO()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
MailVolume = 5,
PostalAddress = new PostalAddressDataDTO()
{
BuildingName = "bldg2",
BuildingNumber = 1,
SubBuildingName = "subbldg1",
OrganisationName = "org",
DepartmentName = "department",
Thoroughfare = "ThoroughFare1",
DependentThoroughfare = "DependentThoroughFare1",
Postcode = "PostcodeNew",
PostTown = "PostTown",
POBoxNumber = "POBoxNumber",
UDPRN = 12345,
PostcodeType = "xyz",
SmallUserOrganisationIndicator = "indicator",
DeliveryPointSuffix = "DeliveryPointSuffix",
PostCodeGUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A15"),
AddressType_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19"),
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19")
},
NetworkNode = new NetworkNodeDataDTO()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
Location = new LocationDataDTO()
{
Shape = DbGeometry.PointFromText("POINT (488938 197021)", 27700)
}
},
};
DbGeometry point = DbGeometry.PointFromText("POINT (488938 197021)", 27700);
var result = testCandidate.GetDeliveryPointDistance(deliveryPointDataDTO, point);
Assert.IsNotNull(result);
Assert.IsNotNull(result == 0);
}
public List <POI> GetContainerByLocation(string lon, string lat, int level)
{
List <POI> containers = new List <POI>();
using (var context = new ApplicationDbContext())
{
var levelStores = context.POIs.Include("Location").Where(x => x.Location.Level == level);
//int count = levelStores.Count();
DbGeometry point = DbGeometry.PointFromText("POINT (" + lon + " " + lat + ")", 4326);
foreach (var s in levelStores)
{
//context.Entry(s).Reference("Location").Load();
if (s.Location.LocationG.Contains(point))
{
containers.Add(s);
}
}
}
return(containers);
}
public void CanCreateGeogrametryColumn()
{
using (SpatialDbContext ctx = new SpatialDbContext())
{
ctx.Database.Delete();
ctx.Database.Create();
var dis = new SPoint {
point = DbGeometry.PointFromText(string.Format("POINT({0} {1})", 47.37, -122.21), 4326)
};
ctx.SPoints.Add(dis);
var dis_2 = new SPoint {
point = DbGeometry.PointFromText(string.Format("POINT({0} {1})", 147.37, -122.21), 4326)
};
ctx.SPoints.Add(dis_2);
ctx.SaveChanges();
var points = ctx.SPoints.First();
Assert.AreEqual("POINT (47.37 -122.21)", points.point.AsText());
}
}
private static void extractPolygon(JObject feature, Dictionary <string, Point3D> labeledPoints, ApplicationDbContext context
, List <Point3D> badPolygonsPoints, List <POI> poisToSave)
{
POI poi = new POI();
poi.Type = null;
Polygone toReturn = new Polygone();
toReturn.Points = new List <Point3D>();
int level = int.Parse(feature["properties"]["level"].ToString());
//bool isAccessible = Boolean.Parse(feature["properties"]["accessible"].ToString());
toReturn.Level = level;
StringBuilder wktsb = new StringBuilder("POLYGON ((");
List <Point3D> labeledPointsFound = new List <Point3D>();
foreach (JArray j in feature["geometry"]["coordinates"][0])
{
StringBuilder pointWkt = new StringBuilder("POINT (");
string lon = Regex.Match(j.ToString(), "34\\.\\d+").Value;
string lat = Regex.Match(j.ToString(), "32\\.\\d+").Value;
wktsb.Append(lon + " " + lat + ",");
pointWkt.Append(lon + " " + lat + ")");
if (!toReturn.Points.Exists(Point3D => Point3D.Wkt == pointWkt.ToString()))
{
if (labeledPoints.ContainsKey(pointWkt.ToString()))
{
labeledPointsFound.Add(labeledPoints[pointWkt.ToString()]);
toReturn.Points.Add(labeledPoints[pointWkt.ToString()]);
//break;
}
else
{
DbGeometry pointG = DbGeometry.PointFromText(pointWkt.ToString(), 4326);
Point3D point = new Point3D {
Longitude = Decimal.Parse(lon), Latitude = Decimal.Parse(lat), Wkt = pointWkt.ToString(), LocationG = pointG, Level = level
};
toReturn.Points.Add(point);
}
}
}
wktsb.Remove(wktsb.Length - 1, 1);
wktsb.Append("))");
toReturn.Wkt = wktsb.ToString();
try
{
DbGeometry polygone = DbGeometry.PolygonFromText(wktsb.ToString(), 4326);
if (!polygone.IsValid)
{
polygone = DbGeometry.FromText(SqlGeometry.STGeomFromText(new SqlChars(polygone.AsText()), 4326).MakeValid().STAsText().ToSqlString().ToString(), 4326);
}
foreach (Point3D point in badPolygonsPoints)
{
if (polygone.Contains(point.LocationG))
{
return;
}
}
toReturn.LocationG = polygone;
}
catch (Exception ex)
{
ex = ex;
}
// polygon with no info
if (labeledPointsFound.Count == 0)
{
return;
}
// polygon with more than one anchor point - check if it is 2 entrances
if (labeledPointsFound.Count > 1)
{
if (labeledPointsFound[0].Areas.Count != labeledPointsFound[1].Areas.Count)
{
return;
}
else
{
for (int i = 0; i < labeledPointsFound[0].Areas.Count; i++)
{
if (!labeledPointsFound[0].Areas[i].AreaID.Equals(labeledPointsFound[1].Areas[i].AreaID))
{
return;
}
}
}
}
Point3D labeledPoint = labeledPointsFound[0];
if (labeledPoint != null)
{
toReturn.Areas = labeledPoint.Areas;
if (labeledPoint.Areas != null && labeledPoint.Areas.Count > 0 && !labeledPoint.Areas[0].AreaID.StartsWith("9"))
{
poi.Type = POI.POIType.STORE;
}
if (labeledPoint.Name.ToLower().Contains("atm"))
{
poi.Type = POI.POIType.ATM;
}
if (labeledPoint.Name.ToLower().Contains("entrance"))
{
poi.Type = POI.POIType.ENTRANCE;
}
if (labeledPoint.Name.ToLower().Contains("toilet") | labeledPoint.Name.ToLower().Contains("wc"))
{
poi.Type = POI.POIType.WC;
}
if (labeledPoint.Name.ToLower().Contains("zone"))
{
poi.Type = POI.POIType.ZONE;
}
}
if (poi.Type != null)
{
switch (poi.Type)
{
case POI.POIType.STORE:
{
poi = new Store {
Type = poi.Type, Anchor = labeledPoint, Enabled = true
, Floor = level,
IsAccessible = labeledPoint.IsAccessible,
Name = labeledPoint.Name,
Name2 = labeledPoint.Name2,
Location = toReturn,
Entrances = new List <Point3D>()
};
foreach (Point3D entrancePoint in labeledPointsFound)
{
((Store)poi).Entrances.Add(entrancePoint);
}
//context.Stores.AddOrUpdate(new Store[] { (Store)poi });
break;
}
default:
{
poi = new POI
{
Type = poi.Type,
Anchor = labeledPoint,
Enabled = true,
Name = labeledPoint.Name,
Location = toReturn
};
//poisToSave.Add(poi);
break;
}
}
poisToSave.Add(poi);
}
//return poi;
}
public static DbGeometry MakeDbGeometryFromCoordinates(double xCoordinate, double yCoordinate, int coordinateSystemId)
{
var geometry = DbGeometry.PointFromText($"POINT({xCoordinate} {yCoordinate})", coordinateSystemId);
return(geometry);
}
/// <summary>
/// Setup for Nunit Tests.
/// </summary>
protected override void OnSetup()
{
mockStreetNetworkDataService = CreateMock <IStreetNetworkDataService>();
mockNetworkManagerIntegrationService = CreateMock <INetworkManagerIntegrationService>();
mockOsRoadLinkDataService = CreateMock <IOSRoadLinkDataService>();
mockRoadNameDataService = CreateMock <IRoadNameDataService>();
loggingHelperMock = CreateMock <ILoggingHelper>();
dbGeometry = DbGeometry.PointFromText("POINT (488938 197021)", 27700);
List <SqlGeometry> listOfnetworkIntersectionPoint = new List <SqlGeometry>();
SqlGeometry networkIntersectionPoint = new SqlGeometry();
coordinates = "POLYGON ((505058.162109375 100281.69677734375, 518986.84887695312 100281.69677734375, 518986.84887695312 114158.546875, 505058.162109375 114158.546875, 505058.162109375 100281.69677734375))";
lineGeometry = DbGeometry.LineFromText("LINESTRING (512722.70000000019 104752.6799999997, 512722.70000000019 104738)", 27700);
NetworkLinkDataDTO networkLink = new NetworkLinkDataDTO()
{
ID = Guid.NewGuid(), LinkGeometry = lineGeometry
};
List <Tuple <NetworkLinkDataDTO, SqlGeometry> > listOfTuple = new List <Tuple <NetworkLinkDataDTO, SqlGeometry> > {
new Tuple <NetworkLinkDataDTO, SqlGeometry>(networkLink, networkIntersectionPoint)
};
Tuple <NetworkLinkDataDTO, SqlGeometry> tuple = new Tuple <NetworkLinkDataDTO, SqlGeometry>(networkLink, networkIntersectionPoint);
referenceDataCategoryDTOList = new List <ReferenceDataCategoryDTO>()
{
new ReferenceDataCategoryDTO()
{
ReferenceDatas = new List <ReferenceDataDTO>()
{
new ReferenceDataDTO()
{
ReferenceDataValue = FileType.Nyb.ToString(),
ID = Guid.NewGuid(),
}
},
CategoryName = PostalAddressType
}
};
// Setup Methods.
mockNetworkManagerIntegrationService.Setup(x => x.GetReferenceDataSimpleLists(It.IsAny <List <string> >())).ReturnsAsync(referenceDataCategoryDTOList);
mockNetworkManagerIntegrationService.Setup(x => x.GetReferenceDataNameValuePairs(It.IsAny <List <string> >())).ReturnsAsync(referenceDataCategoryDTOList);
mockStreetNetworkDataService.Setup(x => x.GetNearestNamedRoad(It.IsAny <DbGeometry>(), It.IsAny <string>(), It.IsAny <List <ReferenceDataCategoryDTO> >())).Returns(tuple);
mockStreetNetworkDataService.Setup(x => x.GetNearestSegment(It.IsAny <DbGeometry>(), It.IsAny <List <ReferenceDataCategoryDTO> >())).Returns(listOfTuple);
mockStreetNetworkDataService.Setup(x => x.GetNetworkLink(It.IsAny <Guid>())).Returns(networkLink);
mockStreetNetworkDataService.Setup(x => x.GetCrossingNetworkLink(It.IsAny <string>(), It.IsAny <DbGeometry>())).Returns(new List <NetworkLinkDataDTO>()
{
networkLink
});
mockStreetNetworkDataService.Setup(x => x.GetStreetNamesForBasicSearch(It.IsAny <string>(), It.IsAny <Guid>(), "Delivery Office")).ReturnsAsync(new List <StreetNameDataDTO>()
{
new StreetNameDataDTO()
{
LocalName = "abc"
}
});
mockStreetNetworkDataService.Setup(x => x.GetStreetNameCount(It.IsAny <string>(), It.IsAny <Guid>(), "Delivery Office")).ReturnsAsync(5);
mockStreetNetworkDataService.Setup(x => x.GetStreetNamesForAdvanceSearch(It.IsAny <string>(), It.IsAny <Guid>(), "Delivery Office")).ReturnsAsync(new List <StreetNameDataDTO>()
{
new StreetNameDataDTO()
{
LocalName = "abc"
}
});
mockOsRoadLinkDataService.Setup(x => x.GetOSRoadLink(It.IsAny <string>())).ReturnsAsync("abc");
mockRoadNameDataService.Setup(x => x.GetRoadRoutes(It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <List <ReferenceDataCategoryDTO> >(), It.IsAny <string>())).Returns(new List <NetworkLinkDataDTO>()
{
networkLink
});
// Setup for IRMTraceManager.
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
loggingHelperMock.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
testCandidate = new NetworkManagerBusinessService(mockStreetNetworkDataService.Object, mockNetworkManagerIntegrationService.Object, mockOsRoadLinkDataService.Object, mockRoadNameDataService.Object, loggingHelperMock.Object);
}
protected override void OnSetup()
{
currentUserUnitType = "Delivery Office";
var deliveryPoint = new List <DeliveryPoint>()
{
new DeliveryPoint()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
PostalAddressID = new Guid("619AF1F3-AE0C-4157-9BDE-A7528C1482BA"),
DeliveryPointUseIndicatorGUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A14"),
RowVersion = new byte[] { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 },
PostalAddress = new PostalAddress()
{
BuildingName = "road bldg2",
BuildingNumber = 1,
SubBuildingName = "road subbldg1",
OrganisationName = "org",
DepartmentName = "department",
Thoroughfare = "road ThoroughFare1",
DependentThoroughfare = "DependentThoroughFare1",
Postcode = "road PostcodeNew",
PostTown = "PostTown",
POBoxNumber = "POBoxNumber",
UDPRN = 12345,
PostcodeType = "xyz",
SmallUserOrganisationIndicator = "indicator",
DeliveryPointSuffix = "DeliveryPointSuffix",
AddressType_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19"),
ID = new Guid("619AF1F3-AE0C-4157-9BDE-A7528C1482BA"),
},
DeliveryPointStatus = new List <DeliveryPointStatus>()
{
new DeliveryPointStatus()
{
LocationID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13")
}
},
NetworkNode = new NetworkNode()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
Location = new Location()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
Shape = DbGeometry.PointFromText("POINT (488938 197021)", 27700)
}
},
}
};
var location = new List <Location>()
{
new Location()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
Shape = DbGeometry.PointFromText("POINT (488938 197021)", 27700),
RowCreateDateTime = DateTime.Now,
NetworkNode = new NetworkNode()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
DeliveryPoint = new DeliveryPoint()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
PostalAddressID = new Guid("619AF1F3-AE0C-4157-9BDE-A7528C1482BA"),
DeliveryPointUseIndicatorGUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A14")
}
}
//,
//LocationOfferings = new List<LocationOffering>() {
// new LocationOffering
// {
// ID= new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
// }
//}
}
};
var networkNode = new List <NetworkNode>()
{
new NetworkNode()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
Location = new Location()
{
Shape = DbGeometry.PointFromText("POINT (488938 197021)", 27700)
}
}
};
var postalAddress = new List <PostalAddress>
{
new PostalAddress()
{
BuildingName = "road bldg2",
BuildingNumber = 1,
SubBuildingName = "road subbldg1",
OrganisationName = "org",
DepartmentName = "department",
Thoroughfare = "road ThoroughFare1",
DependentThoroughfare = "DependentThoroughFare1",
Postcode = "road PostcodeNew",
PostTown = "PostTown",
POBoxNumber = "POBoxNumber",
UDPRN = 12345,
PostcodeType = "xyz",
SmallUserOrganisationIndicator = "indicator",
DeliveryPointSuffix = "DeliveryPointSuffix",
AddressType_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19"),
ID = new Guid("619AF1F3-AE0C-4157-9BDE-A7528C1482BA")
},
};
var deliveryPointStatus = new List <DeliveryPointStatus>()
{
new DeliveryPointStatus()
{
LocationID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13")
}
};
var locationOfferings = new List <LocationOffering>()
{
new LocationOffering
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
Offering = new Offering()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13")
}
}
};
mockLoggingHelper = CreateMock <ILoggingHelper>();
mockRMDBContext = CreateMock <DeliveryPointDBContext>();
// setup for Deliverypoint
var mockAsynEnumerable = new DbAsyncEnumerable <DeliveryPoint>(deliveryPoint);
var mockDeliveryPointDataService = MockDbSet(deliveryPoint);
mockDeliveryPointDataService.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable.AsQueryable().Provider);
mockDeliveryPointDataService.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable.AsQueryable().Expression);
mockDeliveryPointDataService.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable.AsQueryable().ElementType);
mockDeliveryPointDataService.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <DeliveryPoint>)mockAsynEnumerable).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <DeliveryPoint>()).Returns(mockDeliveryPointDataService.Object);
mockRMDBContext.Setup(x => x.DeliveryPoints).Returns(mockDeliveryPointDataService.Object);
mockDeliveryPointDataService.Setup(x => x.Include(It.IsAny <string>())).Returns(mockDeliveryPointDataService.Object);
mockDeliveryPointDataService.Setup(x => x.AsNoTracking()).Returns(mockDeliveryPointDataService.Object);
// setup for location
var mockAsynEnumerable1 = new DbAsyncEnumerable <Location>(location);
var mockLocation = MockDbSet(location);
mockLocation.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable1.AsQueryable().Provider);
mockLocation.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable1.AsQueryable().Expression);
mockLocation.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable1.AsQueryable().ElementType);
mockLocation.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Location>)mockAsynEnumerable1).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <Location>()).Returns(mockLocation.Object);
mockRMDBContext.Setup(x => x.Locations).Returns(mockLocation.Object);
mockLocation.Setup(x => x.Include(It.IsAny <string>())).Returns(mockLocation.Object);
mockLocation.Setup(x => x.AsNoTracking()).Returns(mockLocation.Object);
// setup for networknode
var mockAsynNetworkNode = new DbAsyncEnumerable <NetworkNode>(networkNode);
var mocknetworkNode = MockDbSet(networkNode);
mocknetworkNode.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynNetworkNode.AsQueryable().Provider);
mocknetworkNode.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynNetworkNode.AsQueryable().Expression);
mocknetworkNode.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynNetworkNode.AsQueryable().ElementType);
mocknetworkNode.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <NetworkNode>)mockAsynNetworkNode).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <NetworkNode>()).Returns(mocknetworkNode.Object);
mockRMDBContext.Setup(x => x.NetworkNodes).Returns(mocknetworkNode.Object);
mocknetworkNode.Setup(x => x.Include(It.IsAny <string>())).Returns(mocknetworkNode.Object);
mocknetworkNode.Setup(x => x.AsNoTracking()).Returns(mocknetworkNode.Object);
// setup for PostalAdress
var mockAsynPostalAdress = new DbAsyncEnumerable <PostalAddress>(postalAddress);
var mocknpostalAddresse = MockDbSet(postalAddress);
mocknpostalAddresse.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynPostalAdress.AsQueryable().Provider);
mocknpostalAddresse.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynPostalAdress.AsQueryable().Expression);
mocknpostalAddresse.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynPostalAdress.AsQueryable().ElementType);
mocknpostalAddresse.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <PostalAddress>)mockAsynPostalAdress).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <PostalAddress>()).Returns(mocknpostalAddresse.Object);
mockRMDBContext.Setup(x => x.PostalAddresses).Returns(mocknpostalAddresse.Object);
mocknpostalAddresse.Setup(x => x.Include(It.IsAny <string>())).Returns(mocknpostalAddresse.Object);
mocknpostalAddresse.Setup(x => x.AsNoTracking()).Returns(mocknpostalAddresse.Object);
// setup for delivery point status
var mockAsyndpStatus = new DbAsyncEnumerable <DeliveryPointStatus>(deliveryPointStatus);
var mockdpStatus = MockDbSet(deliveryPointStatus);
mockdpStatus.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsyndpStatus.AsQueryable().Provider);
mockdpStatus.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsyndpStatus.AsQueryable().Expression);
mockdpStatus.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsyndpStatus.AsQueryable().ElementType);
mockdpStatus.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <DeliveryPointStatus>)mockAsyndpStatus).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <DeliveryPointStatus>()).Returns(mockdpStatus.Object);
mockRMDBContext.Setup(x => x.DeliveryPointStatus).Returns(mockdpStatus.Object);
mockdpStatus.Setup(x => x.Include(It.IsAny <string>())).Returns(mockdpStatus.Object);
mockdpStatus.Setup(x => x.AsNoTracking()).Returns(mockdpStatus.Object);
// setup for location offerings
var mockAsynlocOfferings = new DbAsyncEnumerable <LocationOffering>(locationOfferings);
var mocklocOfferings = MockDbSet(locationOfferings);
mocklocOfferings.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynlocOfferings.AsQueryable().Provider);
mocklocOfferings.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynlocOfferings.AsQueryable().Expression);
mocklocOfferings.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynlocOfferings.AsQueryable().ElementType);
mocklocOfferings.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <LocationOffering>)mockAsynlocOfferings).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <LocationOffering>()).Returns(mocklocOfferings.Object);
mockRMDBContext.Setup(x => x.LocationOfferings).Returns(mocklocOfferings.Object);
mocklocOfferings.Setup(x => x.Include(It.IsAny <string>())).Returns(mocklocOfferings.Object);
mocklocOfferings.Setup(x => x.AsNoTracking()).Returns(mocklocOfferings.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockLoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
// mockConfigurationHelper = new Mock<IConfigurationHelper>();
mockDatabaseFactory = CreateMock <IDatabaseFactory <DeliveryPointDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockRMDBContext.Object);
mockRMDBContext.Setup(n => n.SaveChangesAsync()).ReturnsAsync(1);
testCandidate = new DeliveryPointsDataService(mockDatabaseFactory.Object, mockLoggingHelper.Object);
}
protected override void OnSetup()
{
// OnSetup to be configured
referenceDataCategoryDTOList = new List <CommonLibrary.EntityFramework.DTO.ReferenceDataCategoryDTO>()
{
new CommonLibrary.EntityFramework.DTO.ReferenceDataCategoryDTO()
{
ReferenceDatas = new List <CommonLibrary.EntityFramework.DTO.ReferenceDataDTO>()
{
new CommonLibrary.EntityFramework.DTO.ReferenceDataDTO()
{
ReferenceDataValue = FileType.Nyb.ToString(),
ID = Guid.NewGuid(),
}
},
CategoryName = PostalAddressType
},
new CommonLibrary.EntityFramework.DTO.ReferenceDataCategoryDTO()
{
ReferenceDatas = new List <CommonLibrary.EntityFramework.DTO.ReferenceDataDTO>()
{
new CommonLibrary.EntityFramework.DTO.ReferenceDataDTO()
{
ReferenceDataValue = FileType.Usr.ToString(),
ID = Guid.NewGuid(),
}
},
CategoryName = PostalAddressType
},
new CommonLibrary.EntityFramework.DTO.ReferenceDataCategoryDTO()
{
ReferenceDatas = new List <CommonLibrary.EntityFramework.DTO.ReferenceDataDTO>()
{
new CommonLibrary.EntityFramework.DTO.ReferenceDataDTO()
{
ReferenceDataValue = FileType.Paf.ToString(),
ID = new Guid("A08C5212-6123-4EAF-9C27-D4A8035A8974"),
}
},
CategoryName = PostalAddressType
},
new CommonLibrary.EntityFramework.DTO.ReferenceDataCategoryDTO()
{
ReferenceDatas = new List <CommonLibrary.EntityFramework.DTO.ReferenceDataDTO>()
{
new CommonLibrary.EntityFramework.DTO.ReferenceDataDTO()
{
ReferenceDataValue = PostCodeStatus.Live.GetDescription(),
ID = Guid.NewGuid(),
}
},
CategoryName = PostalAddressStatus
},
new CommonLibrary.EntityFramework.DTO.ReferenceDataCategoryDTO()
{
ReferenceDatas = new List <CommonLibrary.EntityFramework.DTO.ReferenceDataDTO>()
{
new CommonLibrary.EntityFramework.DTO.ReferenceDataDTO()
{
ReferenceDataValue = PostCodeStatus.PendingDeleteInFMO.GetDescription(),
ID = Guid.NewGuid(),
}
},
CategoryName = PostalAddressStatus
}
};
AddressLocationDTO addressLocationDTO = new AddressLocationDTO()
{
UDPRN = 1234,
LocationXY = DbGeometry.PointFromText("POINT(512722.70000000019 104752.6799999997)", 27700)
};
PostalAddressDataDTO postalAddressDataDTO = new PostalAddressDataDTO()
{
Postcode = "YO23 1DQ",
PostTown = "York",
UDPRN = 54162429,
DeliveryPointSuffix = "1A",
AddressType_GUID = new Guid("A08C5212-6123-4EAF-9C27-D4A8035A8974")
};
PostalAddressDTO postalAddressDTO = new PostalAddressDTO()
{
ID = Guid.Empty
};
mockPostalAddressDataService = CreateMock <IPostalAddressDataService>();
// mockFileProcessingLogDataService = CreateMock<IFileProcessingLogDataService>();
mockConfigurationHelper = CreateMock <IConfigurationHelper>();
mockLoggingHelper = CreateMock <ILoggingHelper>();
mockHttpHandler = CreateMock <IHttpHandler>();
mockPostalAddressIntegrationService = CreateMock <IPostalAddressIntegrationService>();
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockLoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
mockPostalAddressIntegrationService.Setup(n => n.GetReferenceDataSimpleLists(It.IsAny <string>())).Returns(Task.FromResult(referenceDataCategoryDTOList[2]));
mockPostalAddressIntegrationService.Setup(n => n.GetReferenceDataSimpleLists(It.IsAny <List <string> >())).Returns(Task.FromResult(referenceDataCategoryDTOList));
mockPostalAddressIntegrationService.Setup(n => n.GetReferenceDataGuId(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(Guid.NewGuid()));
mockPostalAddressIntegrationService.Setup(n => n.GetAddressLocationByUDPRN(It.IsAny <int>())).Returns(Task.FromResult(addressLocationDTO));
mockPostalAddressDataService.Setup(n => n.DeleteNYBPostalAddress(It.IsAny <List <int> >(), It.IsAny <Guid>())).Returns(Task.FromResult(true));
mockPostalAddressDataService.Setup(n => n.GetPostalAddresses(It.IsAny <List <Guid> >())).ReturnsAsync(new List <PostalAddressDataDTO>()
{
new PostalAddressDataDTO()
{
Postcode = "1234"
}
});
mockPostalAddressDataService.Setup(n => n.CheckForDuplicateNybRecords(It.IsAny <PostalAddressDataDTO>(), It.IsAny <Guid>())).Returns("PO1234");
mockPostalAddressDataService.Setup(n => n.CheckForDuplicateAddressWithDeliveryPoints(It.IsAny <PostalAddressDataDTO>())).Returns(Task.FromResult(true));
mockPostalAddressDataService.Setup(n => n.CreateAddressForDeliveryPoint(It.IsAny <PostalAddressDataDTO>())).Returns(addressTypeGUID);
mockPostalAddressDataService.Setup(n => n.GetPostalAddress(It.IsAny <int>())).Returns(Task.FromResult(postalAddressDataDTO));
mockPostalAddressDataService.Setup(n => n.GetPAFAddress(It.IsAny <int>(), It.IsAny <Guid>())).Returns(Task.FromResult(postalAddressDTO));
// mockFileProcessingLogDataService.Setup(x => x.LogFileException(It.IsAny<FileProcessingLogDTO>()));
testCandidate = new DataManagement.PostalAddress.WebAPI.BusinessService.Implementation.PostalAddressBusinessService(mockPostalAddressDataService.Object, mockLoggingHelper.Object, mockConfigurationHelper.Object, mockHttpHandler.Object, mockPostalAddressIntegrationService.Object);
}
/// <summary>
/// Setup data
/// </summary>
protected override void OnSetup()
{
currentUserUnit = "Delivery Office";
mockDeliveryPointsDataService = CreateMock <IDeliveryPointsDataService>();
mockConfigurationDataService = CreateMock <IConfigurationHelper>();
mockLoggingDataService = CreateMock <ILoggingHelper>();
mockDeliveryPointIntegrationService = CreateMock <IDeliveryPointIntegrationService>();
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockLoggingDataService.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
List <DeliveryPointDTO> lstDeliveryPointDTO = new List <DeliveryPointDTO>();
List <RM.CommonLibrary.EntityFramework.Entities.DeliveryPoint> lstDeliveryPoint = new List <RM.CommonLibrary.EntityFramework.Entities.DeliveryPoint>();
List <PostalAddressDataDTO> lstPostalAddressDTO = new List <PostalAddressDataDTO>()
{
new PostalAddressDataDTO
{
BuildingName = "Bldg 1",
BuildingNumber = 23,
Postcode = "123"
}
};
deliveryPointDTO = new DeliveryPointDTO()
{
ID = Guid.NewGuid()
};
postalAddressesDTO = new List <PostalAddressDTO>()
{
new PostalAddressDTO()
{
BuildingName = "bldg1",
BuildingNumber = 1,
SubBuildingName = "subbldg",
OrganisationName = "org",
DepartmentName = "department",
Thoroughfare = "ThoroughFare1",
DependentThoroughfare = "DependentThoroughFare1",
Postcode = "PostcodeNew",
PostTown = "PostTown",
POBoxNumber = "POBoxNumber",
UDPRN = 12345,
PostcodeType = "xyz",
SmallUserOrganisationIndicator = "indicator",
DeliveryPointSuffix = "DeliveryPointSuffix",
PostCodeGUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A15"),
AddressType_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A11"),
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A12")
},
new PostalAddressDTO()
{
BuildingName = "bldg1",
BuildingNumber = 1,
SubBuildingName = "subbldg",
OrganisationName = "org",
DepartmentName = "department",
Thoroughfare = "ThoroughFare1",
DependentThoroughfare = "DependentThoroughFare1",
Postcode = "Postcode",
PostTown = "PostTown",
POBoxNumber = "POBoxNumber",
UDPRN = 12345,
PostcodeType = "xyz",
SmallUserOrganisationIndicator = "indicator",
DeliveryPointSuffix = "DeliveryPointSuffix",
PostCodeGUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A15"),
AddressType_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A11"),
ID = Guid.Empty
},
new PostalAddressDTO()
{
BuildingName = "bldg1",
BuildingNumber = 1,
SubBuildingName = "subbldg",
OrganisationName = null,
DepartmentName = "department",
Thoroughfare = "ThoroughFare1",
DependentThoroughfare = "DependentThoroughFare1",
Postcode = "Postcode",
PostTown = "PostTown",
POBoxNumber = "POBoxNumber",
UDPRN = 12345,
PostcodeType = "xyz",
SmallUserOrganisationIndicator = "indicator",
DeliveryPointSuffix = "DeliveryPointSuffix",
PostCodeGUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A15"),
AddressType_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A11"),
ID = Guid.Empty
}
};
addDeliveryPointDTO = new AddDeliveryPointDTO()
{
PostalAddressDTO = postalAddressesDTO[0],
DeliveryPointDTO = deliveryPointDTO,
RangeType = "Odds",
DeliveryPointType = "Range",
FromRange = 2,
ToRange = 11,
};
addDeliveryPointDTO1 = new AddDeliveryPointDTO()
{
PostalAddressDTO = postalAddressesDTO[1],
DeliveryPointDTO = deliveryPointDTO
};
deliveryPointModelDTO = new DeliveryPointModelDTO()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A11"),
XCoordinate = 12,
YCoordinate = 10,
UDPRN = 123,
Latitude = 1,
Longitude = 2,
RowVersion = BitConverter.GetBytes(1)
};
actualDeliveryPointDataDto = new List <DeliveryPointDataDTO>()
{
new DeliveryPointDataDTO()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A11"),
MailVolume = 5, PostalAddress = new PostalAddressDataDTO()
{
BuildingName = "bldg1",
BuildingNumber = 1,
SubBuildingName = "subbldg",
OrganisationName = "org",
DepartmentName = "department",
Thoroughfare = "ThoroughFare1",
DependentThoroughfare = "DependentThoroughFare1",
Postcode = "PostcodeNew",
PostTown = "PostTown",
POBoxNumber = "POBoxNumber",
UDPRN = 12345,
PostcodeType = "xyz",
SmallUserOrganisationIndicator = "indicator",
DeliveryPointSuffix = "DeliveryPointSuffix",
PostCodeGUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A15"),
AddressType_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A11"),
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A12")
},
NetworkNode = new NetworkNodeDataDTO
{
ID = Guid.Empty, NetworkNodeType_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19"), Location = new LocationDataDTO()
{
Shape = DbGeometry.PointFromText("POINT(512722.70000000019 104752.6799999997)", 27700)
}
},
DeliveryPointStatus = new List <DeliveryPointStatusDataDTO>()
{
new DeliveryPointStatusDataDTO
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19")
}
}
},
new DeliveryPointDataDTO()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A17"),
MailVolume = 2, PostalAddress = new PostalAddressDataDTO()
{
BuildingName = "bldg2",
BuildingNumber = 1,
SubBuildingName = "subbldg1",
OrganisationName = "org",
DepartmentName = "department",
Thoroughfare = "ThoroughFare1",
DependentThoroughfare = "DependentThoroughFare1",
Postcode = "PostcodeNew",
PostTown = "PostTown",
POBoxNumber = "POBoxNumber",
UDPRN = 12345,
PostcodeType = "xyz",
SmallUserOrganisationIndicator = "indicator",
DeliveryPointSuffix = "DeliveryPointSuffix",
PostCodeGUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A15"),
AddressType_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19"),
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19")
},
NetworkNode = new NetworkNodeDataDTO
{
ID = Guid.Empty,
NetworkNodeType_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19"),
Location = new LocationDataDTO()
{
Shape = DbGeometry.PointFromText("POINT(512722.70000000019 104752.6799999997)", 27700)
}
},
DeliveryPointStatus = new List <DeliveryPointStatusDataDTO>()
{
new DeliveryPointStatusDataDTO
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19")
}
}
}
};
actualDeliveryPointDTO = new DeliveryPointDataDTO()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A17"),
MailVolume = 2,
PostalAddress = new PostalAddressDataDTO()
{
BuildingName = "bldg2",
BuildingNumber = 1,
SubBuildingName = "subbldg1",
OrganisationName = "org",
DepartmentName = "department",
Thoroughfare = "ThoroughFare1",
DependentThoroughfare = "DependentThoroughFare1",
Postcode = "PostcodeNew",
PostTown = "PostTown",
POBoxNumber = "POBoxNumber",
UDPRN = 12345,
PostcodeType = "xyz",
SmallUserOrganisationIndicator = "indicator",
DeliveryPointSuffix = "DeliveryPointSuffix",
PostCodeGUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A15"),
AddressType_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19"),
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19")
},
NetworkNode = new NetworkNodeDataDTO {
ID = Guid.Empty, NetworkNodeType_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19"), Location = new LocationDataDTO()
{
Shape = DbGeometry.PointFromText("POINT(512722.70000000019 104752.6799999997)", 27700)
}
},
DeliveryPointStatus = new List <DeliveryPointStatusDataDTO>()
{
new DeliveryPointStatusDataDTO {
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19")
}
}
};
AddDeliveryPointDTO actualAddDeliveryPointDTO = new AddDeliveryPointDTO()
{
PostalAddressDTO = new PostalAddressDTO()
{
BuildingName = "bldg2",
BuildingNumber = 1,
SubBuildingName = "subbldg1",
OrganisationName = "org",
DepartmentName = "department",
Thoroughfare = "ThoroughFare1",
DependentThoroughfare = "DependentThoroughFare1",
Postcode = "PostcodeNew",
PostTown = "PostTown",
POBoxNumber = "POBoxNumber",
UDPRN = 12345,
PostcodeType = "xyz",
SmallUserOrganisationIndicator = "indicator",
DeliveryPointSuffix = "DeliveryPointSuffix",
PostCodeGUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A15"),
AddressType_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19"),
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19")
}
};
var locationXy = DbGeometry.PointFromText("POINT(512722.70000000019 104752.6799999997)", 27700);
DbGeometry location = DbGeometry.PointFromText("POINT (488938 197021)", 27700);
List <RM.CommonLibrary.EntityFramework.DTO.ReferenceDataCategoryDTO> referenceData = GetReferenceDataCategory();
double xLocation = 399545.5590911182;
double yLocation = 649744.6394892789;
routeDTO = new RouteDTO
{
RouteName = "Route-001",
RouteNumber = "001"
};
mockDeliveryPointsDataService.Setup(x => x.GetDeliveryPoints(It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <string>())).Returns(actualDeliveryPointDataDto);
mockDeliveryPointsDataService.Setup(x => x.GetDeliveryPoint(It.IsAny <Guid>())).Returns(actualDeliveryPointDTO);
mockDeliveryPointsDataService.Setup(x => x.GetDetailDeliveryPointByUDPRN(It.IsAny <int>())).Returns(actualAddDeliveryPointDTO);
mockDeliveryPointsDataService.Setup(x => x.GetDeliveryPointsForBasicSearch(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <Guid>(), currentUserUnit)).ReturnsAsync(actualDeliveryPointDataDto);
mockDeliveryPointsDataService.Setup(x => x.GetDeliveryPointsCount(It.IsAny <string>(), It.IsAny <Guid>(), currentUserUnit)).ReturnsAsync(actualDeliveryPointDataDto.Count);
mockDeliveryPointsDataService.Setup(x => x.GetDeliveryPointsForAdvanceSearch(It.IsAny <string>(), It.IsAny <Guid>(), currentUserUnit)).ReturnsAsync(actualDeliveryPointDataDto);
// GetDeliveryPointsForAdvanceSearch
mockDeliveryPointsDataService.Setup(x => x.UpdateDeliveryPointLocationOnUDPRN(It.IsAny <DeliveryPointDataDTO>())).Returns(Task.FromResult(1));
mockDeliveryPointsDataService.Setup(x => x.UpdatePAFIndicator(It.IsAny <Guid>(), It.IsAny <Guid>())).ReturnsAsync(true);
mockDeliveryPointIntegrationService.Setup(x => x.CheckForDuplicateNybRecords(It.IsAny <PostalAddressDTO>())).Returns(Task.FromResult("ABC"));
mockDeliveryPointIntegrationService.Setup(x => x.CheckForDuplicateAddressWithDeliveryPoints(It.IsAny <PostalAddressDTO>())).Returns(Task.FromResult(true));
mockDeliveryPointIntegrationService.Setup(x => x.CreateAddressForDeliveryPoint(It.IsAny <AddDeliveryPointDTO>())).ReturnsAsync(new CreateDeliveryPointModelDTO()
{
ID = Guid.NewGuid(), IsAddressLocationAvailable = true, Message = "Delivery Point Created", XCoordinate = xLocation, YCoordinate = yLocation
});
mockDeliveryPointIntegrationService.Setup(x => x.GetReferenceDataSimpleLists(It.IsAny <List <string> >())).ReturnsAsync(referenceData);
mockDeliveryPointIntegrationService.Setup(x => x.GetApproxLocation(It.IsAny <string>())).ReturnsAsync(location);
mockDeliveryPointsDataService.Setup(x => x.InsertDeliveryPoint(It.IsAny <DeliveryPointDataDTO>())).ReturnsAsync(Guid.NewGuid());
mockDeliveryPointsDataService.Setup(x => x.GetDeliveryPointRowVersion(It.IsAny <Guid>())).Returns(BitConverter.GetBytes(1));
mockDeliveryPointIntegrationService.Setup(x => x.MapRouteForDeliveryPoint(It.IsAny <Guid>(), It.IsAny <Guid>())).ReturnsAsync(true);
mockDeliveryPointIntegrationService.Setup(x => x.GetReferenceDataGuId(It.IsAny <string>(), It.IsAny <string>())).Returns(Guid.NewGuid());
mockDeliveryPointsDataService.Setup(x => x.UpdateDeliveryPointLocationOnID(It.IsAny <DeliveryPointDataDTO>())).ReturnsAsync(Guid.NewGuid());
mockDeliveryPointIntegrationService.Setup(x => x.CreateAddressForDeliveryPointForRange(It.IsAny <List <PostalAddressDTO> >())).ReturnsAsync(new List <CreateDeliveryPointModelDTO> {
new CreateDeliveryPointModelDTO()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A12"), IsAddressLocationAvailable = true, Message = "Delivery Point Created", XCoordinate = xLocation, YCoordinate = yLocation
}
});
mockDeliveryPointIntegrationService.Setup(x => x.GetRouteForDeliveryPoint(It.IsAny <Guid>())).ReturnsAsync(routeDTO);
mockDeliveryPointsDataService.Setup(x => x.DeliveryPointExists(It.IsAny <int>())).ReturnsAsync(true);
mockDeliveryPointsDataService.Setup(x => x.UpdateDeliveryPointLocationOnUDPRN(It.IsAny <DeliveryPointDataDTO>())).ReturnsAsync(5);
mockDeliveryPointIntegrationService.Setup(x => x.CreateAccessLink(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(true);
mockDeliveryPointIntegrationService.Setup(x => x.CheckForDuplicateNybRecords(It.IsAny <PostalAddressDTO>())).ReturnsAsync("123");
mockDeliveryPointsDataService.Setup(x => x.GetDeliveryPointByUDPRN(It.IsAny <int>())).ReturnsAsync(actualDeliveryPointDTO);
mockDeliveryPointsDataService.Setup(x => x.GetDeliveryPointByPostalAddress(It.IsAny <Guid>())).Returns(actualDeliveryPointDTO);
mockDeliveryPointsDataService.Setup(x => x.GetDeliveryPointsCrossingOperationalObject(It.IsAny <string>(), It.IsAny <DbGeometry>())).Returns(actualDeliveryPointDataDto);
mockDeliveryPointsDataService.Setup(x => x.GetDeliveryPoint(It.IsAny <Guid>())).Returns(actualDeliveryPointDTO);
mockDeliveryPointsDataService.Setup(x => x.GetDeliveryPointByPostalAddressWithLocation(It.IsAny <Guid>())).ReturnsAsync(actualDeliveryPointDTO);
testCandidate = new DeliveryPointBusinessService(mockDeliveryPointsDataService.Object, mockLoggingDataService.Object, mockConfigurationDataService.Object, mockDeliveryPointIntegrationService.Object);
}
/// <summary>
/// Setup for Nunit Tests.
/// </summary>
protected override void OnSetup()
{
accessLinkManualCreateModelDTO = new AccessLinkManualCreateModelDTO
{
AccessLinkLine = "[[512455.33999999985,107127.7899999991],[512454.8208646417,107129.43228437999],[512474,107139]]",
BoundingBoxCoordinates = "511684.44432227453,106504.23168359262,513419.32779204147,107103.43288199503",
NetworkLinkGUID = "c55712fe-ce92-4386-a0a5-e9a158b15441",
OperationalObjectGUID = "ffc86397-fbb5-4caf-a070-aca8d723de57",
Workloadlength = 40,
NetworkIntersectionPoint = "[512455.33999999985,107127.7899999991]",
OperationalObjectPoint = "[512455.33999999985,107127.7899999991]"
};
deliveryPointDTO = new DeliveryPointDTO
{
LocationXY = DbGeometry.PointFromText("POINT (488938 197021)", 27700),
Latitude = (decimal)50.83133590,
Longitude = (decimal) - 0.40071150,
Positioned = true,
UDPRN = 2364534,
PostalAddress = new RM.CommonLibrary.EntityFramework.DTO.PostalAddressDTO
{
Thoroughfare = "Salvington Gardens"
},
DeliveryPointUseIndicator_GUID = Guid.Parse("178EDCAD-9431-E711-83EC-28D244AEF9ED")
};
accessLinkDTO = new List <AccessLinkDTO>()
{
new AccessLinkDTO()
{
ID = Guid.Parse("3981AD3B-D253-4BD9-AB82-000094D8EE67"),
OperationalObjectPoint = DbGeometry.PointFromText("POINT (488938 197021)", 27700),
NetworkIntersectionPoint = DbGeometry.PointFromText("POINT (488929.9088937093 197036.37310195228)", 27700),
AccessLinkLine = DbGeometry.LineFromText("LINESTRING (488938 197021, 488929.9088937093 197036.37310195228)", 27700),
NetworkLink_GUID = Guid.Parse("4DBA7B39-D23E-493A-9B8F-B94D181A082F")
}
};
networkLink = new NetworkLinkDTO
{
Id = Guid.Parse("4DBA7B39-D23E-493A-9B8F-B94D181A082F"),
TOID = "osgb4000000023358315",
NetworkLinkType_GUID = Guid.Parse("09CE57B1-AF13-4F8E-B4AF-1DE35B4A68A8"),
LinkGeometry = DbGeometry.LineFromText("LINESTRING (488952 197048, 488895 197018, 488888 197014, 488880 197008)", 27700)
};
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
SqlGeometry networkIntersectionPoint = SqlGeometry.Null;
List <SqlGeometry> lstnetworkIntersectionPoint = new List <SqlGeometry>();
try
{
networkIntersectionPoint = accessLinkDTO[0].OperationalObjectPoint.ToSqlGeometry().ShortestLineTo(networkLink.LinkGeometry.ToSqlGeometry()).STEndPoint();
lstnetworkIntersectionPoint.Add(networkIntersectionPoint);
}
catch (Exception)
{
}
Tuple <NetworkLinkDTO, SqlGeometry> tuple = new Tuple <NetworkLinkDTO, SqlGeometry>(networkLink, networkIntersectionPoint);
List <Tuple <NetworkLinkDTO, SqlGeometry> > tuple1 = new List <Tuple <NetworkLinkDTO, SqlGeometry> > {
new Tuple <NetworkLinkDTO, SqlGeometry>(networkLink, networkIntersectionPoint)
};
List <ReferenceDataCategoryDTO> refDataCategotyDTO = new List <ReferenceDataCategoryDTO>()
{
new ReferenceDataCategoryDTO()
{
CategoryName = ReferenceDataCategoryNames.AccessLinkType,
ReferenceDatas = new List <ReferenceDataDTO>()
{
new ReferenceDataDTO()
{
ReferenceDataName = null,
ReferenceDataValue = ReferenceDataValues.AccessLinkTypeDefault,
ID = Guid.Parse("4DBA7B39-D23E-493A-9B8F-B94D181A082F")
},
new ReferenceDataDTO()
{
ReferenceDataName = null,
ReferenceDataValue = ReferenceDataValues.UserDefined,
ID = Guid.Parse("DA8F1A91-2E2B-4EEF-9A81-9B18A917CBF1")
}
}
},
new ReferenceDataCategoryDTO()
{
CategoryName = ReferenceDataCategoryNames.AccessLinkDirection,
ReferenceDatas = new List <ReferenceDataDTO>()
{
new ReferenceDataDTO()
{
ReferenceDataName = null,
ReferenceDataValue = ReferenceDataValues.AccessLinkDirectionBoth,
ID = Guid.Parse("5DBA7B39-D23E-493A-9B8F-B94D181A082F")
}
}
},
new ReferenceDataCategoryDTO()
{
CategoryName = ReferenceDataCategoryNames.AccessLinkStatus,
ReferenceDatas = new List <ReferenceDataDTO>()
{
new ReferenceDataDTO()
{
ReferenceDataName = null,
ReferenceDataValue = ReferenceDataValues.AccessLinkStatusLive,
ID = Guid.Parse("6DBA7B39-D23E-493A-9B8F-B94D181A082F")
},
new ReferenceDataDTO()
{
ReferenceDataName = null,
ReferenceDataValue = ReferenceDataValues.AccessLinkStatusDraftPendingApproval,
ID = Guid.Parse("7DBA7B39-D23E-493A-9B8F-B94D181A082F")
},
new ReferenceDataDTO()
{
ReferenceDataName = null,
ReferenceDataValue = ReferenceDataValues.AccessLinkStatusDraftPendingReview,
ID = Guid.Parse("7B90B2F9-F62F-E711-8735-28D244AEF9ED")
}
}
},
new ReferenceDataCategoryDTO()
{
CategoryName = ReferenceDataCategoryNames.OperationalObjectType,
ReferenceDatas = new List <ReferenceDataDTO>()
{
new ReferenceDataDTO()
{
ReferenceDataName = ReferenceDataValues.OperationalObjectTypeDP,
ReferenceDataValue = ReferenceDataValues.OperationalObjectTypeDP,
ID = Guid.Parse("415c9129-0615-457e-98b7-3a60436320c5")
}
}
},
new ReferenceDataCategoryDTO()
{
CategoryName = ReferenceDataCategoryNames.AccessLinkParameters,
ReferenceDatas = new List <ReferenceDataDTO>()
{
new ReferenceDataDTO()
{
ReferenceDataName = ReferenceDataValues.AccessLinkSameRoadMaxDistance,
ReferenceDataValue = "25",
ID = Guid.Parse("9DBA7B39-D23E-493A-9B8F-B94D181A082F")
},
new ReferenceDataDTO()
{
ReferenceDataName = ReferenceDataValues.AccessLinkDiffRoadMaxDistance,
ReferenceDataValue = "1",
ID = Guid.Parse("3DBA7B39-D23E-493A-9B8F-B94D181A081F")
},
}
},
new ReferenceDataCategoryDTO()
{
CategoryName = ReferenceDataCategoryNames.NetworkLinkType,
ReferenceDatas = new List <ReferenceDataDTO>()
{
new ReferenceDataDTO()
{
ReferenceDataName = ReferenceDataValues.AccessLinkDiffRoadMaxDistance,
ReferenceDataValue = "Road Link",
ID = Guid.Parse("09ce57b1-af13-4f8e-b4af-1de35b4a68a8")
}
}
},
new ReferenceDataCategoryDTO()
{
CategoryName = ReferenceDataCategoryNames.AccessLinkParameters,
ReferenceDatas = new List <ReferenceDataDTO>()
{
new ReferenceDataDTO()
{
ReferenceDataName = "Local Road",
ReferenceDataValue = "1",
ID = Guid.Parse("4DBA7B35-D23E-493A-9B8F-B94D181A082F")
}
}
},
new ReferenceDataCategoryDTO()
{
CategoryName = ReferenceDataCategoryNames.DeliveryPointUseIndicator,
ReferenceDatas = new List <ReferenceDataDTO>()
{
new ReferenceDataDTO()
{
ReferenceDataName = "DeliveryPointUseIndicator",
ReferenceDataValue = "Residential",
ID = Guid.Parse("178edcad-9431-e711-83ec-28d244aef9ed")
}
}
},
};
loggingHelperMock = CreateMock <ILoggingHelper>();
// Setup Methods.
mockaccessLinkDataService = new Mock <IAccessLinkDataService>();
mockAccessLinkIntegrationService = CreateMock <IAccessLinkIntegrationService>();
mockaccessLinkDataService.Setup(x => x.GetAccessLinks(It.IsAny <string>(), It.IsAny <Guid>())).Returns(It.IsAny <List <AccessLinkDataDTO> >);
mockaccessLinkDataService.Setup(x => x.GetAccessLinksCrossingOperationalObject(It.IsAny <string>(), It.IsAny <DbGeometry>())).Returns(default(bool));
mockaccessLinkDataService.Setup(x => x.DeleteAccessLink(It.IsAny <Guid>(), It.IsAny <Guid>(), It.IsAny <Guid>())).ReturnsAsync(true);
mockAccessLinkIntegrationService.Setup(x => x.GetReferenceDataNameValuePairs(It.IsAny <List <string> >())).ReturnsAsync(new List <ReferenceDataCategoryDTO>()
{
});
mockAccessLinkIntegrationService.Setup(x => x.GetReferenceDataSimpleLists(It.IsAny <List <string> >())).ReturnsAsync(refDataCategotyDTO);
mockAccessLinkIntegrationService.Setup(x => x.GetDeliveryPoint(It.IsAny <Guid>())).ReturnsAsync(deliveryPointDTO);
mockAccessLinkIntegrationService.Setup(x => x.GetNearestNamedRoad(It.IsAny <DbGeometry>(), It.IsAny <string>())).ReturnsAsync(tuple);
mockAccessLinkIntegrationService.Setup(x => x.GetNearestSegment(It.IsAny <DbGeometry>())).ReturnsAsync(tuple1);
mockAccessLinkIntegrationService.Setup(x => x.GetOSRoadLink(It.IsAny <string>())).ReturnsAsync("Local Road");
mockAccessLinkIntegrationService.Setup(x => x.GetCrossingNetworkLinks(It.IsAny <string>(), It.IsAny <DbGeometry>())).ReturnsAsync(new List <NetworkLinkDTO>()
{
});
mockAccessLinkIntegrationService.Setup(x => x.GetDeliveryPointsCrossingOperationalObject(It.IsAny <string>(), It.IsAny <DbGeometry>())).ReturnsAsync(new List <DeliveryPointDTO>()
{
});
mockAccessLinkIntegrationService.Setup(x => x.GetNetworkLink(It.IsAny <Guid>())).ReturnsAsync(networkLink);
mockaccessLinkDataService.Setup(x => x.CreateAccessLink(It.IsAny <AccessLinkDataDTO>())).Returns(true);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
loggingHelperMock.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
testCandidate = new AccessLinkBusinessService(mockaccessLinkDataService.Object, loggingHelperMock.Object, mockAccessLinkIntegrationService.Object);
}
private static Point3D extractPoint(int noareas, JObject feature, List <Point3D> badPolygonsPoints, Point3D.PointType pointType)
{
Point3D toReturn = new Point3D();
toReturn.Level = int.Parse(feature["properties"]["level"].ToString());
//if (toReturn.Level == 6)
// Debugger.Break();
toReturn.IsAccessible = Boolean.Parse(feature["properties"]["accessible"].ToString());
StringBuilder wktsb = new StringBuilder("POINT (");
var j = feature["geometry"]["coordinates"];
string lon = Regex.Match(j.ToString(), "34\\.\\d+").Value;
string lat = Regex.Match(j.ToString(), "32\\.\\d+").Value;
wktsb.Append(lon + " " + lat);
wktsb.Append(")");
toReturn.Wkt = wktsb.ToString();
toReturn.LocationG = DbGeometry.PointFromText(wktsb.ToString(), 4326);
toReturn.Name = feature["properties"]["attrs"]["name"].ToString();
//if (toReturn.Name.ToLower().Contains("level"))
// Debugger.Break();
toReturn.Latitude = Decimal.Parse(lat);
toReturn.Longitude = Decimal.Parse(lon);
if (feature["properties"]["attrs"]["Name2"] != null)
{
toReturn.Name2 = feature["properties"]["attrs"]["Name2"].ToString();
}
if (pointType != Point3D.PointType.UNDEFINED)
{
toReturn.Type = pointType;
}
//if (toReturn.Name != null && toReturn.Name.Contains("כלי זמר"))
// Debugger.Break();
toReturn.Areas = new List <Area>();
if ((feature["properties"]["attrs"]["AreaID"] != null && !feature["properties"]["attrs"]["AreaID"].ToString().Equals(""))
| (feature["properties"]["attrs"]["AREAID"] != null && !feature["properties"]["attrs"]["AREAID"].ToString().Equals("")))
{
if (feature["properties"]["attrs"]["AreaID"] != null && !feature["properties"]["attrs"]["AreaID"].ToString().Equals(""))
{
Area area = new Area(feature["properties"]["attrs"]["AreaID"].ToString());
toReturn.Areas.Add(area);
}
if (feature["properties"]["attrs"]["AREAID"] != null && !feature["properties"]["attrs"]["AREAID"].ToString().Equals(""))
{
Area area = new Area(feature["properties"]["attrs"]["AREAID"].ToString());
toReturn.Areas.Add(area);
}
int index = 2;
while (feature["properties"]["attrs"]["AREAID" + index] != null)
{
if (feature["properties"]["attrs"]["AREAID" + index].ToString() != "")
{
toReturn.Areas.Add(new Area(feature["properties"]["attrs"]["AREAID" + index].ToString()));
}
index++;
}
while (feature["properties"]["attrs"]["AreaID" + index] != null)
{
if (feature["properties"]["attrs"]["AreaID" + index].ToString() != "")
{
toReturn.Areas.Add(new Area(feature["properties"]["attrs"]["AreaID" + index].ToString()));
}
index++;
}
}
else
{
noareas++;
}
if (badPolygonsPoints != null && (toReturn.Name.ToUpper().Contains("PASSAGES") | toReturn.Name.ToUpper().Contains("ROADWALK")))
{
badPolygonsPoints.Add(toReturn);
}
return(toReturn);
}
/// <summary>
/// Data and Methods setup required to run test methods
/// </summary>
protected override void OnSetup()
{
// Data setup
unit1Guid = new Guid("8534AA41-391F-4579-A18D-D7EDF5B5F918");
currentUserUnitType = "Delivery Office";
mockIConfigurationHelper = CreateMock <IConfigurationHelper>();
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
var unitBoundary = DbGeometry.PolygonFromText("POLYGON ((505058.162109375 100281.69677734375, 518986.84887695312 100281.69677734375, 518986.84887695312 114158.546875, 505058.162109375 114158.546875, 505058.162109375 100281.69677734375))", 27700);
accessLinkLine = DbGeometry.LineFromText("LINESTRING (488938 197021, 488929.9088937093 197036.37310195228)", 27700);
point = DbGeometry.PointFromText("POINT (488938 197021)", 27700);
var streetNamesList = new List <StreetName>()
{
new StreetName()
{
ID = new Guid("8134AA41-391F-4579-A18D-D7EDF5B5F918"), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad1", DesignatedName = "XYZ1", Geometry = unitBoundary
},
new StreetName()
{
ID = new Guid("8234AA41-391F-4579-A18D-D7EDF5B5F918"), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad2", DesignatedName = "XYZ2", Geometry = unitBoundary
},
new StreetName()
{
ID = new Guid("8334AA41-391F-4579-A18D-D7EDF5B5F918"), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad3", DesignatedName = "XYZ3", Geometry = unitBoundary
},
new StreetName()
{
ID = new Guid("8434AA41-391F-4579-A18D-D7EDF5B5F918"), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad4", DesignatedName = "XYZ4", Geometry = unitBoundary
},
new StreetName()
{
ID = new Guid("8534AA41-391F-4579-A18D-D7EDF5B5F918"), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad5", DesignatedName = "XYZ5", Geometry = unitBoundary
},
new StreetName()
{
ID = new Guid("8634AA41-391F-4579-A18D-D7EDF5B5F918"), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad6", DesignatedName = "XYZ6", Geometry = unitBoundary
},
new StreetName()
{
ID = new Guid("8734AA41-391F-4579-A18D-D7EDF5B5F918"), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad7", DesignatedName = "XYZ7", Geometry = unitBoundary
}
};
var networkLinkList = new List <NetworkLink>()
{
new NetworkLink()
{
LinkGeometry = accessLinkLine,
StreetNameGUID = new Guid("8134AA41-391F-4579-A18D-D7EDF5B5F918"),
NetworkLinkTypeGUID = Guid.Empty,
ID = new Guid("8134AA41-391F-4579-A18D-D7EDF5B5F911")
}
};
List <Location> locationList = new List <Location>()
{
new Location()
{
ID = unit1Guid,
Shape = unitBoundary
}
};
referenceDataCategoryList = new List <ReferenceDataCategoryDTO>()
{
new ReferenceDataCategoryDTO()
{
CategoryName = ReferenceDataCategoryNames.NetworkLinkType,
ReferenceDatas = new List <ReferenceDataDTO>()
{
new ReferenceDataDTO()
{
ReferenceDataValue = ReferenceDataValues.NetworkLinkPathLink
}
},
Id = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918")
},
new ReferenceDataCategoryDTO()
{
CategoryName = ReferenceDataCategoryNames.NetworkLinkType,
ReferenceDatas = new List <ReferenceDataDTO>()
{
new ReferenceDataDTO()
{
ReferenceDataValue = ReferenceDataValues.NetworkLinkRoadLink
}
},
Id = new Guid("2534AA41-391F-4579-A18D-D7EDF5B5F918")
},
new ReferenceDataCategoryDTO()
{
CategoryName = ReferenceDataCategoryNames.AccessLinkParameters,
ReferenceDatas = new List <ReferenceDataDTO>()
{
new ReferenceDataDTO()
{
ReferenceDataName = ReferenceDataValues.AccessLinkDiffRoadMaxDistance,
ReferenceDataValue = "5"
}
},
Id = new Guid("3534AA41-391F-4579-A18D-D7EDF5B5F918")
}
};
mockNetworkDBContext = CreateMock <NetworkDBContext>();
mockILoggingHelper = CreateMock <ILoggingHelper>();
// Setup for StreetName
var mockAsynEnumerable = new DbAsyncEnumerable <StreetName>(streetNamesList);
var mockStreetName = MockDbSet(streetNamesList);
mockStreetName.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable.AsQueryable().Provider);
mockStreetName.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable.AsQueryable().Expression);
mockStreetName.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable.AsQueryable().ElementType);
mockStreetName.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <StreetName>)mockAsynEnumerable).GetAsyncEnumerator());
mockNetworkDBContext.Setup(x => x.Set <StreetName>()).Returns(mockStreetName.Object);
mockNetworkDBContext.Setup(x => x.StreetNames).Returns(mockStreetName.Object);
mockStreetName.Setup(x => x.AsNoTracking()).Returns(mockStreetName.Object);
// Setup for Location
var mockAsynEnumerable1 = new DbAsyncEnumerable <Location>(locationList);
var mockLocation = MockDbSet(locationList);
mockLocation.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable1.AsQueryable().Provider);
mockLocation.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable1.AsQueryable().Expression);
mockLocation.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable1.AsQueryable().ElementType);
mockLocation.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Location>)mockAsynEnumerable1).GetAsyncEnumerator());
mockNetworkDBContext.Setup(x => x.Set <Location>()).Returns(mockLocation.Object);
mockNetworkDBContext.Setup(x => x.Locations).Returns(mockLocation.Object);
mockLocation.Setup(x => x.AsNoTracking()).Returns(mockLocation.Object);
// Setup for NetworkLink
var mockAsynEnumerable3 = new DbAsyncEnumerable <NetworkLink>(networkLinkList);
var mockNetworkLink = MockDbSet(networkLinkList);
mockNetworkLink.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable3.AsQueryable().Provider);
mockNetworkLink.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable3.AsQueryable().Expression);
mockNetworkLink.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable3.AsQueryable().ElementType);
mockNetworkLink.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <NetworkLink>)mockAsynEnumerable3).GetAsyncEnumerator());
mockNetworkDBContext.Setup(x => x.Set <NetworkLink>()).Returns(mockNetworkLink.Object);
mockNetworkDBContext.Setup(x => x.NetworkLinks).Returns(mockNetworkLink.Object);
mockNetworkDBContext.Setup(x => x.NetworkLinks.AsNoTracking()).Returns(mockNetworkLink.Object);
// Mock trace manager
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockILoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
mockIConfigurationHelper.Setup(x => x.ReadAppSettingsConfigurationValues(It.IsAny <string>())).Returns("5");
mockDatabaseFactory = CreateMock <IDatabaseFactory <NetworkDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockNetworkDBContext.Object);
testCandidate = new StreetNetworkDataService(mockDatabaseFactory.Object, mockILoggingHelper.Object, mockIConfigurationHelper.Object);
}
private static IEnumerable <MethodInfo> GetSupportedMethods()
{
yield return(GetStaticMethod(() => DbGeography.FromText(default(string))));
yield return(GetStaticMethod(() => DbGeography.FromText(default(string), default(int))));
yield return(GetStaticMethod(() => DbGeography.PointFromText(default(string), default(int))));
yield return(GetStaticMethod(() => DbGeography.LineFromText(default(string), default(int))));
yield return(GetStaticMethod(() => DbGeography.PolygonFromText(default(string), default(int))));
yield return(GetStaticMethod(() => DbGeography.MultiPointFromText(default(string), default(int))));
yield return(GetStaticMethod(() => DbGeography.MultiLineFromText(default(string), default(int))));
yield return(GetStaticMethod(() => DbGeography.MultiPolygonFromText(default(string), default(int))));
yield return(GetStaticMethod(() => DbGeography.GeographyCollectionFromText(default(string), default(int))));
yield return(GetStaticMethod(() => DbGeography.FromBinary(default(byte[]), default(int))));
yield return(GetStaticMethod(() => DbGeography.FromBinary(default(byte[]))));
yield return(GetStaticMethod(() => DbGeography.PointFromBinary(default(byte[]), default(int))));
yield return(GetStaticMethod(() => DbGeography.LineFromBinary(default(byte[]), default(int))));
yield return(GetStaticMethod(() => DbGeography.PolygonFromBinary(default(byte[]), default(int))));
yield return(GetStaticMethod(() => DbGeography.MultiPointFromBinary(default(byte[]), default(int))));
yield return(GetStaticMethod(() => DbGeography.MultiLineFromBinary(default(byte[]), default(int))));
yield return(GetStaticMethod(() => DbGeography.MultiPolygonFromBinary(default(byte[]), default(int))));
yield return(GetStaticMethod(() => DbGeography.GeographyCollectionFromBinary(default(byte[]), default(int))));
yield return(GetStaticMethod(() => DbGeography.FromGml(default(string))));
yield return(GetStaticMethod(() => DbGeography.FromGml(default(string), default(int))));
yield return(GetInstanceMethod((DbGeography geo) => geo.AsBinary()));
yield return(GetInstanceMethod((DbGeography geo) => geo.AsGml()));
yield return(GetInstanceMethod((DbGeography geo) => geo.AsText()));
yield return(GetInstanceMethod((DbGeography geo) => geo.SpatialEquals(default(DbGeography))));
yield return(GetInstanceMethod((DbGeography geo) => geo.Disjoint(default(DbGeography))));
yield return(GetInstanceMethod((DbGeography geo) => geo.Intersects(default(DbGeography))));
yield return(GetInstanceMethod((DbGeography geo) => geo.Buffer(default(double))));
yield return(GetInstanceMethod((DbGeography geo) => geo.Distance(default(DbGeography))));
yield return(GetInstanceMethod((DbGeography geo) => geo.Intersection(default(DbGeography))));
yield return(GetInstanceMethod((DbGeography geo) => geo.Union(default(DbGeography))));
yield return(GetInstanceMethod((DbGeography geo) => geo.Difference(default(DbGeography))));
yield return(GetInstanceMethod((DbGeography geo) => geo.SymmetricDifference(default(DbGeography))));
yield return(GetInstanceMethod((DbGeography geo) => geo.ElementAt(default(int))));
yield return(GetInstanceMethod((DbGeography geo) => geo.PointAt(default(int))));
yield return(GetStaticMethod(() => DbGeometry.FromText(default(string))));
yield return(GetStaticMethod(() => DbGeometry.FromText(default(string), default(int))));
yield return(GetStaticMethod(() => DbGeometry.PointFromText(default(string), default(int))));
yield return(GetStaticMethod(() => DbGeometry.LineFromText(default(string), default(int))));
yield return(GetStaticMethod(() => DbGeometry.PolygonFromText(default(string), default(int))));
yield return(GetStaticMethod(() => DbGeometry.MultiPointFromText(default(string), default(int))));
yield return(GetStaticMethod(() => DbGeometry.MultiLineFromText(default(string), default(int))));
yield return(GetStaticMethod(() => DbGeometry.MultiPolygonFromText(default(string), default(int))));
yield return(GetStaticMethod(() => DbGeometry.GeometryCollectionFromText(default(string), default(int))));
yield return(GetStaticMethod(() => DbGeometry.FromBinary(default(byte[]))));
yield return(GetStaticMethod(() => DbGeometry.FromBinary(default(byte[]), default(int))));
yield return(GetStaticMethod(() => DbGeometry.PointFromBinary(default(byte[]), default(int))));
yield return(GetStaticMethod(() => DbGeometry.LineFromBinary(default(byte[]), default(int))));
yield return(GetStaticMethod(() => DbGeometry.PolygonFromBinary(default(byte[]), default(int))));
yield return(GetStaticMethod(() => DbGeometry.MultiPointFromBinary(default(byte[]), default(int))));
yield return(GetStaticMethod(() => DbGeometry.MultiLineFromBinary(default(byte[]), default(int))));
yield return(GetStaticMethod(() => DbGeometry.MultiPolygonFromBinary(default(byte[]), default(int))));
yield return(GetStaticMethod(() => DbGeometry.GeometryCollectionFromBinary(default(byte[]), default(int))));
yield return(GetStaticMethod(() => DbGeometry.FromGml(default(string))));
yield return(GetStaticMethod(() => DbGeometry.FromGml(default(string), default(int))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.AsBinary()));
yield return(GetInstanceMethod((DbGeometry geo) => geo.AsGml()));
yield return(GetInstanceMethod((DbGeometry geo) => geo.AsText()));
yield return(GetInstanceMethod((DbGeometry geo) => geo.SpatialEquals(default(DbGeometry))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.Disjoint(default(DbGeometry))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.Intersects(default(DbGeometry))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.Touches(default(DbGeometry))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.Crosses(default(DbGeometry))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.Within(default(DbGeometry))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.Contains(default(DbGeometry))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.Overlaps(default(DbGeometry))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.Relate(default(DbGeometry), default(string))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.Buffer(default(double))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.Distance(default(DbGeometry))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.Intersection(default(DbGeometry))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.Union(default(DbGeometry))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.Difference(default(DbGeometry))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.SymmetricDifference(default(DbGeometry))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.ElementAt(default(int))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.PointAt(default(int))));
yield return(GetInstanceMethod((DbGeometry geo) => geo.InteriorRingAt(default(int))));
}
private void InsertGolfStore(MallBuddyApi.Models.ApplicationDbContext context)
{
try
{
var golf = new Store
{
Name = "GOLF",
Type = POI.POIType.STORE,
Anchor = new Point3D(),
Schedule = new List <Models.existing.OpeningHoursSpan>(),
Enabled = true,
WebsiteLink = "http://www.dizengof-center.co.il/GOLF.aspx",
ImageUrl = "http://www.dizengof-center.co.il/manage-pages/uploaded-files/a_03-07-2011-15-37-5.jpg",
Location = new Polygone(),
ContactDetails = new ContactDetails {
PoiName = "GOLF", Phone1 = "03-5283163", Address = "www.golf.co.il"
},
//Category = "Fashion",
};
var schedule1 = new List <OpeningHoursSpan>();
var weekday = new OpeningHoursSpan {
day = DayOfWeek.Sunday, from = 10, to = 2130
};
var friday = new OpeningHoursSpan {
day = DayOfWeek.Friday, from = 0930, to = 1530
};
var saturday = new OpeningHoursSpan {
day = DayOfWeek.Saturday, from = 20, to = 2230
};
schedule1.Add(weekday); schedule1.Add(friday); schedule1.Add(saturday);
golf.Schedule = schedule1;
Polygone poly = new Polygone
{
Accessible = true,
Areas = new List <Area> {
new Area {
AreaID = "0401"
}, new Area {
AreaID = "0401A"
}
},
Wkt = "POLYGON ((34.775053932498516 32.07540339193275,34.77499915806167 32.07548404017222,34.77497984348338 32.07549149508553, 34.774953825764996 32.07549049106811,34.774935077805786 32.07547970303128,34.77491144862596 32.07545506831342,34.77490455271353 32.07544820193738, 34.77489280495869 32.075426482513976, 34.774889877466975 32.07541821355505,34.774886213457535 32.07540786423455,34.77488379926684 32.075401045136886,34.774871958289275 32.07534718017001,34.77487191400818 32.0752896316811,34.77492920795574 32.075324825765655,34.775053932498516 32.07540339193275,34.775053932498516 32.07540339193275))",
LocationG = DbGeometry.PolygonFromText("POLYGON ((34.775053932498516 32.07540339193275,34.77499915806167 32.07548404017222,34.77497984348338 32.07549149508553, 34.774953825764996 32.07549049106811,34.774935077805786 32.07547970303128,34.77491144862596 32.07545506831342,34.77490455271353 32.07544820193738, 34.77489280495869 32.075426482513976, 34.774889877466975 32.07541821355505,34.774886213457535 32.07540786423455,34.77488379926684 32.075401045136886,34.774871958289275 32.07534718017001,34.77487191400818 32.0752896316811,34.77492920795574 32.075324825765655,34.775053932498516 32.07540339193275,34.775053932498516 32.07540339193275))", 4326),
Points = new List <Point3D>()
};
var Point3D1 = new Point3D {
Level = 2, Longitude = 34.775053932498516m, Latitude = 32.07540339193275m, Wkt = "POINT(34.775053932498516 32.07540339193275)", LocationG = DbGeometry.PointFromText("POINT(34.775053932498516 32.07540339193275)", 4326)
};
var Point3D2 = new Point3D {
Level = 2, Longitude = 34.77499915806167m, Latitude = 32.07548404017222m, Wkt = "POINT(34.77499915806167 32.07548404017222)", LocationG = DbGeometry.PointFromText("POINT(34.77499915806167 32.07548404017222)", 4326)
};
var Point3D3 = new Point3D {
Level = 2, Longitude = 34.77497984348338m, Latitude = 32.07549149508553m, Wkt = "POINT(34.77497984348338 32.07549149508553)", LocationG = DbGeometry.PointFromText("POINT(34.77497984348338 32.07549149508553)", 4326)
};
var Point3D4 = new Point3D {
Level = 2, Longitude = 34.774953825764996m, Latitude = 32.07549049106811m, Wkt = "POINT(34.774953825764996 32.07549049106811)", LocationG = DbGeometry.PointFromText("POINT(34.774953825764996 32.07549049106811)", 4326)
};
poly.Points.Add(Point3D1); poly.Points.Add(Point3D2); poly.Points.Add(Point3D3); poly.Points.Add(Point3D4);
golf.Location = poly;
context.Stores.AddOrUpdate(golf);
//context.
SaveChanges(context);
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
throw;
}
}
protected override void OnSetup()
{
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
mockLoggingHelper = CreateMock <ILoggingHelper>();
unit1Guid = Guid.NewGuid();
unit2Guid = Guid.NewGuid();
unit3Guid = Guid.NewGuid();
user1Id = System.Guid.NewGuid();
user2Id = System.Guid.NewGuid();
var unitBoundary = DbGeometry.PolygonFromText("POLYGON((511570.8590967182 106965.35195621933, 511570.8590967182 107474.95297542136, 512474.1409032818 107474.95297542136, 512474.1409032818 106965.35195621933, 511570.8590967182 106965.35195621933))", 27700);
var unitLocation = new List <UnitLocation>()
{
new UnitLocation()
{
UnitName = "unit1", ExternalId = "extunit1", ID = unit1Guid, UnitBoundryPolygon = unitBoundary, UserRoleUnits = new List <UserRoleUnit> {
new UserRoleUnit {
Unit_GUID = unit1Guid, User_GUID = user1Id
}
}
},
new UnitLocation()
{
UnitName = "unit2", ExternalId = "extunit2", ID = unit2Guid, UnitBoundryPolygon = unitBoundary, UserRoleUnits = new List <UserRoleUnit> {
new UserRoleUnit {
Unit_GUID = unit2Guid, User_GUID = user1Id
}
}
},
new UnitLocation()
{
UnitName = "unit3", ExternalId = "extunit2", ID = unit3Guid, UnitBoundryPolygon = unitBoundary, UserRoleUnits = new List <UserRoleUnit> {
new UserRoleUnit {
Unit_GUID = unit3Guid, User_GUID = user2Id
}
}
}
};
var accessLink = new List <AccessLink>()
{
new AccessLink()
{
AccessLinkLine = unitBoundary,
ID = Guid.NewGuid()
}
};
accessLinkDto = new AccessLinkDTO()
{
OperationalObjectPoint = DbGeometry.PointFromText("POINT (488938 197021)", 27700),
NetworkIntersectionPoint = null,
AccessLinkLine = null,
ActualLengthMeter = 3,
WorkloadLengthMeter = 5,
Approved = true,
OperationalObject_GUID = Guid.NewGuid()
};
var mockAsynEnumerable = new DbAsyncEnumerable <AccessLink>(accessLink);
var mockAccessLinkDataService = MockDbSet(accessLink);
mockFmoDbContext = CreateMock <RMDBContext>();
mockFmoDbContext.Setup(x => x.Set <AccessLink>()).Returns(mockAccessLinkDataService.Object);
mockFmoDbContext.Setup(x => x.AccessLinks).Returns(mockAccessLinkDataService.Object);
mockFmoDbContext.Setup(c => c.AccessLinks.AsNoTracking()).Returns(mockAccessLinkDataService.Object);
mockAccessLinkDataService.Setup(x => x.Include(It.IsAny <string>())).Returns(mockAccessLinkDataService.Object);
var mockAsynEnumerable2 = new DbAsyncEnumerable <UnitLocation>(unitLocation);
var mockAccessLinkDataService2 = MockDbSet(unitLocation);
mockFmoDbContext.Setup(x => x.Set <UnitLocation>()).Returns(mockAccessLinkDataService2.Object);
mockFmoDbContext.Setup(x => x.UnitLocations).Returns(mockAccessLinkDataService2.Object);
mockFmoDbContext.Setup(c => c.UnitLocations.AsNoTracking()).Returns(mockAccessLinkDataService2.Object);
mockAccessLinkDataService2.Setup(x => x.Include(It.IsAny <string>())).Returns(mockAccessLinkDataService2.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <RMDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockFmoDbContext.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockLoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
testCandidate = new AccessLinkDataService(mockDatabaseFactory.Object, mockLoggingHelper.Object);
}
private static Dictionary <MethodInfo, string> GetRenamedMethodFunctions()
{
var result = new Dictionary <MethodInfo, string>();
result.Add(GetStaticMethod(() => DbGeography.FromText(default(string))), "GeographyFromText");
result.Add(GetStaticMethod(() => DbGeography.FromText(default(string), default(int))), "GeographyFromText");
result.Add(GetStaticMethod(() => DbGeography.PointFromText(default(string), default(int))), "GeographyPointFromText");
result.Add(GetStaticMethod(() => DbGeography.LineFromText(default(string), default(int))), "GeographyLineFromText");
result.Add(
GetStaticMethod(() => DbGeography.PolygonFromText(default(string), default(int))), "GeographyPolygonFromText");
result.Add(
GetStaticMethod(() => DbGeography.MultiPointFromText(default(string), default(int))), "GeographyMultiPointFromText");
result.Add(
GetStaticMethod(() => DbGeography.MultiLineFromText(default(string), default(int))), "GeographyMultiLineFromText");
result.Add(
GetStaticMethod(() => DbGeography.MultiPolygonFromText(default(string), default(int))),
"GeographyMultiPolygonFromText");
result.Add(
GetStaticMethod(() => DbGeography.GeographyCollectionFromText(default(string), default(int))),
"GeographyCollectionFromText");
result.Add(GetStaticMethod(() => DbGeography.FromBinary(default(byte[]), default(int))), "GeographyFromBinary");
result.Add(GetStaticMethod(() => DbGeography.FromBinary(default(byte[]))), "GeographyFromBinary");
result.Add(
GetStaticMethod(() => DbGeography.PointFromBinary(default(byte[]), default(int))), "GeographyPointFromBinary");
result.Add(GetStaticMethod(() => DbGeography.LineFromBinary(default(byte[]), default(int))), "GeographyLineFromBinary");
result.Add(
GetStaticMethod(() => DbGeography.PolygonFromBinary(default(byte[]), default(int))), "GeographyPolygonFromBinary");
result.Add(
GetStaticMethod(() => DbGeography.MultiPointFromBinary(default(byte[]), default(int))),
"GeographyMultiPointFromBinary");
result.Add(
GetStaticMethod(() => DbGeography.MultiLineFromBinary(default(byte[]), default(int))),
"GeographyMultiLineFromBinary");
result.Add(
GetStaticMethod(() => DbGeography.MultiPolygonFromBinary(default(byte[]), default(int))),
"GeographyMultiPolygonFromBinary");
result.Add(
GetStaticMethod(() => DbGeography.GeographyCollectionFromBinary(default(byte[]), default(int))),
"GeographyCollectionFromBinary");
result.Add(GetStaticMethod(() => DbGeography.FromGml(default(string))), "GeographyFromGml");
result.Add(GetStaticMethod(() => DbGeography.FromGml(default(string), default(int))), "GeographyFromGml");
result.Add(GetInstanceMethod((DbGeography geo) => geo.AsBinary()), "AsBinary");
result.Add(GetInstanceMethod((DbGeography geo) => geo.AsGml()), "AsGml");
result.Add(GetInstanceMethod((DbGeography geo) => geo.AsText()), "AsText");
result.Add(GetInstanceMethod((DbGeography geo) => geo.SpatialEquals(default(DbGeography))), "SpatialEquals");
result.Add(GetInstanceMethod((DbGeography geo) => geo.Disjoint(default(DbGeography))), "SpatialDisjoint");
result.Add(GetInstanceMethod((DbGeography geo) => geo.Intersects(default(DbGeography))), "SpatialIntersects");
result.Add(GetInstanceMethod((DbGeography geo) => geo.Buffer(default(double))), "SpatialBuffer");
result.Add(GetInstanceMethod((DbGeography geo) => geo.Distance(default(DbGeography))), "Distance");
result.Add(GetInstanceMethod((DbGeography geo) => geo.Intersection(default(DbGeography))), "SpatialIntersection");
result.Add(GetInstanceMethod((DbGeography geo) => geo.Union(default(DbGeography))), "SpatialUnion");
result.Add(GetInstanceMethod((DbGeography geo) => geo.Difference(default(DbGeography))), "SpatialDifference");
result.Add(
GetInstanceMethod((DbGeography geo) => geo.SymmetricDifference(default(DbGeography))), "SpatialSymmetricDifference");
result.Add(GetInstanceMethod((DbGeography geo) => geo.ElementAt(default(int))), "SpatialElementAt");
result.Add(GetInstanceMethod((DbGeography geo) => geo.PointAt(default(int))), "PointAt");
result.Add(GetStaticMethod(() => DbGeometry.FromText(default(string))), "GeometryFromText");
result.Add(GetStaticMethod(() => DbGeometry.FromText(default(string), default(int))), "GeometryFromText");
result.Add(GetStaticMethod(() => DbGeometry.PointFromText(default(string), default(int))), "GeometryPointFromText");
result.Add(GetStaticMethod(() => DbGeometry.LineFromText(default(string), default(int))), "GeometryLineFromText");
result.Add(GetStaticMethod(() => DbGeometry.PolygonFromText(default(string), default(int))), "GeometryPolygonFromText");
result.Add(
GetStaticMethod(() => DbGeometry.MultiPointFromText(default(string), default(int))), "GeometryMultiPointFromText");
result.Add(
GetStaticMethod(() => DbGeometry.MultiLineFromText(default(string), default(int))), "GeometryMultiLineFromText");
result.Add(
GetStaticMethod(() => DbGeometry.MultiPolygonFromText(default(string), default(int))),
"GeometryMultiPolygonFromText");
result.Add(
GetStaticMethod(() => DbGeometry.GeometryCollectionFromText(default(string), default(int))),
"GeometryCollectionFromText");
result.Add(GetStaticMethod(() => DbGeometry.FromBinary(default(byte[]))), "GeometryFromBinary");
result.Add(GetStaticMethod(() => DbGeometry.FromBinary(default(byte[]), default(int))), "GeometryFromBinary");
result.Add(GetStaticMethod(() => DbGeometry.PointFromBinary(default(byte[]), default(int))), "GeometryPointFromBinary");
result.Add(GetStaticMethod(() => DbGeometry.LineFromBinary(default(byte[]), default(int))), "GeometryLineFromBinary");
result.Add(
GetStaticMethod(() => DbGeometry.PolygonFromBinary(default(byte[]), default(int))), "GeometryPolygonFromBinary");
result.Add(
GetStaticMethod(() => DbGeometry.MultiPointFromBinary(default(byte[]), default(int))),
"GeometryMultiPointFromBinary");
result.Add(
GetStaticMethod(() => DbGeometry.MultiLineFromBinary(default(byte[]), default(int))), "GeometryMultiLineFromBinary");
result.Add(
GetStaticMethod(() => DbGeometry.MultiPolygonFromBinary(default(byte[]), default(int))),
"GeometryMultiPolygonFromBinary");
result.Add(
GetStaticMethod(() => DbGeometry.GeometryCollectionFromBinary(default(byte[]), default(int))),
"GeometryCollectionFromBinary");
result.Add(GetStaticMethod(() => DbGeometry.FromGml(default(string))), "GeometryFromGml");
result.Add(GetStaticMethod(() => DbGeometry.FromGml(default(string), default(int))), "GeometryFromGml");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.AsBinary()), "AsBinary");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.AsGml()), "AsGml");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.AsText()), "AsText");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.SpatialEquals(default(DbGeometry))), "SpatialEquals");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.Disjoint(default(DbGeometry))), "SpatialDisjoint");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.Intersects(default(DbGeometry))), "SpatialIntersects");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.Touches(default(DbGeometry))), "SpatialTouches");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.Crosses(default(DbGeometry))), "SpatialCrosses");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.Within(default(DbGeometry))), "SpatialWithin");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.Contains(default(DbGeometry))), "SpatialContains");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.Overlaps(default(DbGeometry))), "SpatialOverlaps");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.Relate(default(DbGeometry), default(string))), "SpatialRelate");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.Buffer(default(double))), "SpatialBuffer");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.Distance(default(DbGeometry))), "Distance");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.Intersection(default(DbGeometry))), "SpatialIntersection");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.Union(default(DbGeometry))), "SpatialUnion");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.Difference(default(DbGeometry))), "SpatialDifference");
result.Add(
GetInstanceMethod((DbGeometry geo) => geo.SymmetricDifference(default(DbGeometry))), "SpatialSymmetricDifference");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.ElementAt(default(int))), "SpatialElementAt");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.PointAt(default(int))), "PointAt");
result.Add(GetInstanceMethod((DbGeometry geo) => geo.InteriorRingAt(default(int))), "InteriorRingAt");
return(result);
}
private void extractLineString(JObject feature, List <LineStringDTO> lineStrings, List <Point3D> pathPoints, Dictionary <string, Point3D> labeledPoints)
{
LineStringDTO toAdd = new LineStringDTO();
int level = int.Parse(feature["properties"]["level"].ToString());
//bool isAccessible = Boolean.Parse(feature["properties"]["accessible"].ToString());
toAdd.Level = level;
if (feature["properties"]["attrs"]["name"] != null)
{
toAdd.Name = feature["properties"]["attrs"]["name"].ToString();
}
StringBuilder wktsb = new StringBuilder("LINESTRING (");
//List<Point3D> labeledPointsFound = new List<Point3D>();
//Point3D source = new Point3D();
//Point3D target = new Point3D();
int i = 0;
foreach (JArray j in feature["geometry"]["coordinates"])
{
StringBuilder pointWkt = new StringBuilder("POINT (");
string lon = Regex.Match(j.ToString(), "34\\.\\d+").Value;
string lat = Regex.Match(j.ToString(), "32\\.\\d+").Value;
wktsb.Append(lon + " " + lat + ",");
pointWkt.Append(lon + " " + lat + ")");
Point3D current = null;
if (labeledPoints.ContainsKey(pointWkt.ToString()))
{
current = labeledPoints[pointWkt.ToString()];
current.Type = Point3D.PointType.PATH_POINT;
if (!pathPoints.Contains(current))
{
pathPoints.Add(current);
}
}
if (current == null)
{
current = pathPoints.Find(x => x.Wkt == pointWkt.ToString() && x.Level == level);
}
else
{
current = current;
}
if (current == null)
{
current = new Point3D();
//current = i == 0 ? source : target;
current.Latitude = Decimal.Parse(lat);
current.Longitude = Decimal.Parse(lon);
current.Wkt = pointWkt.ToString();
current.LocationG = DbGeometry.PointFromText(current.Wkt, 4326);
current.Level = level;
current.Type = Point3D.PointType.PATH_POINT;
pathPoints.Add(current);
}
else
{
i = i;
}
if (i == 0)
{
toAdd.Source = current;
}
if (i == 1)
{
toAdd.Target = current;
}
i++;
}
wktsb.Remove(wktsb.Length - 1, 1);
wktsb.Append(")");
toAdd.Wkt = wktsb.ToString();
toAdd.LocationG = DbGeometry.LineFromText(toAdd.Wkt, 4326);
toAdd.Distance = GeoUtils.GetHaversineDistance(toAdd.Source, toAdd.Target);
toAdd.BiDirectional = true;
//if (toAdd.Target.Longitude == 34.7745353108864M)
// Debugger.Break();
toAdd.setConnectorType();
lineStrings.Add(toAdd);
}
//////////////////////////
//helpers
///////////////////////
//attempt to geocode the profile address
protected void addUpdateAddrGeoTag(int profileId)
{
var profile = _workUnit.ProfileRepository.GetEntityByID(profileId);
if (profile == null)
{
return;
}
var address = profile.Organization.StreetAddress;
var zip = profile.Organization.Zip;
var city = profile.Organization.City;
var state = profile.Organization.State;
//if any field is empty do nothing
if (string.IsNullOrEmpty(address) ||
string.IsNullOrEmpty(zip) ||
string.IsNullOrEmpty(city))
{
return;
}
//geocode
var geocoder = new MDLocatorWithZip();
var jsonResult = geocoder.geocode(address, city, zip);
var resultObj = Net.deserializeJson(jsonResult);
if (resultObj == null)
{
return;
}
var result = resultObj.candidates as IEnumerable <dynamic>;
if (result == null)
{
return;
}
var bestScore = geocoder.AcceptableScore;
dynamic location = null;
//parse result (get the entry with highest score and above acceptable score 65)
foreach (var candidate in result)
{
if (candidate.score > bestScore)
{
bestScore = candidate.score;
location = candidate.location;
}
}
//create geo tag
if (location != null)
{
var tagName = string.Format("{0}, {1}, {2} {3}", address, city, state, zip);
var wkt = string.Format("POINT({0} {1})", location.x, location.y);
//create geo tag
var geoTag = new GeoTag()
{
Name = tagName,
Geometry = DbGeometry.PointFromText(wkt, geocoder.SpatialReference),
Description = "address"
};
//remove all old references
try {
var oldAddrTagRefs = profile
.ProfileTags
.Where(x => (x.Tag is GeoTag) && x.Tag.Description == "address")
.ToList();
oldAddrTagRefs.ForEach(x => _workUnit.ProfileTagRepository.DeleteEntity(x));
_workUnit.saveChanges();
}
catch (ArgumentNullException) {
//no item found
}
//update new tags
try {
var currentTag = _workUnit.TagRepository.Entities.OfType <GeoTag>().First(x => x.Name.ToUpper() == tagName.ToUpper());
//update the geometry if it already exists
currentTag.Geometry = geoTag.Geometry;
if (currentTag.Description == "")
{
currentTag.Description = "address";
}
//update to database
_workUnit.TagRepository.UpdateEntity(currentTag);
//check if it already has referenced this profile
if (!profile.ProfileTags.Select(x => x.Tag).Contains(currentTag))
{
var profileTag = new ProfileTag()
{
Tag = currentTag,
Profile = profile
};
_workUnit.ProfileTagRepository.InsertEntity(profileTag);
}
}
catch {
//create ProfileTag
var profileTag = new ProfileTag()
{
Tag = geoTag,
Profile = profile
};
_workUnit.ProfileTagRepository.InsertEntity(profileTag);
}
finally {
_workUnit.saveChanges();
}
}
}
internal void setWktAndGeometry()
{
Wkt = "POINT(" + Longitude + " " + Latitude + ")";
LocationG = DbGeometry.PointFromText(Wkt, 4326);
}
