internal void DeleteRoutesDataFromStorage(IEnumerable <ViewRoute> routes)
{
RoutePointManager pointManager = new RoutePointManager();
RoutePointMediaObjectManager mediaManager = new RoutePointMediaObjectManager();
foreach (var vRoute in routes)
{
var points = pointManager.GetPointsByRouteId(vRoute.RouteId);
foreach (var vPoint in points)
{
var medias = mediaManager.GetMediaObjectsByRoutePointId(vPoint.RoutePointId);
foreach (var media in medias)
{
mediaManager.TryDeleteFile(media.RoutePointMediaObjectId, MediaObjectTypeEnum.Image, false);
mediaManager.TryDeleteFile(media.RoutePointMediaObjectId, MediaObjectTypeEnum.Image, true);
mediaManager.TryDeleteFile(media.RoutePointMediaObjectId, MediaObjectTypeEnum.Audio);
var vMedia = new ViewRoutePointMediaObject();
vMedia.Load(media.RoutePointMediaObjectId);
mediaManager.DeleteObjectFromLocalStorage(vMedia);
}
pointManager.DeleteObjectFromLocalStorage(vPoint);
}
DeleteObjectFromLocalStorage(vRoute);
}
}
private void deleteMedia(ViewRoutePointMediaObject media)
{
_log.AddStringEvent($"image deleted, passed mediaid:{media.RoutePointMediaObjectId}");
_routePointMediaManager.SetSyncStatus(media.RoutePointMediaObjectId, false, true);
_routePointMediaManager.SetSyncStatus(media.RoutePointMediaObjectId, true, true);
MediaFileManager fileManager = new MediaFileManager();
fileManager.Delete(media.RoutePointMediaObjectId, media.MediaType);
}
private async Task <bool> recognizeSpeechToText()
{
SyncServer syncRoute = new SyncServer();
bool synced = !await syncRoute.SyncRouteIsNeedAsync(_vpoint.RouteId);
if (!synced)
{
synced = await syncRoute.Sync(_vpoint.RouteId, false);
}
if (synced)
{
TokenStoreService tokenService = new TokenStoreService();
string authToken = await tokenService.GetAuthTokenAsync();
var audios = GetUnprocessedAudios();
int index = 0;
int count = audios.Count();
SpeechToTextHelper speechToText = new SpeechToTextHelper(authToken);
string oldDescription = _vpoint.Description;
var sb = new StringBuilder();
foreach (var audio in audios)
{
string textResult = await speechToText.TryRecognizeAudioAsync(audio.RoutePointMediaObjectId);
if (speechToText.LastHttpStatusCode == HttpStatusCode.OK)
{
sb.AppendLine(string.IsNullOrEmpty(textResult) ? "Текст не распознан" : textResult);
ViewRoutePointMediaObject vMediaObject = new ViewRoutePointMediaObject();
vMediaObject.Load(audio.RoutePointMediaObjectId);
vMediaObject.Processed = true;
vMediaObject.ProcessResultText = textResult;
vMediaObject.Save();
}
index++;
double percent = (double)index * 100 / (double)count / 100;
Xamarin.Forms.MessagingCenter.Send <SyncProgressImageLoadingMessage>(new SyncProgressImageLoadingMessage()
{
RouteId = _vpoint.RouteId, ProgressValue = percent
}, string.Empty);
}
string newDescription = sb.ToString();
if (!string.IsNullOrEmpty(newDescription) && !oldDescription.Equals(newDescription))
{
_vpoint.Description += Environment.NewLine + newDescription;
_vpoint.Version++;
_vpoint.Save();
Device.BeginInvokeOnMainThread(() =>
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Description"));
});
}
}
return(!string.IsNullOrEmpty(_vpoint.Description));
}
public PointCarouselItemViewModel(string routeId, string routePointId, string routePointMediaId)
{
_routeObject = new ViewRoute(routeId);
_pointObject = new ViewRoutePoint(routeId, routePointId);
_mediaObject = new ViewRoutePointMediaObject();
_mediaObject.Load(routePointMediaId);
ChangeImageAspectCommand = new Command(changeImageAspectCommand);
EditRoutePointCommand = new Command(editRoutePointCommand);
PhotoImageAspect = Aspect.AspectFill;
}
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 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);
}
internal void DeleteObjectFromLocalStorage(ViewRoutePointMediaObject vmedia)
{
if (vmedia != null)
{
try
{
RoutePointMediaObject media = !string.IsNullOrEmpty(vmedia.Id) ? RealmInstance.Find <RoutePointMediaObject>(vmedia.Id) : null;
if (media != null)
{
RealmInstance.Write(() =>
{
RealmInstance.Remove(media);
});
}
}
catch (Exception e)
{
HandleError.Process("RoutePointMediaObjectManager", "DeleteObjectFromLocalStorage", e, false);
}
}
}
private void deleteRouteContain(ViewRoute route)
{
_log.AddStringEvent($"delete data for route {_routeId}");
string pathToPicturesDirectory = ImagePathManager.GetPicturesDirectory();
var mediasByRoute = _routePointMediaManager.GetMediaObjectsByRouteId(route.RouteId);
foreach (var media in mediasByRoute)
{
ViewRoutePointMediaObject viewMedia = new ViewRoutePointMediaObject();
viewMedia.Load(media.RoutePointMediaObjectId);
try
{
string pathToMediaFile = ImagePathManager.GetImagePath(viewMedia.RoutePointMediaObjectId, (MediaObjectTypeEnum)media.MediaType, false);
if (File.Exists(pathToMediaFile))
{
File.Delete(pathToMediaFile);
}
string pathToMediaFilePreview = ImagePathManager.GetImagePath(viewMedia.RoutePointMediaObjectId, (MediaObjectTypeEnum)media.MediaType, true);
if (File.Exists(pathToMediaFilePreview))
{
File.Delete(pathToMediaFilePreview);
}
}
catch (Exception e)
{
HandleError.Process("DeleteRouteContain", "NewFile", e, false);
}
viewMedia.Delete();
}
var pointsByRoute = _routePointManager.GetPointsByRouteId(route.RouteId);
foreach (var point in pointsByRoute)
{
point.Delete();
}
}
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);
}
