private async Task <bool> updatePoints(RouteRoot routeRoot)
{
bool updateResult = true;
List <string> pointsToUpload = new List <string>();
var pointsByRoute = _routePointManager.GetPointsByRouteId(_routeId, true);
//если есть новые точки, на отправку
pointsToUpload.AddRange(pointsByRoute
.Where(p => !routeRoot.Route.Points.Any(sp => sp.Id == p.RoutePointId)).Select(p => p.Id)
.ToList());
foreach (var serverPoint in routeRoot.Route.Points)
{
var localPoint = _routePointManager.GetPointById(serverPoint.Id);
if ((localPoint == null) || (serverPoint.Version > localPoint.Version))
{
ViewRoutePoint updatePoint = new ViewRoutePoint(serverPoint.RouteId, serverPoint.Id);
updatePoint.FillFromWSModel(serverPoint);
updateResult = updatePoint.Save();
}
else if (serverPoint.Version < localPoint.Version)
{
//на сервере более старая версия, в очередь на отправку
pointsToUpload.Add(serverPoint.Id);
}
if (!updateResult)
{
return(false);
}
}
if (pointsToUpload.Count > 0)
{
List <ViewRoutePoint> viewPointsToUpload = new List <ViewRoutePoint>();
foreach (string routePointId in pointsToUpload)
{
viewPointsToUpload.Add(new ViewRoutePoint(routeRoot.Route.Id, routePointId));
}
updateResult = await UploadAsync(GetJsonStructuresPoints(viewPointsToUpload), _routePointsApi);
}
return(updateResult);
}
private async Task <bool> updateRoute(string routeServerHash, RouteRoot routeRoot, ViewRoute localRoute)
{
bool updateResult = false;
if (routeRoot == null)
{
return(updateResult);
}
if ((localRoute == null) || (routeRoot.Route?.Version > localRoute.Version))
{
ViewRoute updateViewRoute = new ViewRoute(_routeId);
updateViewRoute.FillFromWSModel(routeRoot, routeServerHash);
updateResult = updateViewRoute.Save();
if ((updateResult) && (!string.IsNullOrEmpty(updateViewRoute.ImgFilename)))
{
updateResult = await _routesApi.DownloadCoverImage(_routeId, updateViewRoute.ImgFilename);
}
}
else if (string.IsNullOrEmpty(routeServerHash))
{
updateResult = await UploadAsync(GetRouteJsonStructure(localRoute, ""), _routesApi);
}
else if (routeRoot.Route.Version < localRoute.Version)
{
string coverImgBase64 = string.Empty;
if (!string.IsNullOrEmpty(localRoute.ImgFilename))
{
RoutePointMediaObjectRequest mediaRequest = new RoutePointMediaObjectRequest(_apiUrl, _authToken);
var httpResult = await mediaRequest.ImageExist(localRoute.ImgFilename);
if (httpResult == HttpStatusCode.NotFound)
{
string pathToCoverImg = Path.Combine(ImagePathManager.GetPicturesDirectory(), localRoute.ImgFilename);
var bytes = File.ReadAllBytes(pathToCoverImg);
coverImgBase64 = Convert.ToBase64String(bytes);
}
}
updateResult = await UploadAsync(GetRouteJsonStructure(localRoute, coverImgBase64), _routesApi);
}
else if (routeRoot.Route.Version == localRoute.Version)
{
updateResult = true;
}
return(updateResult);
}
internal void FillFromWSModel(RouteRoot routeRoot, string routeHash)
{
if (routeRoot != null)
{
_id = routeRoot.Route.Id;
_name = routeRoot.Route.Name;
_createDate = routeRoot.Route.CreateDate;
_version = routeRoot.Route.Version;
_isShared = routeRoot.Route.IsShared;
_isPublished = routeRoot.Route.IsPublished;
_isDeleted = routeRoot.Route.IsDeleted;
_creatorId = routeRoot.Route.CreatorId;
_description = routeRoot.Route.Description;
_imgFilename = routeRoot.Route.ImgFilename;
_objVerHash = routeHash;
}
}
public async Task <RouteRoot> GetRouteRoot(string routeId)
{
RouteRoot deserializedValue = new RouteRoot();
try
{
var response = await _serverRequest.HttpRequestGet($"/api/route/{routeId}", _authToken);
LastHttpStatusCode = _serverRequest.GetLastStatusCode();
deserializedValue = JsonConvert.DeserializeObject <RouteRoot>(response);
}
catch (Exception e)
{
HandleError.Process("RoutesApiRequest", "GetRouteRoot", e, false);
}
return(deserializedValue);
}
public async Task <bool> SyncAsync(string routeServerHash, bool loadOnlyPreviewImg = false)
{
var localRoute = _routeManager.GetViewRouteById(_routeId);
//новый маршрут
if (string.IsNullOrEmpty(routeServerHash))
{
bool updateResult = await updateRoute(routeServerHash, new RouteRoot()
{
Route = new SharedModelsWS.Route()
{
Version = -1
}
}, localRoute);
_log.AddStringEvent($"route {_routeId}, create result:{updateResult}");
}
//независимо от того, новый маршрут или нет, проверяем, что изменилось - придется пройтись по всему маршруту и узнать
RouteRoot routeRoot = await _routesApi.GetRouteRoot(_routeId);
bool AuthRequired = (_routesApi.GetLastHttpStatusCode() == HttpStatusCode.Forbidden || _routesApi.GetLastHttpStatusCode() == HttpStatusCode.Unauthorized);
if ((!AuthRequired) && (routeRoot != null))
{
bool updateResult = await updateRoute(routeServerHash, routeRoot, localRoute);
if (!updateResult)
{
return(false);
}
if (!localRoute.IsDeleted)
{
updateResult = await updatePoints(routeRoot);
if (!updateResult)
{
return(false);
}
List <ViewRoutePointMediaObject> mediaForDownload = new List <ViewRoutePointMediaObject>();
List <ViewRoutePointMediaObject> mediaForUpload = new List <ViewRoutePointMediaObject>();
(updateResult, mediaForUpload, mediaForDownload) = await updateMedias(routeRoot);
if (!updateResult)
{
return(false);
}
if (mediaForDownload.Count > 0)
{
await downloadMedias(mediaForDownload, loadOnlyPreviewImg);
}
if (mediaForUpload.Count > 0)
{
await uploadMedias(mediaForUpload);
}
TrackRouteRequest trackRequest = new TrackRouteRequest(_authToken);
var trackResponse = await trackRequest.GetTrackPlacesAsync(_routeId);
if ((trackResponse != null) && (trackResponse.Places.Any()))
{
_trackFileManager.RemoveAllTracksFromRoute(_routeId);
var viewTrackPlaces = trackRequest.GetViewTrackPlaces(trackResponse.Places);
_trackFileManager.SaveTrack(_routeId, viewTrackPlaces);
}
}
}
else
{
return(false);
}
var serverHash = await _routesApi.UpdateHash(_routeId);
if (_routesApi.LastHttpStatusCode == HttpStatusCode.OK)
{
var updatedLocalRoute = _routeManager.GetViewRouteById(_routeId);
updatedLocalRoute.ServerSynced = true;
updatedLocalRoute.ObjVerHash = HashManager.Generate(getVersionsForRoute(updatedLocalRoute).ToString());
if (updatedLocalRoute.ObjVerHash.Equals(serverHash))
{
_log.AddStringEvent($"set route {_routeId}, versions {serverHash}");
updatedLocalRoute.Save();
}
else
{
_log.AddStringEvent($"failed set route {_routeId}, versions {serverHash}");
HandleError.Process("SyncRoute", "ErrorUpdateHash", new Exception("Client and Server hash different"), false, $"server:[{serverHash}], client:[{updatedLocalRoute.ObjVerHash}]");
}
if (updatedLocalRoute.IsDeleted)
{
_log.AddStringEvent($"set delete route {_routeId}");
deleteRouteContain(updatedLocalRoute);
}
}
else
{
HandleError.Process("SyncRoute", "ErrorUpdateHash", new Exception("Http error:" + _routesApi.LastHttpStatusCode.ToString()), false);
}
return(true);
}
private async Task <(bool, List <ViewRoutePointMediaObject>, List <ViewRoutePointMediaObject>)> updateMedias(RouteRoot routeRoot)
{
bool updateResult = true;
//List<string> mediasToUpload = new List<string>();
List <ViewRoutePointMediaObject> mediasToUpload = new List <ViewRoutePointMediaObject>();
List <ViewRoutePointMediaObject> mediasToDowload = new List <ViewRoutePointMediaObject>();
var medias = _routePointMediaManager.GetMediaObjectsByRouteId(routeRoot.Route.Id);
List <SharedModelsWS.RoutePointMediaObject> serverMedias = new List <SharedModelsWS.RoutePointMediaObject>();
foreach (var serverPoint in routeRoot.Route.Points)
{
serverMedias.AddRange(serverPoint.MediaObjects.Select(m => m));
}
var newMedias = medias.Where(m => !serverMedias.Any(sm => sm.Id == m.RoutePointMediaObjectId));
//новые медиа
//var refreshedNewMedias = newMedias.Select(m => new ViewRoutePointMediaObject() {Id = m.RoutePointMediaObjectId});
var refreshedNewMedias = new List <ViewRoutePointMediaObject>();
foreach (var mediaItem in newMedias)
{
ViewRoutePointMediaObject media = new ViewRoutePointMediaObject();
media.Load(mediaItem.RoutePointMediaObjectId);
refreshedNewMedias.Add(media);
}
mediasToUpload.AddRange(refreshedNewMedias);
foreach (var serverMedia in serverMedias)
{
var localMedia = _routePointMediaManager.GetMediaObjectById(serverMedia.Id);
if ((localMedia == null) || (serverMedia.Version > localMedia.Version))
{
ViewRoutePointMediaObject updateMedia = new ViewRoutePointMediaObject();
updateMedia.FillFromWSModel(serverMedia);
updateResult = updateMedia.Save();
mediasToDowload.Add(updateMedia);
}
else if (serverMedia.Version < localMedia.Version)
{
//в очередь на отправку
//mediasToUpload.Add(serverMedia.Id);
var media = new ViewRoutePointMediaObject()
{
Id = serverMedia.Id
};
media.Refresh();
mediasToUpload.Add(media);
}
if (!updateResult)
{
break;
}
}
if (mediasToUpload.Count > 0)
{
/*List<ViewRoutePointMediaObject> viewMediasToUpload = new List<ViewRoutePointMediaObject>();
* foreach (string mediaId in mediasToUpload)
* {
* var media = new ViewRoutePointMediaObject();
* media.Load(mediaId);
* viewMediasToUpload.Add(media);
* }*/
//updateResult = await UploadAsync(GetJsonStructuresMedias(viewMediasToUpload), _routePointMediaObjectsApi);
updateResult = await UploadAsync(GetJsonStructuresMedias(mediasToUpload), _routePointMediaObjectsApi);
}
return(updateResult, mediasToUpload, mediasToDowload);
}
