public async Task <ActionResult <UploadData> > Post([FromForm] UploadDataRequest uploadDataRequest)
{
if (uploadDataRequest.File.Length > 0)
{
try
{
return(Ok(await _uploadFile.UploadFile(uploadDataRequest)));
}
catch (Exception ex)
{
ErrorEntity error = new ErrorEntity
{
Type = "Exception",
Message = ex.Message,
Code = 500,
Name = "Error-Utilitarios-Api"
};
return(BadRequest(error));
}
}
else
{
ErrorEntity error = new ErrorEntity
{
Type = "Exception",
Message = "Error-Verificar el Archivo",
Code = 500,
Name = "Error-Verificar el Archivo"
};
return(BadRequest(error));
}
}
public async Task <UploadData> UploadFile(UploadDataRequest uploadDataRequest)
{
UploadData Resp = new UploadData();
//condicion para crear un contenedor
uploadDataRequest.Contenedor = uploadDataRequest.Contenedor.ToLower();
var cliente = new BlobContainerClient(connectionString, uploadDataRequest.Contenedor);
try
{
await cliente.CreateIfNotExistsAsync();
cliente.SetAccessPolicy(Azure.Storage.Blobs.Models.PublicAccessType.Blob);
var extension = Path.GetExtension(uploadDataRequest.File.FileName);
var archivoNombre = $"{uploadDataRequest.NombreArchivo}{extension}";
var blob = cliente.GetBlobClient(archivoNombre);
await blob.UploadAsync(uploadDataRequest.File.OpenReadStream());
Resp.Url = blob.Uri.ToString();
Resp.Message = "Documento Cargado Correctamente";
Resp.Status = "Ok";
}
catch (Exception e)
{
Resp.Url = string.Empty;
Resp.Message = e.Message;
Resp.Status = "Error";
}
return(Resp);
}
public void Setup()
{
_apiClientMock = new Mock <IApiClient>();
_uploadRequests = new List <UploadDataRequest>();
_lastUploadRequest = null;
_apiClientMock.Setup(x => x.UploadData(It.IsAny <UploadDataRequest>()))
.Callback <UploadDataRequest>(x =>
{
_uploadDataCounter++;
_lastUploadRequest = x;
_uploadRequests.Add(x);
}).ReturnsAsync(new UploadDataResponse());
_realmFileName = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
RealmiusSyncService.RealmiusDbPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + "sync");
_syncServiceMock = CreateSyncService();
_syncServiceMock.Setup(x => x.StartUploadTask()).Callback(
() =>
{
_uploadTask = Task.Factory.StartNew(() =>
{
_syncServiceMock.Object.Upload();
});
});
_realmiusSyncService = _syncServiceMock.Object;
_uploadDataCounter = 0;
_uploadTask = null;
}
/// <summary>
/// Uploads data to the service.
/// </summary>
/// <param name="data">Data to upload.</param>
/// <param name="sessionId">The identifier of the upload / training session.</param>
public void UploadData(string data, Guid sessionId)
{
data.CheckArgumentNull("data");
sessionId.CheckArgumentEmpty("sessionId");
var request = new UploadDataRequest {
Data = data,
SessionId = sessionId
};
Post(UploadDataMethodName, request, UploadDataTimeoutSec);
}
public UploadDataResponse UploadData(UploadDataRequest request, string connectionId)
{
if (!Connections.ContainsKey(connectionId))
{
Logger.Info($"User with ConnectionId {connectionId} not found in the connections pool (not authorized?)");
return(new UploadDataResponse());
}
var result = Processor.Upload(request, Connections[connectionId]);
return(result);
}
public async Task <UploadDataResponse> UploadData(UploadDataRequest request)
{
var httpClient = GetHttpClient();
var content = new StringContent(JsonConvert.SerializeObject(request), System.Text.Encoding.UTF8, "application/json");
var result = await httpClient.PostAsync(UploadServerUri, content);
if (!result.IsSuccessStatusCode)
{
return(new UploadDataResponse());
}
var resultString = await result.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <UploadDataResponse>(resultString));
}
public Task <UploadDataResponse> UploadData(UploadDataRequest request)
{
try
{
if (_connection?.State != ConnectionState.Connected)
{
return(Task.FromResult(new UploadDataResponse()));
}
var task = SendAndReceive <UploadDataResponse>(MethodConstants.ServerUploadData, request);
return(task);
}
catch (Exception e)
{
Logger.Exception(e);
return(Task.FromResult(new UploadDataResponse()));
}
}
public async Task <UploadDataResponse> UploadData(UploadDataRequest request)
{
try
{
if (_hubConnection?.State != ConnectionState.Connected)
{
return(new UploadDataResponse());
}
var response = await _hubProxy?.Invoke <UploadDataResponse>("UploadData", request);
return(response);
}
catch (Exception e)
{
Logger.Exception(e);
return(new UploadDataResponse());
}
}
private void SetupCorrectUploadResponse()
{
_apiClientMock.Setup(x => x.UploadData(It.IsAny <UploadDataRequest>()))
.Returns((UploadDataRequest x) =>
{
_uploadDataCounter++;
_lastUploadRequest = x;
_uploadRequests.Add(x);
Console.WriteLine("UploadData_1");
var response = new UploadDataResponse
{
Results = x.ChangeNotifications
.Select(z => new UploadDataResponseItem(z.PrimaryKey, z.Type))
.ToList(),
};
return(Task.FromResult(response));
});
}
public void SyncEnabledAfterSomeObjectsWereInsertedInRealm_Modify()
{
_realmiusSyncService.Dispose();
var obj = new DbSyncClientObject
{
Text = "123",
};
var realm = GetRealm();
realm.Write(() =>
{
realm.Add(obj);
});
var syncServiceMock = CreateSyncService();
var syncService = syncServiceMock.Object;
var realm2 = GetRealm();
var obj2 = realm2.Find <DbSyncClientObject>(obj.Id);
_lastUploadRequest = null;
realm2.Write(() =>
{
obj2.Text = "456";
realm2.Add(obj2, true);
});
syncService.Realm.Refresh();
syncService.Realmius.Refresh();
syncServiceMock.Verify(x => x.ObjectChanged(It.Is <IRealmCollection <RealmObject> >(z => z != null), It.Is <ChangeSet>(z => z != null), It.IsAny <Exception>()), Times.Once);
_uploadTask.Wait();
Wait(() => _lastUploadRequest != null);
_apiClientMock.Verify(z => z.UploadData(It.IsAny <UploadDataRequest>()), Times.Once);
string.Join(", ", _lastUploadRequest.ChangeNotifications.Select(x => x.SerializedObject))
.Should()
.MatchEquivalentOf("{\r\n \"Id\": \"" + obj.Id + "\",\r\n \"Text\": \"456\",\r\n \"Tags\": null,\r\n \"MobilePrimaryKey\": \"" + obj.Id + "\"\r\n}");
}
public void AddObject_Succeeded_Update_UploadDataIsCalled()
{
var realm = GetRealm();
var obj = new DbSyncClientObject
{
Text = "444",
};
SetupCorrectUploadResponse();
realm.Write(() =>
{
realm.Add(obj);
});
_realmiusSyncService.Realm.Refresh();
_realmiusSyncService.Realmius.Refresh();
_uploadTask.Wait();
_uploadTask.Wait();
_uploadTask = null;
_lastUploadRequest = null;
Console.WriteLine("Before update");
realm.Write(() =>
{
obj.Text = "555";
});
_realmiusSyncService.Realm.Refresh();
_realmiusSyncService.Realmius.Refresh();
Wait(() => _lastUploadRequest != null);
_lastUploadRequest.Should().NotBeNull("UploadData should be called");
string.Join(", ", _lastUploadRequest.ChangeNotifications)
.Should().MatchEquivalentOf($"Type: DbSyncClientObject, PrimaryKey: {obj.Id}, SerializedObject: {{ \"Text\": \"555\"}}");
_apiClientMock.Verify(x => x.UploadData(It.IsAny <UploadDataRequest>()), Times.AtLeast(2));
}
public void Setup()
{
_apiClientMock = new Mock <IApiClient>();
_uploadRequests = new List <UploadDataRequest>();
_lastUploadRequest = null;
_apiClientMock.Setup(x => x.UploadData(It.IsAny <UploadDataRequest>()))
.Callback <UploadDataRequest>(x =>
{
_uploadDataCounter++;
_lastUploadRequest = x;
_uploadRequests.Add(x);
}).ReturnsAsync(new UploadDataResponse());
_apiClientMock.SetupGet(x => x.IsConnected).Returns(true);
_realmFileName = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
RealmiusSyncService.RealmiusDbPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + "sync");
_syncServiceMock = CreateSyncService();
_realmiusSyncService = _syncServiceMock.Object;
_uploadDataCounter = 0;
_uploadTask = null;
RealmiusSyncService.DelayWhenUploadRequestFailed = 10;
}
public virtual async Task Upload()
{
//Logger.Log.Debug($"Attempt to Upload");
if (_uploadInProgress || _disposed)
{
return;
}
if (!_apiClient.IsConnected)
{
return;
}
if (!InTests)
{
lock (_uploadLock)
{
if (_uploadInProgress)
{
return;
}
_uploadInProgress = true;
}
}
var uploadSucceeded = false;
Dictionary <string, List <string> > changesIds;
var changes = new UploadDataRequest();
try
{
using (var realmius = CreateRealmius())
{
realmius.Refresh();
var objects = GetObjectsToUpload(realmius);
var objectsToUpload = objects.GroupBy(
x => new
{
x.Type,
x.PrimaryKey
}).ToDictionary(x => x.Key);
changesIds =
objectsToUpload.ToDictionary(
x => GetSyncStatusKey(x.Key.Type, x.Key.PrimaryKey),
x => x.Value.Select(z => z.Id).ToList());
if (objectsToUpload.Count == 0)
{
return;
}
UIUploadInProgress = true;
foreach (var uploadRequestItemRealm in objectsToUpload.Values)
{
//remove upload items that should not be synced anymore
if (!_typesToSync.ContainsKey(uploadRequestItemRealm.Key.Type))
{
realmius.Write(
() =>
{
foreach (var requestItemRealm in uploadRequestItemRealm)
{
realmius.Remove(requestItemRealm);
}
});
continue;
}
var serializedObject = MergeJsonStrings(uploadRequestItemRealm.Select(x => x.SerializedObject).ToList());
var changeNotification = new UploadRequestItem()
{
SerializedObject = serializedObject,
PrimaryKey = uploadRequestItemRealm.Key.PrimaryKey,
Type = uploadRequestItemRealm.Key.Type,
IsDeleted = uploadRequestItemRealm.Any(x => x.IsDeleted),
};
changes.ChangeNotifications.Add(changeNotification);
Logger.Debug($"Up: {changeNotification.Type}.{changeNotification.PrimaryKey}: {changeNotification.SerializedObject}");
}
}
try
{
var result = await _apiClient.UploadData(changes);
//Logger.Log.Debug($"Upload finished " + JsonConvert.SerializeObject(result));
using (var realmius = CreateRealmius())
{
realmius.Refresh();
var notSynced = changes.ChangeNotifications
.Select(x => new { x.Type, x.PrimaryKey })
.Except(result.Results.Where(x => x.IsSuccess)
.Select(x => new { x.Type, PrimaryKey = x.MobilePrimaryKey }))
.ToList();
if (notSynced.Count > 0)
{
var notSyncedObjects = notSynced.Select(x => $"{x.Type}: {x.PrimaryKey}");
Logger.Info($"Some objects were not accepted by the server: {string.Join("; ", notSyncedObjects)}");
}
using (var realm = _realmFactoryMethod())
{
foreach (var realmiusObject in result.Results)
{
if (realmiusObject.IsSuccess)
{
var syncStateObject = FindSyncStatus(
realmius,
realmiusObject.Type,
realmiusObject.MobilePrimaryKey);
realmius.Write(
() =>
{
try
{
foreach (var key in changesIds[GetSyncStatusKey(realmiusObject.Type, realmiusObject.MobilePrimaryKey)])
{
try
{
var uploadRequestItemRealm = realmius.Find <UploadRequestItemRealm>(key);
Logger.Debug(
$"Removed UploadRequest {uploadRequestItemRealm?.Id} for {realmiusObject.Type}:{realmiusObject.MobilePrimaryKey}");
if (uploadRequestItemRealm != null)
{
realmius.Remove(uploadRequestItemRealm);
}
}
catch (Exception e)
{
//System.Console.WriteLine(e);
throw;
}
}
syncStateObject.SetSyncState(SyncState.Synced);
}
catch (Exception e)
{
//System.Console.WriteLine(e);
throw;
}
});
if (_typesToSync[realmiusObject.Type].ImplementsSyncState)
{
var obj =
(IRealmiusObjectWithSyncStatusClient)
realm.Find(realmiusObject.Type, realmiusObject.MobilePrimaryKey);
realm.Write(
() =>
{
obj.SyncStatus = (int)SyncState.Synced;
});
}
}
else
{
realmius.Write(
() =>
{
foreach (var key in changesIds[GetSyncStatusKey(realmiusObject.Type, realmiusObject.MobilePrimaryKey)])
{
var uploadRequestItemRealm =
realmius.Find <UploadRequestItemRealm>(key);
uploadRequestItemRealm.UploadAttempts++;
if (uploadRequestItemRealm.UploadAttempts > 30)
{
Logger.Debug($"UploadRequest {realmiusObject.Type}.{realmiusObject.MobilePrimaryKey}, failed for attempts {uploadRequestItemRealm.UploadAttempts}, removing");
realmius.Remove(uploadRequestItemRealm);
}
else
{
if (uploadRequestItemRealm.UploadAttempts >= 3)
{
uploadRequestItemRealm.NextUploadAttemptDate = DateTimeOffset.Now.AddSeconds(10 * uploadRequestItemRealm.UploadAttempts);
}
Logger.Debug($"Delaying UploadRequest {realmiusObject.Type}.{realmiusObject.MobilePrimaryKey}, attempt {uploadRequestItemRealm.UploadAttempts}, scheduled for {uploadRequestItemRealm.NextUploadAttemptDate}");
}
}
});
}
}
}
}
uploadSucceeded = result.Results.Any();
}
catch (Exception ex)
{
Debug.WriteLine($"{ex}");
}
}
catch (Exception ex)
{
Debug.WriteLine($"{ex}");
}
finally
{
_uploadInProgress = false;
}
#pragma warning disable 4014
Task.Factory.StartNew(async() =>
#pragma warning restore 4014
{
try
{
if (!InTests)
{
if (!uploadSucceeded)
{
await Task.Delay(DelayWhenUploadRequestFailed);
}
//ToDo: delays might be increased in case of consequent errors
Logger.Debug($"Upload requeued");
await Upload();
}
}
catch (Exception e)
{
Logger.Exception(e, $"Error in Upload");
}
});
}
