private void btnGetCurrentLatLng_Click(object sender, EventArgs e)
{
var geoInfo = GeoHelper.GetCurrentGetInfo();
tbLatitude.Text = geoInfo.Latitude.ToString();
tbLongitude.Text = geoInfo.Longitude.ToString();
}
/// <summary>
/// 检测转向灯
/// </summary>
protected override void LeftIndicatorCheck(IndicatorCheckState checkState)
{
//角度设置0时，不进行角度达到检测转向灯
if (checkState == IndicatorCheckState.MidCheckAngle && Settings.TurnRightAngle < 0.5)
{
return;
}
if (indicatorChecked)
{
return;
}
if (checkState == IndicatorCheckState.MidCheckAngle)
{
//设置了变道角度后
if (CarSignalSet.Current.BearingAngle.IsValidAngle() &&
StartAngle.IsValidAngle() &&
!GeoHelper.IsBetweenDiffAngle(CarSignalSet.Current.BearingAngle, StartAngle, Settings.TurnRightAngle))
{
CheckRight();
}
}
else if (checkState == IndicatorCheckState.StopCheck)
{
CheckRight();
}
}
public void StandardShipEtasFromStLouisBay()
{
Position testPosition = ShipPositions.StLouisBay;
var ship = new ShipTest
{
Position = testPosition,
NavigationalStatus = NavigationalStatus.Underway,
CanalEntryTimestamp = DateTime.UtcNow.AddHours(-6),
Speed = 1
};
var directDistanceToDuluth = GeoHelper.DistanceBetweenCoord(Ports.Duluth, testPosition);
var shipSideDistance = directDistanceToDuluth * Math.Sin(60d.ToRadians());
var canalSideDistance = directDistanceToDuluth * Math.Cos(60d.ToRadians());
var totalDistance = shipSideDistance + canalSideDistance;
var expected = DateTime.UtcNow.AddHours(totalDistance / ship.Speed) + ShipTestProcessor.DataLag;
ship.Update();
// ReSharper disable once PossibleInvalidOperationException
Assert.IsTrue(expected > ship.DerivedEta.Value.AddSeconds(-1));
Assert.IsTrue(expected < ship.DerivedEta.Value.AddSeconds(1));
}
void DragToCenterPositionWorld()
{
Vector2 newMercatorPos;
//if (CurrentMapSource is YandexMap) {
//newMercatorPos = MercatorProjectionYandex.Instance.FromLatLngToPixel(CenterPositionWorld.Y, CenterPositionWorld.X, 0) / 256.0f;
//} else {
newMercatorPos = GeoHelper.WorldToTilePos(CenterPositionWorld);
//}
var diff = newMercatorPos - CenterPositionMercator;
if (diff != Vector2.Zero)
{
Vector3 scale, translation;
Quaternion rotation;
Transform.TranslationVector = Transform.TranslationVector - new Vector3(diff * Zoom, 0);
Transform.Decompose(out scale, out rotation, out translation);
Offset = new Vector2(translation.X, translation.Y);
Zoom = scale.X * 1280;
}
}
/// <summary>
/// 将楼梯中所有与选择的表面相同方向的面上都生成面层
/// </summary>
/// <param name="docTran"> </param>
/// <param name="elem"> 用来生成面层的单元。此函数会搜索此单元中所有与 baseFace 同法向的面，并进行面层的绘制 </param>
/// <param name="pickedFace"> 楼梯中用来生成面层的那个面</param>
/// <param name="faceOp"> 生成面层的选项</param>
/// <param name="transf"> </param>
/// <returns></returns>
private IList <DirectShape> ExtendToFacesWithSameNormal(Transaction docTran, Element elem, PlanarFace pickedFace, FaceOptions faceOp, Transform transf)
{
IList <DirectShape> directShapes = new List <DirectShape>();
// 值中的false 表示solid 是 Family中的solid，后期还要再进行一次transform才能变换 Familyinstance 所对应的位置
Dictionary <Solid, bool> solids = GeoHelper.GetSolidsInModel(elem, GeoHelper.SolidVolumnConstraint.Positive);
foreach (Solid solid in solids.Keys)
{
foreach (Face face in solid.Faces)
{
if ((face is PlanarFace))
{
PlanarFace planarFace = (PlanarFace)face;
if (GeoHelper.IsSameDirection(planarFace.FaceNormal, transf.OfVector(pickedFace.FaceNormal)))
{
DirectShape ds = ConstructSurfaceFromPlanarFace(docTran, planarFace, faceOp, Transform.Identity);
if (ds != null)
{
directShapes.Add(ds);
}
}
}
}
}
return(directShapes);
}
private void m_listener_Rendering(object sender, EventArgs e)
{
bool stillAnimating = false;
foreach (SetCard3D card in m_cards)
{
double zTranslateTarget = (card.IsChecked) ? 50 : 0;
zTranslateTarget += (card.IsMouseOver) ? -10 : 0;
double attractionFactor = .05;
attractionFactor *= 1 + (card.Variation - .5);
double newTranslate, newVelocity;
stillAnimating = GeoHelper.Animate(card.TranslateTransform3D.OffsetZ, card.CurrentZVelocity, zTranslateTarget,
attractionFactor, .3, 1000, .00001, .00001,
out newTranslate, out newVelocity) || stillAnimating;
card.CurrentZVelocity = newVelocity;
card.TranslateTransform3D.OffsetZ = newTranslate;
}
if (!stillAnimating)
{
m_listener.StopListening();
}
}
/// <summary>
/// speichert die aktuellen Höhenangaben und die kumulierte Länge in einer Datei (z.B. um ein Höhenprofil zu erzeugen)
/// <para>Vor jedem Tracksegment steht eine Zeile mit dem Tracknamen und der Segmentnummer.</para>
/// </summary>
/// <param name="file"></param>
public void SaveHeight(string file)
{
Console.Error.WriteLine("speichere Höhenprofil in {0} ...", file);
double length = 0;
using (System.IO.StreamWriter stream = new System.IO.StreamWriter(file)) {
for (int t = 0; t < TrackCount(); t++)
{
for (int s = 0; s < TrackSegmentCount(t); s++)
{
stream.WriteLine("# Track {0} ({1}), Segment {2}", t + 1, GetTrackname(t), s + 1);
List <GpxTrackPoint> pt = GetTrackSegmentPointList(t, s, false);
if (pt.Count > 0)
{
stream.WriteLine("0\t{0}", pt[0].Elevation != BaseElement.NOTVALID_DOUBLE ? pt[0].Elevation.ToString("f1") : "");
}
for (int p = 1; p < pt.Count; p++)
{
length += GeoHelper.Wgs84Distance(pt[p - 1].Lon, pt[p].Lon, pt[p - 1].Lat, pt[p].Lat, GeoHelper.Wgs84DistanceCompute.ellipsoid);
stream.WriteLine("{0:F1}\t{1}",
length,
pt[p].Elevation != BaseElement.NOTVALID_DOUBLE ? pt[p].Elevation.ToString("f1") : "");
}
}
}
}
}
public FieldMapAnnotation(Field field)
{
coordinate = new CLLocationCoordinate2D(GeoHelper.CalculateCenter(field.BoundingCoordinates).Latitude, GeoHelper.CalculateCenter(field.BoundingCoordinates).Longitude);
Field = field;
title = field.Name;
subtitle = string.Format("Number of blocks: {0}", field.Blocks.Count);
}
public List <string> GetConnections(double latitude, double longitude)
{
List <string> conn = new List <string>();
var point = new Position(latitude, longitude);
try
{
lock (coordUser)
{
foreach (var p in coordUser)
{
var test = GeoHelper.CalculateDistance(point, p.Value);
if (GeoHelper.CalculateDistance(point, p.Value) < 15000)
{
conn.Add(p.Key);
}
}
}
}
catch
{
conn = null;
}
return(conn);
}
public void TestBearingCalculating()
{
Point a = new Point
{
Lat = 39.099912,
Long = -94.581213
};
Point b = new Point
{
Lat = 38.627089,
Long = -90.200203
};
Assert.AreEqual(96.51, Math.Round(GeoHelper.GetBearing(a, b), 2));
Point a1 = new Point
{
Lat = 52.457182,
Long = 31.026222
};
Point b1 = new Point
{
Lat = 52.457323,
Long = 31.026065
};
double bearing = GeoHelper.GetBearing(a1, b1);
Assert.AreEqual(325.84, Math.Round(bearing, 2));
}
public void Test000_Distance()
{
SIGENCEScenarioToolTestCaseHelper.ShowTestCaseInformation();
//-----------------------------------------------------------------
// Possibility 1
{
//var p1 = GetSqlGeometry( GeoHelper.PORTANIGRA );
//var p2 = GetSqlGeometry( GeoHelper.AMPHITHEATER );
var p1 = GetSqlGeometry(GeoHelper.CreatePoint(47.666557, 9.386941));
var p2 = GetSqlGeometry(GeoHelper.CreatePoint(47.666100, 9.172648));
var dist = p1.STDistance(p2);
Log.InfoFormat("Point 1 -> Point 2 :{0}", dist * 100);
}
// Possibility 2
{
double dist = NetTopologySuite.Operation.Distance.DistanceOp.Distance(GeoHelper.PORTANIGRA, GeoHelper.AMPHITHEATER);
Log.InfoFormat("Port Nigra -> Amphitheater :{0}", dist * 100);
}
// Possibility 3
{
double dist = GeoHelper.PORTANIGRA.Distance(GeoHelper.AMPHITHEATER);
Log.InfoFormat("Port Nigra -> Amphitheater :{0}", dist * 100);
}
}
public HomePage()
{
App.Current.Resources["PositionOrigin"] = new Point(0.5, 0.5);
this.InitializeComponent();
Map.MapServiceToken = Constants.MapServiceToken;
var messenger = Mvx.Resolve <IMvxMessenger>();
UserInfo.Tapped += (sender, args) =>
{
Debug.WriteLine("position tapped");
args.Handled = true;
};
_locationToken = messenger.Subscribe <LocationMessage>(async message =>
{
if (!message.IsError)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
var geoPoint = new Geopoint(new BasicGeoposition {
Latitude = message.Lat, Longitude = message.Lng
});
await InitializeUserPositionIfNeeded(geoPoint, message.Accuracy);
var vals = GeoHelper.CalculatePolygon(message.Lat, message.Lng, message.Accuracy ?? 0).Select(p => p.ToNative().Position);
_accuracyPolygon.Path = new Geopath(vals);
});
}
});
}
protected override Size ArrangeOverride(Size finalSize)
{
Action <UIElement> arrange = delegate(UIElement child)
{
TransformGroup tg = (TransformGroup)child.RenderTransform;
ScaleTransform st = (ScaleTransform)tg.Children[0];
TranslateTransform tt = (TranslateTransform)tg.Children[3];
Size childSize = child.DesiredSize;
child.Arrange(new Rect(childSize));
tt.SetToVector(finalSize.CenterVector() - childSize.CenterVector());
double scale = GeoHelper.ScaleToFit(finalSize, childSize);
st.ScaleX = scale;
st.ScaleY = scale;
};
m_elements.ForEach(arrange);
m_fadingElements.ForEach(arrange);
return(finalSize);
}
private static bool updateChildData(AnimatingPanelItemData data, double dampening, double attractionFactor, double variation)
{
if (data == null)
{
return(false);
}
else
{
Debug.Assert(dampening > 0 && dampening < 1);
Debug.Assert(attractionFactor > 0 && !double.IsInfinity(attractionFactor));
attractionFactor *= 1 + (variation * data.RandomSeed - .5);
Point newLocation;
Vector newVelocity;
bool anythingChanged =
GeoHelper.Animate(data.Current, data.LocationVelocity, data.Target,
attractionFactor, dampening, c_terminalVelocity, c_diff, c_diff,
out newLocation, out newVelocity);
data.Current = newLocation;
data.LocationVelocity = newVelocity;
var transformVector = data.Current - data.Target;
data.Transform.SetToVector(transformVector);
return(anythingChanged);
}
}
/// <summary>
/// 检测转向灯
/// </summary>
protected override void LeftIndicatorCheck(IndicatorCheckState checkState)
{
//角度设置0时，不进行角度达到检测转向灯
if (checkState == IndicatorCheckState.MidCheckAngle && Settings.TurnLeftAngle < 0.5)
{
return;
}
if (indicatorChecked)
{
return;
}
if (checkState == IndicatorCheckState.MidCheckAngle)
{
//设置了变道角度后
if (CurrentAngle.IsValidAngle() &&
StartAngle.IsValidAngle() &&
!GeoHelper.IsBetweenDiffAngle(CurrentAngle, StartAngle, Settings.TurnLeftAngle))
{
if (Settings.TurnLeftEndFlag)
{
stopDelayDistance = CurrentDistance;
}
CheckLeft();
}
}
else if (checkState == IndicatorCheckState.StopCheck)
{
CheckLeft();
}
}
/// <summary>
/// 查找同方向的最近点位
/// </summary>
/// <param name="signalInfo"></param>
/// <returns></returns>
public MapPoint[] Search(CarSignalInfo signalInfo)
{
//无航向角（停车时）不搜索点位
if (MapPoints.Length == 0 || !signalInfo.Gps.AngleDegrees.IsValidAngle() || signalInfo.CarState == CarState.Stop)
{
return(new MapPoint[0]);
}
var gps = signalInfo.Gps;
//
//搜索20米内同方向（相同15角度类）的所有点位
var query = from a in MapPoints
where
a.PointType != MapPointType.Normal &&
GeoHelper.IsBetweenDiffAngle(a.Point.Angle, gps.AngleDegrees, 15) &&
(GeoHelper.GetDistance(a.Point.Longitude, a.Point.Latitude, gps.LongitudeDegrees, gps.LatitudeDegrees) <= 15)
select a;
var items = query.ToArray();
if (items.Any())
{
foreach (var _item in items)
{
Logger.InfoFormat("搜索符合点：{0}-{1}-{2}-{3}", _item.Name, _item.Point.Longitude, _item.Point.Latitude, _item.Point.Angle);
Logger.InfoFormat("当前GPS：{0}-{1}-{2}", signalInfo.Gps.LongitudeDegrees, signalInfo.Gps.LatitudeDegrees, signalInfo.Gps.AngleDegrees);
}
}
return(items);
//return null;
}
void SetHeatMapCoordinates(double left, double right, double top, double bottom)
{
if (heatMapLeft == left && heatMapRight == right && heatMapTop == top && heatMapBottom == bottom)
{
return;
}
heatMapLeft = left;
heatMapRight = right;
heatMapTop = top;
heatMapBottom = bottom;
if (heatVB != null)
{
heatVB.Dispose();
}
if (heatIB != null)
{
heatIB.Dispose();
}
var lt = GeoHelper.WorldToTilePos(new DVector2(left, top));
var rb = GeoHelper.WorldToTilePos(new DVector2(right, bottom));
GenerateTileGrid(10, out heatVB, out heatIB, lt.X, rb.X, lt.Y, rb.Y, 0);
}
/// <summary>
/// If the a ship's bearing to a given position is less than 90 degrees away from exact heading needed to get to the port,
/// Then we says that a ship is moving toward that port
/// </summary>
/// <param name="shipTest">shipTest object</param>
/// <param name="position">Location of port that ship may be moving toward</param>
/// <returns>true or false</returns>
public static bool IsMovingToward(this ShipTest shipTest, Position position)
{
var bearing = GeoHelper.GetBearing(shipTest.Position, position);
var difference = Math.Abs(shipTest.Heading - bearing);
return(difference <= 90);
}
internal async Task MoveNearbyCircleToUser()
{
if (OwnedBy != SearchSection.Nearby)
{
return;
}
if (_tokenSource != null && !_tokenSource.IsCancellationRequested)
{
_tokenSource.Cancel();
}
_tokenSource = new CancellationTokenSource();
IsOverviewLoading = true;
GenericResult <Geoposition> result = await _geolocation.GetCurrentLocationAsync();
if (result.HasResult)
{
MapCircles.Clear();
_messenger.Send(new MessageTypes.CenterMapOnGeoposition(result.Result.Coordinate.Point.Position));
MapCircles.Add(new ColoredGeocircle(GeoHelper.GetGeocirclePoints(result.Result.Coordinate.Point, GeocircleRadiusMeters, GeocircleNumberOfPoints),
result.Result.Coordinate.Point.Position));
await UpdateNearbyPlaces(new Geocircle(result.Result.Coordinate.Point.Position, GeocircleRadiusMeters), _tokenSource.Token);
}
IsOverviewLoading = false;
}
public async Task <IActionResult> InTime(TimeTrackerModel timeTrackerModel)
{
string user = User.FindFirst("Index").Value;
var Currentuser = await _taskRepository.GetCurrentUser(user);
ViewBag.photo = Currentuser.PhotoURL;
timeTrackerModel.EmpId = Currentuser.EmpId;
bool existOne = _timeTrackRepo.CheckIn(timeTrackerModel.EmpId);
if (existOne)
{
return(RedirectToAction(nameof(Portal)));
}
else
{
JSONToViewModel model = new JSONToViewModel();
GeoHelper geoHelper = new GeoHelper();
var result = await geoHelper.GetGeoInfo();
model = JsonConvert.DeserializeObject <JSONToViewModel>(result);
timeTrackerModel.Inlocation = model.City;
timeTrackerModel.Inlatitude = model.Latitude;
timeTrackerModel.InLongitude = model.Longitude;
int id = await _timeTrackRepo.InTimeMark(timeTrackerModel);
if (id > 0)
{
return(RedirectToAction(nameof(Portal)));
}
}
return(View());
}
public static double CalculateDistances(this IEnumerable <Coordinate> points)
{
if (points == null)
{
return(0);
}
var items = points.ToArray();
if (items.Length == 0)
{
return(0);
}
var last = items[0];
var sum = 0d;
foreach (var point in items)
{
var len = GeoHelper.GetDistance(last.Longitude, last.Latitude, point.Longitude, point.Latitude);
if (!double.IsNaN(len))
{
sum += len;
}
last = point;
}
return(sum);
}
/// <summary>
/// 从一组曲线中找到一条与连续链左端点相接的曲线，并且在适当的情况下，对搜索到的曲线进行反转。
/// </summary>
/// <param name="curves">进行搜索的曲线集合。在此函数中，可能会对连接到的那条曲线进行反转。
/// IDictionary中的键值表示每一条Curve的Id值，这个值并不一定是从1开始递增的。</param>
/// <returns>与连续曲线链的最右端相连的那一条曲线在输入的曲线集合中所对应的Id键值。
/// 如果没有找到连接的曲线，则返回Nothing！</returns>
public Nullable <int> CheckBackward(Dictionary <int, Curve> curves)
{
// 搜索到的那一条曲线所对应的Id值
Nullable <int> ConnectedCurveIndex = new Nullable <int>();
ConnectedCurveIndex = null; // 如果没有找到，则返回Nothing
//
var Ids = curves.Keys.ToArray();
var Cvs = curves.Values;
//
int tempId = 0;
Curve tempCurve = default(Curve);
// 从曲线集合中找出起点与上面的终点重合的曲线 。 find curve with start point = end point
for (int i = 0; i <= Ids.Length - 1; i++)
{
tempId = Ids[i];
tempCurve = curves[tempId];
// Is there a match end->start, if so this is the next curve
if (GeoHelper.IsAlmostEqualTo(tempCurve.GetEndPoint(0), this.end0, GeoHelper.VertexTolerance))
{
// 将曲线进行反转
curves[tempId] = tempCurve.CreateReversed();
return(tempId);
}
else if (GeoHelper.IsAlmostEqualTo(tempCurve.GetEndPoint(1), this.end0, GeoHelper.VertexTolerance))
{
return(tempId);
}
}
//
return(ConnectedCurveIndex);
}
private void m_listener_rendering(object sender, EventArgs e)
{
if (this.Child != m_zapPanel)
{
m_zapPanel = (PagingPanel)this.Child;
m_zapPanel.RenderTransform = m_traslateTransform;
}
if (m_zapPanel != null)
{
int actualTargetIndex = Math.Max(0, Math.Min(m_zapPanel.Children.Count - 1, TargetIndex));
double targetPercentOffset = -actualTargetIndex / (double)m_zapPanel.Children.Count;
targetPercentOffset = double.IsNaN(targetPercentOffset) ? 0 : targetPercentOffset;
bool stopListening = !GeoHelper.Animate(
m_percentOffset, m_velocity, targetPercentOffset,
.05, .3, .1, c_diff, c_diff,
out m_percentOffset, out m_velocity);
double targetPixelOffset = m_percentOffset * (this.RenderSize.Width * m_zapPanel.Children.Count);
m_traslateTransform.X = targetPixelOffset;
if (stopListening)
{
m_listener.StopListening();
}
}
}
public async Task LatLngAndPostcodeSpecifiedUsesLatLngOverPostcode_AddsFilterToQuery()
{
// Arrange
var postcode = "AB1 2DE";
var postcodeLat = 1m;
var postcodeLng = 2m;
ConfigureOnspdSearchResultsForPostcode(postcode, coords: (postcodeLat, postcodeLng));
var lat = 5d;
var lng = 6d;
var distance = 10;
var distanceInKm = GeoHelper.MilesToKilometers(10);
var request = CreateRequest(new
{
sortBy = "Distance",
postcode = postcode,
latitude = lat,
longitude = lng,
distance = distance
});
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.EnsureSuccessStatusCode();
CapturedQuery.GenerateSearchQuery().Options.Filter.Should().Contain(
$"geo.distance(Position, geography'POINT({lng} {lat})') le {distanceInKm}");
}
public async Task DistanceSpecifiedWithLatLng_AddsFilterToQuery()
{
// Arrange
var lat = 1m;
var lng = 2m;
var distance = 10;
var distanceInKm = GeoHelper.MilesToKilometers(10);
var request = CreateRequest(new
{
sortBy = "Distance",
latitude = lat,
longitude = lng,
distance = distance
});
// Act
var response = await HttpClient.SendAsync(request);
// Assert
response.EnsureSuccessStatusCode();
CapturedQuery.GenerateSearchQuery().Options.Filter.Should().Contain(
$"geo.distance(Position, geography'POINT({lng} {lat})') le {distanceInKm}");
}
public void SuccessfulDistanceCalculationInNauticalMiles()
{
Assert.AreEqual(
GeoHelper.DistanceBetweenCoord(TestDestination, TestShipPosition, GeoHelper.Units.NauticalMiles),
ExpectedDistanceInNmi,
ExpectedDistanceInNmi * DeltaPercentage
);
}
/// <param name="angleRadians">The angle, in radians, from 3-o'clock going counter-clockwise.</param>
public static void DrawLine(this DrawingContext drawingContext, Pen pen, Point startPoint, double angleRadians, double length)
{
Contract.Requires <ArgumentNullException>(drawingContext != null);
Contract.Requires <ArgumentException>(startPoint.IsValid());
Contract.Requires <ArgumentNullException>(pen != null);
drawingContext.DrawLine(pen, startPoint, startPoint + GeoHelper.GetVectorFromAngle(angleRadians, length));
}
public void GeoCircle_Contains()
{
var circle = new GeoCircle(GeoCoordinate.Origin, 10, GeoHelper.EarthRadiusMiles);
Assert.IsTrue(circle.Contains(circle.Center));
Assert.IsTrue(circle.Contains(GeoHelper.Plot(circle.Center, 0.45, 5, GeoHelper.EarthRadiusMiles)));
Assert.IsFalse(circle.Contains(GeoHelper.Plot(circle.Center, 0.45, 15, GeoHelper.EarthRadiusMiles)));
}
public void SuccessfulDistanceCalculationInKilometers()
{
Assert.AreEqual(
GeoHelper.DistanceBetweenCoord(TestDestination, TestShipPosition, GeoHelper.Units.KiloMeter),
ExpectedDistanceInKm,
ExpectedDistanceInKm * DeltaPercentage
);
}
public void SuccessfulDistanceCalculationInMiles()
{
Assert.AreEqual(
GeoHelper.DistanceBetweenCoord(TestDestination, TestShipPosition),
ExpectedDistanceInMiles,
ExpectedDistanceInMiles * DeltaPercentage
);
}
/// <summary>
/// Get problem spefic experts who quoted or all
/// experts for a category/sub category combination.
/// </summary>
/// <param name="sessionKey">string</param>
/// <param name="problemid">string</param>
/// <param name="categoryid">string</param>
/// <param name="subcategoryid">string</param>
/// <returns>SessionResponseObject</returns>
public ResponseObjectForAnything GetExpertsByCatSubCat(string sessionKey, string pincode, string distance, string categoryid, string subcategoryid)
{
List<User> lstexperts = new List<User>();
List<ProblemBid> lstProblemBids = new List<ProblemBid>();
ResponseObjectForAnything responseObject = new ResponseObjectForAnything();
SessionResponseObject session = new SessionResponseObject();
AuthenticationEngine authEngine = new AuthenticationEngine();
bool isValid = authEngine.IsValidSession(sessionKey);
DataSet dsExperts = new DataSet();
if(isValid)
{
try
{
Database db = DatabaseFactory.CreateDatabase();
DbCommand dbCommand = db.GetStoredProcCommand("usp_GetExperts");
float latitude, longitude;
GeoHelper geoHelper = new GeoHelper();
geoHelper.GetGeoLocationByPinCode(pincode, out latitude, out longitude);
db.AddInParameter(dbCommand, "@Distance", DbType.Decimal, distance);
db.AddInParameter(dbCommand, "@Latitude", DbType.Decimal, latitude);
db.AddInParameter(dbCommand, "@Longitude", DbType.Decimal, longitude);
db.AddInParameter(dbCommand, "@CategoryID", DbType.Int32, Int32.Parse(categoryid));
db.AddInParameter(dbCommand, "@SubCategoryID", DbType.Int32, Int32.Parse(subcategoryid));
dsExperts = db.ExecuteDataSet(dbCommand);
if(dsExperts.Tables.Count > 0)
{
DataTable tUser = dsExperts.Tables[0];
foreach(DataRow tRow in tUser.Rows)
{
User user = new User();
if (tRow["UserID"] != DBNull.Value) { user.UserID = Int32.Parse(tRow["UserID"].ToString()); }
if (tRow["UserRoleID"] != DBNull.Value) { user.UserID = Int32.Parse(tRow["UserRoleID"].ToString()); }
if (tRow["FirstName"] != DBNull.Value) { user.FirstName = tRow["FirstName"].ToString(); }
if (tRow["LastName"] != DBNull.Value) { user.LastName = tRow["LastName"].ToString(); }
if (tRow["DisplayName"] != DBNull.Value) { user.DisplayName = tRow["DisplayName"].ToString(); }
if (tRow["EmailID"] != DBNull.Value) { user.EmailID = tRow["EmailID"].ToString(); }
if (tRow["PinCode"] != DBNull.Value) { user.PinCode = tRow["PinCode"].ToString(); }
if (tRow["Address1"] != DBNull.Value) { user.Address1 = tRow["Address1"].ToString(); }
if (tRow["Address2"] != DBNull.Value) { user.Address2 = tRow["Address2"].ToString(); }
if (tRow["Address3"] != DBNull.Value) { user.Address3 = tRow["Address3"].ToString(); }
if (tRow["City"] != DBNull.Value) { user.City = tRow["City"].ToString(); }
if (tRow["Distance"] != DBNull.Value) { user.Distance = Convert.ToDecimal(tRow["Distance"].ToString()); }
if (tRow["PhoneNumber"] != DBNull.Value) { user.PhoneNumber = tRow["PhoneNumber"].ToString(); }
if (tRow["ProfilePicPath"] != DBNull.Value) { user.ProfilePicPath = tRow["ProfilePicPath"].ToString(); }
if (tRow["AvgRating"] != DBNull.Value) { user.AvgRating = Convert.ToDecimal(tRow["AvgRating"].ToString()); }
lstexperts.Add(user);
}
responseObject.ResultCode = "SUCCESS";
responseObject.ResultObjectRecordCount = tUser.Rows.Count;
responseObject.ResultObjectJSON = Serializer.ObjectToJSON(lstexperts);
if (tUser.Rows.Count == 0) { responseObject.ResultMessage = "No Experts found for this combination of category and subcategory."; }
}
}
catch (Exception ex)
{
responseObject.ResultCode = "ERROR";
responseObject.ResultMessage = ex.Message;
CustomException exc = new CustomException(ex.ToString(), this.ToString(), "GetExpertsByCatSubCat", System.DateTime.Now);
ExceptionManager.PublishException(exc);
}
}
return responseObject;
}
/// <summary>
/// This method creates/updates a problem into the system.
/// </summary>
/// <param name="sessionKey">string</param>
/// <param name="problemId">string</param>
/// <param name="companyRelated">string</param>
/// <param name="companyId">string</param>
/// <param name="problemHeading">string</param>
/// <param name="hastags">string</param>
/// <param name="categoryId">string</param>
/// <param name="subcategoryId">string</param>
/// <param name="productId">string</param>
/// <param name="modelNo">string</param>
/// <param name="description">string</param>
/// <param name="purchaseMonth">string</param>
/// <param name="purchaseYear">string</param>
/// <param name="productStatus">string</param>
/// <param name="resolutionneededby">string</param>
/// <param name="thumbnailmedia">string</param>
/// <param name="hashtags">string</param>
/// <param name="imagesupload">string</param>
/// <param name="videosupload">string</param>
/// <param name="isVirtual">string</param>
/// <param name="isRegisteredAddress">string</param>
/// <param name="address1">string</param>
/// <param name="address2">string</param>
/// <param name="address3">string</param>
/// <param name="city">string</param>
/// <param name="stateId">string</param>
/// <param name="countryId">string</param>
/// <param name="pinCode">string</param>
/// <param name="isEdit">string</param>
/// <returns>string</returns>
public string SaveProblem(string sessionKey, string problemId, string companyRelated, string companyId, string problemHeading, string categoryId, string subcategoryId, string productId, string modelNo,
string description, string purchaseMonth, string purchaseYear, string productStatus, string resolutionneededby, string hashtags, string isVirtual,
string isRegisteredAddress, string address1, string address2, string address3, string city, string stateId, string countryId, string pinCode)
{
string retVal = string.Empty;
Int32 probId = -1;
AuthenticationEngine authEngine = new AuthenticationEngine();
MyProfileObject user = new MyProfileObject();
bool isValid = authEngine.IsValidSession(sessionKey);
ResponseObjectForAnything responseobject = new ResponseObjectForAnything();
if(isValid)
{
responseobject = authEngine.GetUserFromSession(sessionKey);
user = (MyProfileObject)Serializer.JSONStringToObject<MyProfileObject>(responseobject.ResultObjectJSON);
if (user != null)
{
try
{
if (!string.IsNullOrEmpty(problemId)) { probId = Int32.Parse(problemId); }
Database db = DatabaseFactory.CreateDatabase();
DbCommand dbCommand = db.GetStoredProcCommand("usp_UpsertProblem");
if (!string.IsNullOrEmpty(problemId)) { db.AddInParameter(dbCommand, "ProblemId", DbType.Int32, Int32.Parse(problemId)); }
else { db.AddInParameter(dbCommand, "ProblemId", DbType.Int32, null); }
db.AddInParameter(dbCommand, "UserId", DbType.Int32, user.UserObject.UserID);
db.AddInParameter(dbCommand, "CompanyRelated", DbType.Boolean, Convert.ToBoolean(companyRelated));
if (!string.IsNullOrEmpty(companyId)) { db.AddInParameter(dbCommand, "CompanyID", DbType.Int32, Int32.Parse(companyId)); }
db.AddInParameter(dbCommand, "ProblemHeading", DbType.String, problemHeading);
db.AddInParameter(dbCommand, "CategoryID", DbType.Int32, Int32.Parse(categoryId));
db.AddInParameter(dbCommand, "SubCategoryID", DbType.Int32, Int32.Parse(subcategoryId));
if (!string.IsNullOrEmpty(productId)) { db.AddInParameter(dbCommand, "ProductID", DbType.Int32, Int32.Parse(productId)); }
db.AddInParameter(dbCommand, "ModelNo", DbType.String, modelNo);
db.AddInParameter(dbCommand, "Description", DbType.String, description);
db.AddInParameter(dbCommand, "PurchaseMonth", DbType.String, purchaseMonth);
db.AddInParameter(dbCommand, "PurchaseYear", DbType.String, purchaseYear);
db.AddInParameter(dbCommand, "ProductStatusID", DbType.String, Int32.Parse(productStatus));
if (!string.IsNullOrEmpty(resolutionneededby)) { db.AddInParameter(dbCommand, "ResolutionNeededBy", DbType.DateTime, Convert.ToDateTime(resolutionneededby)); }
else { db.AddInParameter(dbCommand, "ResolutionNeededBy", DbType.DateTime, null); }
string[] problemhashtags = hashtags.Split(",".ToCharArray());
DataSet dsHashTags = ToDataSet(problemhashtags, "Name");
db.AddInParameter(dbCommand, "ProblemHashTags", DbType.Xml, dsHashTags.GetXml());
db.AddInParameter(dbCommand, "IsVirtual", DbType.Boolean, Convert.ToBoolean(isVirtual));
db.AddInParameter(dbCommand, "IsRegisteredAddress", DbType.Boolean, Convert.ToBoolean(isRegisteredAddress));
db.AddInParameter(dbCommand, "Address1", DbType.String, address1);
db.AddInParameter(dbCommand, "Address2", DbType.String, address2);
db.AddInParameter(dbCommand, "Address3", DbType.String, address3);
db.AddInParameter(dbCommand, "City", DbType.String, city);
if (!string.IsNullOrEmpty(stateId)) { db.AddInParameter(dbCommand, "StateID", DbType.Int32, Convert.ToInt32(stateId)); }
else { db.AddInParameter(dbCommand, "StateID", DbType.Int32, null); }
if (!string.IsNullOrEmpty(countryId)) { db.AddInParameter(dbCommand, "CountryID", DbType.Int32, countryId); }
{ db.AddInParameter(dbCommand, "CountryID", DbType.Int32, null); }
db.AddInParameter(dbCommand, "PinCode", DbType.String, pinCode);
float latitude, longitude;
GeoHelper geoHelper = new GeoHelper();
geoHelper.GetGeoLocationByPinCode(pinCode, out latitude, out longitude);
db.AddInParameter(dbCommand, "Latitude", DbType.Decimal, latitude);
db.AddInParameter(dbCommand, "Longitude", DbType.Decimal, longitude);
if (string.IsNullOrEmpty(problemId))
{
probId = Int32.Parse(db.ExecuteScalar(dbCommand).ToString());
if(probId > 0)
responseobject.ResultCode = "SUCCESS";
else
responseobject.ResultCode = "ERROR";
responseobject.ResultMessage = "Problem created successfully.";
responseobject.ResultObjectID = probId;
}
else
{
db.ExecuteNonQuery(dbCommand);
responseobject.ResultCode = "SUCCESS";
responseobject.ResultMessage = "Problem saved successfully.";
}
}
catch (Exception ex)
{
responseobject.ResultCode = "ERROR";
responseobject.ResultMessage = ex.Message;
CustomException exc = new CustomException(ex.ToString(), this.ToString(), "SaveProblem", System.DateTime.Now);
ExceptionManager.PublishException(exc);
}
}
}
retVal = Serializer.ObjectToJSON(responseobject);
return retVal;
}
/// <summary>
/// This method creates a user/expert into the system
/// and then creates the session for the user to log in.
/// </summary>
/// <param name="firstName">string</param>
/// <param name="lastName">string</param>
/// <param name="displayName">string</param>
/// <param name="emailID">string</param>
/// <param name="isUser">string</param>
/// <param name="isExpert">string</param>
/// <param name="catsubcat">string</param>
/// <param name="area">string</param>
/// <param name="city">string</param>
/// <param name="password">string</param>
/// <param name="deviceTokenId">string</param>
/// <returns>SessionResponseObject</returns>
public ResponseObjectForAnything CreateUser(string firstName, string lastName, string displayName, string emailID, string address2, string city, string pinCode,
string isUser, string isExpert, string catsubcat, string password, string deviceTokenId)
{
AuthenticationEngine authEngine = new AuthenticationEngine();
int userId = -1;
SessionResponseObject sessionObject = new SessionResponseObject();
ResponseObjectForAnything responseObject = new ResponseObjectForAnything();
try
{
string useraccount = authEngine.CheckExistingAccount(emailID);
if (useraccount == "SUCCESS")
{
Database db = DatabaseFactory.CreateDatabase();
DbCommand dbCommand = db.GetStoredProcCommand("usp_CreateUser");
db.AddInParameter(dbCommand, "FirstName", DbType.String, firstName);
db.AddInParameter(dbCommand, "LastName", DbType.String, lastName);
db.AddInParameter(dbCommand, "DisplayName", DbType.String, displayName);
db.AddInParameter(dbCommand, "EmailID", DbType.String, emailID);
db.AddInParameter(dbCommand, "Address2", DbType.String, address2);
db.AddInParameter(dbCommand, "City", DbType.String, city);
db.AddInParameter(dbCommand, "PinCode", DbType.String, pinCode);
float latitude, longitude;
GeoHelper geoHelper = new GeoHelper();
geoHelper.GetGeoLocationByPinCode(pinCode, out latitude, out longitude);
db.AddInParameter(dbCommand, "Latitude", DbType.Decimal, latitude);
db.AddInParameter(dbCommand, "Longitude", DbType.Decimal, longitude);
db.AddInParameter(dbCommand, "IsUser", DbType.Boolean, Convert.ToBoolean(isUser));
db.AddInParameter(dbCommand, "IsExpert", DbType.Boolean, Convert.ToBoolean(isExpert));
string[] lstcatsubcat = catsubcat.Split(";".ToCharArray());
DataSet dataSet = new DataSet();
DataTable dataTable = dataSet.Tables.Add();
dataTable.Columns.Add("CategoryID");
dataTable.Columns.Add("SubCategoryID");
for(int count =0; count <lstcatsubcat.Length - 1; count++)
{
string category = lstcatsubcat[count].Split(",".ToCharArray())[0];
string subcategory = lstcatsubcat[count].Split(",".ToCharArray())[1];
dataTable.Rows.Add(new object[] { category, subcategory });
}
db.AddInParameter(dbCommand, "CatSubCat", DbType.String, dataSet.GetXml());
db.AddInParameter(dbCommand, "Password", DbType.String, BitConverter.ToString(SHA1.Create().ComputeHash(Encoding.Default.GetBytes(password + ""))).Replace("-", ""));
db.AddInParameter(dbCommand, "DeviceTokenId", DbType.String, deviceTokenId);
userId = Int32.Parse(db.ExecuteScalar(dbCommand).ToString());
responseObject.ResultCode = "SUCCESS";
responseObject.ResultObjectJSON = Serializer.ObjectToJSON(sessionObject);
responseObject.ResultObjectRecordCount = userId;
if (responseObject.ResultObjectRecordCount <= 0) { responseObject.ResultMessage = "Email Id already exists."; }
}
else
{
responseObject.ResultCode = "ERROR";
responseObject.ResultMessage = "Email Id already exists.";
}
}
catch (Exception ex)
{
responseObject.ResultCode = "ERROR";
responseObject.ResultMessage = ex.Message;
CustomException exc = new CustomException(ex.ToString(), this.ToString(), "CreateUser", System.DateTime.Now);
ExceptionManager.PublishException(exc);
}
return (responseObject);
}
