public DateTime GetMaxDate(string pathToImageDirectory)
{
var localFiles = RealmInstance.All <LocalFile>().Where(l => l.SourcePath.Equals(pathToImageDirectory)).OrderBy(l => l.FileNameDate);
var maxItem = localFiles.LastOrDefault();
return(maxItem?.FileNameDate.DateTime ?? DateTime.Now);
}
internal (int pointCountInRoute, double length) GetLengthRouteData(string routeId)
{
double length = 0;
int countPoints = 0;
if (!string.IsNullOrEmpty(routeId))
{
var route = RealmInstance.Find <Route>(routeId);
if (route != null)
{
countPoints = route.Points.Count;
for (int index = 0; index < countPoints; index++)
{
if (index + 1 < countPoints)
{
var firstPoint = route.Points[index];
var secondPoint = route.Points[index + 1];
if ((firstPoint.Latitude != 0) && (firstPoint.Longitude != 0))
{
if ((secondPoint.Latitude != 0) && (secondPoint.Longitude != 0))
{
Location firstPointLocation = new Location(firstPoint.Latitude, firstPoint.Longitude);
Location secondPointLocation = new Location(secondPoint.Latitude, secondPoint.Longitude);
length += Location.CalculateDistance(firstPointLocation, secondPointLocation, DistanceUnits.Kilometers);
}
}
}
}
}
}
return(countPoints, length);
}
/*internal IEnumerable<RoutePoint> GetNotSynced()
* {
* return _realmInstance.All<RoutePoint>().Where(item => !item.ServerSynced);
* }*/
internal IEnumerable <RoutePoint> GetPoints()
{
var deletedRoutes = RealmInstance.All <Route>().Where(r => r.IsDeleted).ToList().Select(d => d.RouteId);
return(RealmInstance.All <RoutePoint>().ToList().Where(r => (!deletedRoutes.Any(d => d == r.RouteId))));
//return _realmInstance.All<RoutePoint>().Where(r=>(!deletedRoutes.Any(d=>d == r.RouteId)));
}
internal IEnumerable <RoutePointMediaObject> GetMediaObjectsByRouteId(string routeId)
{
var points = RealmInstance.All <RoutePoint>().Where(p => p.RouteId == routeId);
var objects = RealmInstance.All <RoutePointMediaObject>().ToList().Where(m => (points.Any(p => p.RoutePointId == m.RoutePointId)));
return(objects);
}
internal int GetCountPublishedRoutesByCreator(string UserId)
{
List <ViewRoute> vroutes = new List <ViewRoute>();
var countRoutes = RealmInstance.All <Route>().Where(u => (u.CreatorId == UserId && u.IsPublished)).Count();
return(countRoutes);
}
internal bool Save(ViewUserInfo viewUserInfo)
{
bool result = false;
try
{
RealmInstance.Write(() =>
{
var dbObject = !string.IsNullOrEmpty(viewUserInfo.UserId) ? RealmInstance.Find <User>(viewUserInfo.UserId) : null;
if (dbObject == null)
{
dbObject = new User();
dbObject.UserId = viewUserInfo.UserId;
RealmInstance.Add(dbObject);
}
dbObject.Name = viewUserInfo.Name;
dbObject.Email = viewUserInfo.Email;
dbObject.ImgUrl = viewUserInfo.ImgUrl;
});
result = true;
}
catch (Exception e)
{
HandleError.Process("UserManager", "Save", e, false);
}
return(result);
}
internal bool Delete(string mediaObjectId)
{
bool result = false;
try
{
RealmInstance.Write(() =>
{
var mediaObject = RealmInstance.Find <RoutePointMediaObject>(mediaObjectId);
if (mediaObject != null)
{
var pointObject = RealmInstance.Find <RoutePoint>(mediaObject.RoutePointId);
if (pointObject != null)
{
mediaObject.IsDeleted = true;
mediaObject.Version++;
result = mediaObject.IsDeleted;
//нужно для того, чтобы синхронизация обнаружила отличия от сервера и проверила версии с последующей отправкой изменений на сервер
pointObject.MainRoute.ObjVerHash = string.Empty;
}
}
}
);
}
catch (Exception e)
{
HandleError.Process("RoutePointMediaObjectManager", "Delete", e, false);
}
return(result);
}
public bool SetSyncStatus(string Id, bool IsSyncPreview, bool Status)
{
bool result = false;
try
{
RealmInstance.Write(() =>
{
var mediaObject = RealmInstance.Find <RoutePointMediaObject>(Id);
if (IsSyncPreview)
{
mediaObject.PreviewServerSynced = Status;
}
else
{
mediaObject.OriginalServerSynced = Status;
}
}
);
result = true;
}
catch (Exception e)
{
HandleError.Process("RoutePointMediaObjectManager", "SetSyncStatus", e, false);
}
return(result);
}
public List <string> GetFullFilenames(string pathToImageDirectory)
{
List <string> listCachedImages = new List <string>();
var listDbModel = RealmInstance.All <LocalFile>().Where(l => l.SourcePath.Equals(pathToImageDirectory)).ToList();
return(listDbModel.Select(l => Path.Combine(pathToImageDirectory, l.SourceFileName)).ToList());
}
internal bool Delete(ViewRoutePoint viewRoutePoint)
{
bool result = false;
string rId = viewRoutePoint.RouteId;
try
{
RealmInstance.Write(() =>
{
var point = RealmInstance.Find <RoutePoint>(viewRoutePoint.Id);
foreach (var item in point.MediaObjects)
{
RealmInstance.Remove(item);
}
RealmInstance.Remove(point);
});
result = true;
}
catch (Exception e)
{
HandleError.Process("RoutePointManager", "DeleteRoutePoint", e, false);
}
return(result);
}
internal ViewPoi GetPoiByRoutePointId(string routePointId)
{
var poiDb = RealmInstance.All <Poi>().Where(p => !p.IsDeleted && p.ByRoutePointId.Equals(routePointId)).FirstOrDefault();
if (poiDb != null)
{
return(new ViewPoi(poiDb.PoiId));
}
return(new ViewPoi());
}
public IEnumerable <Tuple <double?, double?> > GetTrackByRoute(string routeId)
{
var collectionRealm = RealmInstance.All <RouteTrackPlace>().Where(place => place.RouteTrackId.Equals(routeId))
.OrderBy(place => place.DateTimeBegin).ToList().Select(place => new
{
place.Latitude, place.Longitude
});
return(collectionRealm.Select(x => new Tuple <double?, double?>(x.Latitude, x.Longitude)));
}
internal IEnumerable <RoutePointMediaObject> GetNotSyncedMediaObjects(bool OnlyPreview)
{
if (OnlyPreview)
{
return(RealmInstance.All <RoutePointMediaObject>().Where(x => !x.PreviewServerSynced));
}
else
{
return(RealmInstance.All <RoutePointMediaObject>().Where(x => !x.OriginalServerSynced));
}
}
internal ObservableCollection <ViewRoute> GetRoutes(string userId)
{
ObservableCollection <ViewRoute> vRoutes = new ObservableCollection <ViewRoute>();
var routes = RealmInstance.All <Route>().Where(u => (!u.IsDeleted && !u.IsPublished) || (!u.IsDeleted && u.IsPublished && u.CreatorId == userId)).OrderByDescending(r => r.CreateDate);
foreach (var route in routes)
{
vRoutes.Add(new ViewRoute(route.RouteId));
}
return(vRoutes);
}
internal Tuple <RoutePoint, RoutePoint> GetFirstAndLastPoints(string routeId)
{
var routePoints = RealmInstance.All <RoutePoint>().Where(p => p.RouteId == routeId).OrderBy(p => p.CreateDate);
if (routePoints.Count() > 0)
{
var first = routePoints.FirstOrDefault();
var last = routePoints.LastOrDefault();
return(new Tuple <RoutePoint, RoutePoint>(first, last));
}
return(new Tuple <RoutePoint, RoutePoint>(new RoutePoint(), new RoutePoint()));
}
public List <Tuple <DateTime, int> > GetCountImagesByDay(DateTime dateBegin, DateTime dateEnd,
string pathToImageDirectory)
{
var countByDays = RealmInstance.All <LocalFile>()
.Where(f => f.FileNameDate >= dateBegin && f.FileNameDate <= dateEnd && f.SourcePath.Equals(pathToImageDirectory))
.ToList();
var grouped = countByDays.GroupBy(f =>
new DateTime(f.FileNameDate.Year, f.FileNameDate.Month, f.FileNameDate.Day))
.Select(g => new Tuple <DateTime, int>(g.Key, g.Count())).ToList();
return(grouped);
}
internal (ViewRoutePoint, ViewRoutePoint) GetFirstAndLastViewRoutePoints(string routeId)
{
var routePoints = RealmInstance.All <RoutePoint>().Where(p => p.RouteId == routeId).OrderBy(p => p.CreateDate);
if (routePoints.Count() > 0)
{
var first = new ViewRoutePoint(routeId, routePoints.FirstOrDefault()?.RoutePointId);
var last = new ViewRoutePoint(routeId, routePoints.LastOrDefault()?.RoutePointId);
return(first, last);
}
return(new ViewRoutePoint(), new ViewRoutePoint());
}
/// <summary>
/// На данном этапе публичные маршруты ничем почти не отличаются от обычных
/// </summary>
/// <returns></returns>
internal IEnumerable <ViewRoute> GetPosts()
{
List <ViewRoute> vroutes = new List <ViewRoute>();
var routes = RealmInstance.All <Route>().Where(r => r.IsPublished && !r.IsDeleted).OrderByDescending(r => r.CreateDate);
if (routes.Any())
{
foreach (var route in routes)
{
vroutes.Add(new ViewRoute(route.RouteId));
}
}
return(vroutes);
}
/// <summary>
/// Возвращает список маршрутов, созданных и опубликованных не текущим пользователем
/// </summary>
/// <param name="currentUserId"></param>
/// <returns></returns>
internal IEnumerable <ViewRoute> GetPostsOtherCreators(string currentUserId)
{
List <ViewRoute> vroutes = new List <ViewRoute>();
var routes = RealmInstance.All <Route>().Where(r => r.IsPublished && !r.CreatorId.Equals(currentUserId)).OrderByDescending(r => r.CreateDate);
if (routes.Any())
{
foreach (var route in routes)
{
vroutes.Add(new ViewRoute(route.RouteId));
}
}
return(vroutes);
}
internal IEnumerable <ViewRoute> GetRoutesForSync()
{
List <ViewRoute> vroutes = new List <ViewRoute>();
var routes = RealmInstance.All <Route>().OrderByDescending(r => r.CreateDate);
if (routes.Any())
{
foreach (var route in routes)
{
vroutes.Add(new ViewRoute(route.RouteId));
}
}
return(vroutes);
}
internal void DeleteAll()
{
try
{
RealmInstance.Write(() =>
{
RealmInstance.RemoveAll <Poi>();
});
}
catch (Exception e)
{
HandleError.Process("PoiManager", "DeleteAll", e, false);
}
}
internal ViewRoutePointMediaObject GetFirstMediaObjectByRouteId(string routeId)
{
ViewRoutePointMediaObject resultMedia = new ViewRoutePointMediaObject();
var point = RealmInstance.All <RoutePoint>().Where(p => p.RouteId == routeId && !p.IsDeleted).OrderBy(p => p.CreateDate).ToList().FirstOrDefault();
if (point != null)
{
var media = RealmInstance.All <RoutePointMediaObject>().Where(p => p.RoutePointId == point.RoutePointId && !p.IsDeleted).FirstOrDefault();
if (media != null)
{
resultMedia.Load(media.RoutePointMediaObjectId);
}
}
return(resultMedia);
}
internal string GetDefaultImagePreviewFilename(string routePointId)
{
string filename = string.Empty;
RoutePoint point = RealmInstance.Find <RoutePoint>(routePointId);
if (point?.MediaObjects.Count > 0)
{
filename = $"img_{point.MediaObjects[0].RoutePointMediaObjectId}_preview.jpg";
}
else
{
filename = "emptylist.png";
}
return(filename);
}
public List <ViewLocalFile> LocalFilesByDays(DateTime dateBegin, DateTime dateEnd, string pathToImageDirectory)
{
var listCachedFiles = RealmInstance.All <LocalFile>().Where(f => f.FileNameDate >= dateBegin && f.FileNameDate <= dateEnd && f.SourcePath.Equals(pathToImageDirectory)).ToList().Select(f => new ViewLocalFile(f.LocalFileId)
{
Address = f.Address,
Country = f.Country,
CreateDate = f.CreateDate,
FileNameDate = f.FileNameDate,
ImagePreviewFileName = f.ImagePreviewFileName,
Latitude = (long)f.Latitude,
Longitude = (long)f.Longitude,
SourceFileName = f.SourceFileName,
SourcePath = f.SourcePath,
Processed = f.Processed
}).ToList();
return(listCachedFiles);
}
internal void Delete(string poiId)
{
try
{
RealmInstance.Write(() =>
{
var poiDb = RealmInstance.Find <Poi>(poiId);
if (poiDb != null)
{
RealmInstance.Remove(poiDb);
}
});
}
catch (Exception e)
{
HandleError.Process("PoiManager", "Delete", e, false);
}
}
internal void Delete(string id)
{
try
{
RealmInstance.Write(() =>
{
var dbObject = RealmInstance.Find <LocalFile>(id);
if (dbObject != null)
{
RealmInstance.Remove(dbObject);
}
});
}
catch (Exception e)
{
HandleError.Process("LocalFileCacheManager", "Delete", e, false);
}
}
internal string Save(ViewRoutePointMediaObject vmedia)
{
string returnId = string.Empty;
try
{
var pointObject = RealmInstance.Find <RoutePoint>(vmedia.RoutePointId);
RealmInstance.Write(() =>
{
RoutePointMediaObject mediaObject = !string.IsNullOrEmpty(vmedia.Id) ? RealmInstance.Find <RoutePointMediaObject>(vmedia.Id) : null;
if (mediaObject == null)
{
mediaObject = new RoutePointMediaObject();
mediaObject.RoutePointMediaObjectId = vmedia.Id;
mediaObject.RoutePointId = vmedia.RoutePointId;
mediaObject.Point = pointObject;
RealmInstance.Add(mediaObject);
}
if (mediaObject.Version != vmedia.Version)
{
//нужно для того, чтобы синхронизация обнаружила отличия от сервера и проверила версии с последующей отправкой изменений на сервер
var route = pointObject.MainRoute;
route.ObjVerHash = string.Empty;
}
returnId = mediaObject.RoutePointMediaObjectId;
mediaObject.OriginalServerSynced = vmedia.OriginalServerSynced;
mediaObject.PreviewServerSynced = vmedia.PreviewServerSynced;
mediaObject.ServerSyncedDate = vmedia.ServerSyncedDate;
mediaObject.Version = vmedia.Version;
mediaObject.IsDeleted = vmedia.IsDeleted;
mediaObject.MediaType = (int)vmedia.MediaType;
mediaObject.Processed = vmedia.Processed;
mediaObject.ProcessResultText = vmedia.ProcessResultText;
});
}
catch (Exception e)
{
HandleError.Process("RoutePointMediaObjectManager", "SaveRoutePointMediaObject", e, false);
}
return(returnId);
}
public bool Save(ViewPoi viewPoi)
{
bool result = false;
try
{
RealmInstance.Write(() =>
{
var poi = !string.IsNullOrEmpty(viewPoi.Id) ? RealmInstance.Find <Poi>(viewPoi.Id) : null;
if (null == poi)
{
poi = string.IsNullOrEmpty(viewPoi.Id) ? new Poi() : new Poi()
{
PoiId = viewPoi.Id
};
RealmInstance.Add(poi);
}
poi.Name = viewPoi.Name;
poi.CreateDate = viewPoi.CreateDate;
poi.UpdateDate = viewPoi.UpdateDate;
poi.IsDeleted = viewPoi.IsDeleted;
poi.CreatorId = viewPoi.CreatorId;
poi.ImgFilename = viewPoi.ImgFilename;
poi.Description = viewPoi.Description;
//poi.PoiType = viewPoi.PoiType;
poi.Address = viewPoi.Address;
poi.ByRoutePointId = viewPoi.ByRoutePointId;
poi.ByRouteId = viewPoi.ByRouteId;
poi.IsPublished = viewPoi.IsPublished;
poi.Latitude = viewPoi.Location.Latitude;
poi.Longitude = viewPoi.Location.Longitude;
poi.LikesCount = viewPoi.LikesCount;
poi.ViewsCount = viewPoi.ViewsCount;
});
var poiSaved = RealmInstance.Find <Poi>(viewPoi.Id);
viewPoi.Refresh(poiSaved.PoiId);
result = true;
}
catch (Exception e)
{
HandleError.Process("PoiManager", "SavePoi", e, false);
}
return(result);
}
public bool Save(ViewRoute viewRoute)
{
bool result = false;
RouteManager routeManager = new RouteManager();
try
{
RealmInstance.Write(() =>
{
var route = !string.IsNullOrEmpty(viewRoute.Id) ? RealmInstance.Find <Route>(viewRoute.Id) : null;
if (null == route)
{
route = string.IsNullOrEmpty(viewRoute.Id) ? new Route() : new Route()
{
RouteId = viewRoute.Id
};
RealmInstance.Add(route);
}
route.Name = viewRoute.Name;
route.Version = viewRoute.Version;
route.CreateDate = viewRoute.CreateDate;
route.IsShared = viewRoute.IsShared;
route.IsPublished = viewRoute.IsPublished;
route.IsDeleted = viewRoute.IsDeleted;
route.CreatorId = viewRoute.CreatorId;
route.ObjVerHash = viewRoute.ObjVerHash;
route.ImgFilename = viewRoute.ImgFilename;
route.Description = viewRoute.Description;
if (!route.ServerSynced.Equals(viewRoute.ServerSynced) && viewRoute.ServerSynced)
{
route.ServerSyncedDate = DateTimeOffset.Now;
}
route.ServerSynced = !string.IsNullOrEmpty(viewRoute.ObjVerHash) && viewRoute.ServerSynced;
viewRoute.Refresh(route.RouteId);
});
result = true;
}
catch (Exception e)
{
HandleError.Process("RouteManager", "AddRoute", e, false);
}
return(result);
}
public void MergeRoutes(string currentUserId, List <SharedModelsWS.Route> serverRoutes)
{
List <string> mergedRoutes = new List <string>();
var routes = RealmInstance.All <Route>().Where(u => (!u.IsDeleted && !u.IsPublished) || (!u.IsDeleted && u.IsPublished && u.CreatorId == currentUserId));
foreach (var route in routes)
{
var vRoute = new ViewRoute(route.RouteId);
var serverRoute = serverRoutes.Where(sr => sr.Id.Equals(vRoute.Id)).DefaultIfEmpty().SingleOrDefault();
if (serverRoute != null)
{
vRoute.ServerSynced = serverRoute.VersionsHash.Equals(vRoute.ObjVerHash);
}
else
{
vRoute.ServerSynced = false;
}
vRoute.Save();
mergedRoutes.Add(route.RouteId);
}
foreach (var serverRoute in serverRoutes.Where(sr => !mergedRoutes.Contains(sr.Id)))
{
var vRoute = new ViewRoute(String.Empty)
{
Id = serverRoute.Id,
Name = serverRoute.Name,
Description = serverRoute.Description,
CreateDate = serverRoute.CreateDate,
CreatorId = serverRoute.CreatorId,
Version = 0,
ImgFilename = serverRoute.ImgFilename,
IsDeleted = serverRoute.IsDeleted,
IsPublished = serverRoute.IsPublished,
UserId = serverRoute.CreatorId,
ObjVerHash = "",
ServerSynced = false
};
vRoute.Save();
}
;
}
