public StorageResult <TValue> UpdateDocument <TKey, TValue>(ITransaction transaction, string collection, TKey key, TValue update)
{
StorageResult <TValue> result = new StorageResult <TValue>();
if (string.IsNullOrEmpty(collection))
{
throw new ArgumentException("Collection name can not be null or empty.");
}
if (!CollectionExists(collection))
{
throw new ArgumentException("Specified collection not found in " + GetFileInfo() + " Collection = " + collection);
}
if (update == null)
{
throw new ArgumentException("Value can not be null.");
}
if (IsDatabaseFull())
{
result.Status = StoreResult.FailureDatabaseFull;
return(result);
}
return(UpdateDocumentInternal(transaction, collection, key, update));
}
private StorageResult <TValue> UpdateDocumentInternal <TKey, TValue>(ITransaction transaction, string collection, TKey key, TValue update)
{
StorageResult <TValue> result = new StorageResult <TValue>();
ValidateTransaction(transaction);
LightningTransaction lmdbTransaction = (LightningTransaction)transaction.InnerObject;
byte[] keyBytes = _environment.ConverterStore.GetToBytes <TKey>().Convert(_collectionTable[collection].Collection, key);
byte[] oldValBytes = lmdbTransaction.Get(_collectionTable[collection].Collection, keyBytes);
long netSize = 0;
netSize = -CaclulateSize(keyBytes, oldValBytes);
byte[] valueBytes = _environment.ConverterStore.GetToBytes <TValue>().Convert(_collectionTable[collection].Collection, update);
try
{
lmdbTransaction.Put(_collectionTable[collection].Collection, keyBytes, valueBytes);
//Incase of update previous size is not being subtracted at the moment
long size = CaclulateSize(keyBytes, valueBytes);
netSize += size;
((LMDBTransaction)transaction).ChangeSize(netSize);
_collectionTable[collection].IncrementTemporaryStats(netSize);
result.Document = update;
result.Status = StoreResult.SuccessOverwrite;
return(result);
}
catch (LightningException le)
{
result.Status = HandleException(le);
return(result);
}
}
private void InitializePerviouslyStoredCollections()
{
//needed to ensure that internalMetadataCollection exists so that argument exception is not thrown by LMDB.
_collectionTable[METADATA_COLLECTION] = new LMDBCollection(CreateCollectionInternal(METADATA_COLLECTION, typeof(string)));
//ITransaction transaction = BeginTransaction(null, true);
StorageResult <byte[]> result = GetDocument <string, byte[]>(METADATA_COLLECTION, "collections");
if (result.Document != null)
{
Dictionary <string, LMDBCollection> collectionList;
using (ClusteredMemoryStream ms = new ClusteredMemoryStream(result.Document))
{
using (CompactReader reader = new CompactBinaryReader(ms))
{
collectionList = SerializationUtility.DeserializeDictionary <string, LMDBCollection>(reader);
}
}
foreach (var col in collectionList)
{
CreateCollection(col.Key, null, null);
if (LoggerManager.Instance.StorageLogger != null && LoggerManager.Instance.StorageLogger.IsInfoEnabled)
{
LoggerManager.Instance.StorageLogger.Info("LMDB.Initialize", "Previously stored collection :" + col.Key + " initialized successfully. ");
}
_collectionTable[col.Key].Stats.DataSize = col.Value.Stats.DataSize;
_collectionTable[col.Key].Stats.DocumentCount = col.Value.Stats.DocumentCount;
}
}
}
private StorageResult <TValue> StoreDocumentInternal <TKey, TValue>(ITransaction transaction, string collection, TKey key, TValue value)
{
StorageResult <TValue> result = new StorageResult <TValue>();
ValidateTransaction(transaction);
LightningTransaction lmdbTransaction = (LightningTransaction)transaction.InnerObject;
byte[] keyBytes = _environment.ConverterStore.GetToBytes <TKey>().Convert(_collectionTable[collection].Collection, key);
byte[] valueBytes = _environment.ConverterStore.GetToBytes <TValue>().Convert(_collectionTable[collection].Collection, value);
try
{
lmdbTransaction.Put(_collectionTable[collection].Collection, keyBytes, valueBytes);
long size = CaclulateSize(keyBytes, valueBytes);
((LMDBTransaction)transaction).ChangeSize(size);
_collectionTable[collection].IncrementTemporaryStats(size);
result.Document = value;
result.Status = StoreResult.Success;
return(result);
}
catch (LightningException le)
{
result.Status = HandleException(le);
return(result);
}
}
/// <summary>
/// SetItem T By Key
/// </summary>
/// <typeparam name="T">Type Of Cached Value</typeparam>
/// <param name="key">Key Lookup</param>
/// <param name="litter">Item T To Be Cached</param>
/// <returns>Success True|False (For Each Cache)</returns>
public async Task <StorageResult[]> SetItem <T>(string key, LitterBoxItem <T> litter)
{
if (string.IsNullOrWhiteSpace(key))
{
this.RaiseException(new ArgumentException($"{nameof(this.SetItem)}=>{nameof(key)} Cannot Be NullOrWhiteSpace"));
return(null);
}
if (litter == null)
{
this.RaiseException(new ArgumentException($"{nameof(this.SetItem)}=>{nameof(litter)} Cannot Be Null"));
return(null);
}
var results = new StorageResult[this._caches.Length];
for (var i = 0; i < this._caches.Length; i++)
{
var cache = this._caches[i];
var success = await cache.SetItem(key, litter).ConfigureAwait(false);
results[i] = new StorageResult {
CacheType = cache.GetType(),
IsSuccessful = success
};
}
return(results);
}
public override StoreResult StoreKeyMetadata(ITransaction metadataTransaction, JSONDocument document, long rowId)
{
StorageResult <byte[]> result = _metadataPersister.StoreDocument(metadataTransaction,
GetKeyMetadataCollection(), document.Key, GetSerializedMetadata(document.Key, rowId));
if (result.Status == StoreResult.Success || result.Status == StoreResult.SuccessOverwrite)
{
//if (_statsCollector != null && result.Status == StoreResult.Success)
//{
// _statsCollector.IncrementStatsValue(StatisticsType.DocumentCount);
//}
//SetAverageDocumentSize();
//return StoreResult.Success;
}
else
{
return(result.Status);
}
StorageResult <string> resultR2K = _metadataPersister.StoreDocument(metadataTransaction,
GetRowMetadataCollection(), rowId, document.Key.ToString());
if (resultR2K.Status == StoreResult.Success || resultR2K.Status == StoreResult.SuccessOverwrite)
{
lock (_transactionRowIds)
{
_transactionRowIds.Add(rowId);
}
return(StoreResult.Success);
}
return(resultR2K.Status);
}
public virtual StoreResult RemovekeyMetadata(ITransaction metadataTransaction, JSONDocument document, long rowId, IOperationContext context)
{
StorageResult <byte[]> result = _metadataPersister.DeleteDocument <long, byte[]>(metadataTransaction, GetKeyMetadataCollection(), rowId);
if (result.Status == StoreResult.Success || result.Status == StoreResult.SuccessDelete || result.Status == StoreResult.SuccessKeyDoesNotExist)
{
lock (_rowToFileIndex)
{
_rowToFileIndex.Remove(rowId);
}
if (result.Status != StoreResult.SuccessKeyDoesNotExist)
{
//if (_statsCollector != null)
//{
// _statsCollector.DecrementStatsValue(StatisticsType.DocumentCount);
// SetAverageDocumentSize();
//}
}
lock (_keyToRowIndex)
{
_enumerationSet.Remove(rowId);
}
return(StoreResult.Success);
}
return(result.Status);
}
/// <summary>
/// Calls record create handler and updates status if success.
/// </summary>
/// <param name="handler">BroadcastLoggerHandler instance.</param>
/// <param name="cur">Current item in queue.</param>
private void recordCreateHelper(BroadcastLoggerHandler handler, StorageResult cur)
{
bool realtime = false;
Console.WriteLine("\n\n\n\n");
Console.WriteLine("DateTime.UtcNow: " + DateTime.UtcNow);
Console.WriteLine("cur.CreationDate.toUniversalTime(): " + cur.CreationDate.ToUniversalTime());
Console.WriteLine("\n\n\n\n");
// Set realtime if this item's Creation Date is less than two seconds from the current time.
if ((int)(cur.CreationDate.Subtract(DateTime.UtcNow)).TotalMilliseconds < 2000)
{
realtime = true;
}
bool succeeded = false;
succeeded = handler.recordingCreate(cur.StationID, authCode, cur.CreationDate.ToUniversalTime(), realtime);
if (succeeded)
{
cur.RecordID = handler.RecordingId.ToString();
storage.UpdateRecordID(Int32.Parse(cur.UploadID), cur.RecordID);
cur.Status = Status.ID_CREATED;
storage.UpdateStatus(Int32.Parse(cur.UploadID), Status.ID_CREATED);
}
else
{
Console.WriteLine(handler.ErrorMessage);
}
}
public void Commit(ITransaction transaction)
{
try
{
if (!transaction.IsReadOnly)
{
foreach (LMDBCollection collection in _collectionTable.Values)
{
collection.UpdateTemporaryStats();
}
StorageResult <long> result = UpdateDocumentInternal(transaction, METADATA_COLLECTION, "fileSize", _providerFileSize + ((LMDBTransaction)transaction).Size);
if (result.Status != StoreResult.Success && result.Status != StoreResult.SuccessDelete && result.Status != StoreResult.SuccessKeyDoesNotExist && result.Status != StoreResult.SuccessOverwrite)
{
throw new Exception("Error commiting transaction." + GetFileInfo());
}
StoreCollectionInfo(null, transaction); //if something happens above check might be needed here too.
}
CommitInternal(transaction);
RemoveTransactionFromLists(transaction);
}
catch (TransactionComittedException)
{
RemoveTransactionFromLists(transaction);
//if transaction was already comitted and again comit call was sent then no need to throw exception.
if (LoggerManager.Instance.StorageLogger != null && LoggerManager.Instance.StorageLogger.IsWarnEnabled)
{
LoggerManager.Instance.StorageLogger.Warn("LMDB.Commit", " Transaction committed exception. " + GetFileInfo());
}
}
}
private void GetPreviouslyStoredFileSize()
{
//needed to ensure that internalMetadataCollection exists so that argument exception is not thrown by LMDB.
CreateCollection(METADATA_COLLECTION, typeof(string), typeof(byte[]));
StorageResult <long> fileSize = GetDocument <string, long>(METADATA_COLLECTION, "fileSize");
ChangeDataSize(fileSize.Document == 0 ? _environment.UsedSize : fileSize.Document);
}
public async Task <CommandResult> Handle(UpdateMeasureCommand request, CancellationToken cancellationToken)
{
CommandResult commandInvariantResult = await ValidateCommandInvariants(request);
if (!commandInvariantResult.Success)
{
return(FailureDueTo(commandInvariantResult.Notifications.ToList()));
}
Measure measure = await _measureRepository.GetByIdAsync(request.MeasureId);
if (!FoundValidMeasure(measure))
{
return(FailureDueToMeasureNotFound());
}
List <Image> bodyPictures = new List <Image>();
foreach (IFormFile bodyPicture in request.BodyPictures)
{
string containerName = _containerOptions.Value.MeasureImageContainerName;
StorageFile existingBodyPicture = await _storageService.FindFileAsync(containerName, bodyPicture.FileName);
if (existingBodyPicture == null)
{
StorageResult storageResult = await UploadBodyPictureToStorage(bodyPicture);
if (!storageResult.Success)
{
return(FailureDueToUploadFailure());
}
bodyPictures.Add(new Image(storageResult.FileName, storageResult.FileUrl));
}
else
{
bodyPictures.Add(new Image(existingBodyPicture.UrlPath, existingBodyPicture.Name));
}
}
BasicMeasure basicMeasure = new BasicMeasure(request.Height, request.Weight);
measure.Update(
request.Title,
request.Details,
basicMeasure,
request.MeasureDate,
bodyPictures,
_mapper.Map <List <MeasureLine> >(request.MeasureLines)
);
await _measureRepository.UpdateAsync(measure);
return(await CommitAndPublishDefaultAsync());
}
/// <summary>
/// Calls setAsUploaded handler and updates status if success.
/// </summary>
/// <param name="handler">BroadcastLoggerHandler instance.</param>
/// <param name="cur">Current item in queue.</param>
private void recordUploadedHelper(BroadcastLoggerHandler handler, StorageResult cur)
{
bool succeeded = handler.setAsUploaded(cur.StationID, authCode, Int32.Parse(cur.RecordID));
if (succeeded)
{
cur.Status = Status.SET_UPLOADED;
storage.UpdateStatus(Int32.Parse(cur.UploadID), Status.SET_UPLOADED);
}
}
private async void StoreTempIteration()
{
var directory = Directory.CreateDirectory(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Iterations", "Common"));
LocalStorageProvider provider = new LocalStorageProvider();
string json = JsonConvert.SerializeObject(Provider.Iteration);
StorageResult result = await provider.StoreTempIteration(json, directory.FullName);
}
/// <summary>
/// Calls amazon upload handler and updates status if success.
/// </summary>
/// <param name="handler">AmazonHandler instance.</param>
/// <param name="cur">Current item in queue.</param>
private void amazonHelper(AmazonHandler amazonHandler, StorageResult cur)
{
bool succeeded = amazonHandler.putObject(cur.LocalFileName, cur.AWSFileName, this.bucketName);
if (succeeded)
{
cur.Status = Status.UPLOADED;
storage.UpdateStatus(Int32.Parse(cur.UploadID), Status.UPLOADED);
}
}
private void GetR2KFromStore(long rowId, out DocumentKey key)
{
StorageResult <string> result = _metadataPersister.GetDocument <long, string>(GetRowMetadataCollection(), rowId);
if (result.Document != null)
{
key = new DocumentKey(result.Document);
return;
}
key = null;
}
public StorageResult <TValue> GetDocument <TKey, TValue>(string collection, TKey key)
{
StorageResult <TValue> result = new StorageResult <TValue>();
if (string.IsNullOrEmpty(collection))
{
throw new ArgumentException("Collection name can not be null or empty.");
}
if (!CollectionExists(collection))
{
throw new ArgumentException("Specified collection not found in " + GetFileInfo() + " Collection = " + collection);
}
ReadTransaction transaction = null;
try
{
if (_readerTransaction != null)
{
if (_readerTransaction.ShouldRenew)
{
_readerTransaction.WaitUntillFree();
}
}
lock (_readerTransactionLock)
{
if (_readerTransaction == null || !_readerTransaction.Running)
{
_readerTransaction = new ReadTransaction(BeginTransaction(null, true));
}
transaction = _readerTransaction;
transaction.Enter();
}
ValidateTransaction(transaction.Transaction);
LightningTransaction lmdbTransaction = (LightningTransaction)transaction.Transaction.InnerObject;
byte[] keyBytes = _environment.ConverterStore.GetToBytes <TKey>().Convert(_collectionTable[collection].Collection, key);
byte[] valueBytes = lmdbTransaction.Get(_collectionTable[collection].Collection, keyBytes);
result.Document = _environment.ConverterStore.GetFromBytes <TValue>().Convert(_collectionTable[collection].Collection, valueBytes);
}
finally
{
if (transaction != null)
{
transaction.Exit();
}
}
result.Status = StoreResult.Success;
return(result);
}
public async void LoadIterations(string directory)
{
LocalStorageProvider provider = new LocalStorageProvider();
StorageResult result = await provider.LoadStoredIterationsAsync(directory);
if ((result.Status == StorageStatus.Success || result.Status == StorageStatus.Warning) && result.Result != null)
{
BrowsedIterations = new ObservableCollection <BrowsedIteration>((List <BrowsedIteration>)result.Result);
}
}
public void StoreLastRowId(ITransaction transaction)
{
if (!transaction.IsReadOnly)
{
StorageResult <long> result = _metadataPersister.UpdateDocument(transaction.InnerObject as ITransaction, GetLasRowIdCollection(), "LastRowId", _lastRowId);
if (result.Status != StoreResult.SuccessOverwrite && result.Status != StoreResult.Success)
{
throw new Exception("Error storing lastRowId. Status = " + result.Status);
}
}
}
private async Task <StorageResult> UploadBodyPictureToStorage(IFormFile bodyPicture)
{
using (MemoryStream stream = new MemoryStream())
{
string containerName = _containerOptions.Value.PostImageContainerName;
await bodyPicture.CopyToAsync(stream);
StorageResult result = await _storageService.UploadFileToStorageAsync(containerName, stream, Guid.NewGuid().ToString());
return(result);
}
}
/// <summary>
/// Calls authStation handler and updates status if success.
/// </summary>
/// <param name="handler">BroadcastLoggerHandler instance.</param>
/// <param name="cur">Current item in queue.</param>
private void authHelper(BroadcastLoggerHandler handler, StorageResult cur)
{
// boolean var is used to help with code clarity.
// handler has a Status property, but we used this var to avoid
// the possibility of overwriting the property.
bool succeeded = handler.authStation(cur.StationID, authCode);
if (succeeded)
{
cur.Status = Status.AUTHORIZED;
storage.UpdateStatus(Int32.Parse(cur.UploadID), Status.AUTHORIZED);
}
}
private void GetK2RFromStore(DocumentKey key, out long rowId, out long fileId, out long size)
{
StorageResult <byte[]> result = _metadataPersister.GetDocument <string, byte[]>(GetKeyMetadataCollection(), key.ToString());
if (result.Document != null)
{
DeserializeMetadata(result.Document, out rowId, out fileId, out size);
return;
}
rowId = -1;
fileId = -1;
size = -1;
}
public void GetInvalidEntry()
{
Storage storage = new Storage();
ResetStorage(storage);
try
{
StorageResult sr = storage[0];
Assert.Fail("Exception should of been thrown");
}
catch (InvalidOperationException)
{
//Expected exception
}
}
public async void LoadIterations(string directory)
{
LocalStorageProvider provider = new LocalStorageProvider();
StorageResult result = await provider.LoadStoredIterationsAsync(directory, CheckSubFolder);
if (result.Status == StorageStatus.Success || result.Status == StorageStatus.Warning)
{
BrowsedIterations = new ObservableCollection <BrowsedIteration>((List <BrowsedIteration>)result.Result);
// Generate statistics
GenerateBasicStatistics();
}
}
public StorageResult <TValue> DeleteDocument <TKey, TValue>(ITransaction transaction, string collection, TKey key)
{
StorageResult <TValue> result = new StorageResult <TValue>();
if (string.IsNullOrEmpty(collection))
{
throw new ArgumentException("Collection name can not be null or empty.");
}
if (!CollectionExists(collection))
{
throw new ArgumentException("Specified collection not found in " + GetFileInfo() + " Collection = " + collection);
}
ValidateTransaction(transaction);
LightningTransaction lmdbTransaction = (LightningTransaction)transaction.InnerObject;
byte[] keyBytes = _environment.ConverterStore.GetToBytes <TKey>().Convert(_collectionTable[collection].Collection, key);
byte[] valueBytes = lmdbTransaction.Get(_collectionTable[collection].Collection, keyBytes);
long size = CaclulateSize(keyBytes, valueBytes);
result.Document = _environment.ConverterStore.GetFromBytes <TValue>().Convert(_collectionTable[collection].Collection, valueBytes);
try
{
lmdbTransaction.Delete(_collectionTable[collection].Collection, keyBytes);
((LMDBTransaction)transaction).ChangeSize(-size);
_collectionTable[collection].DecrementTemporaryStats(size);
result.Status = StoreResult.Success;
return(result);
}
catch (LightningException le)
{
//todo temp fix consider success if doc not found
if (le.StatusCode == LMDBErrorCodes.MDB_NOTFOUND)
{
if (LoggerManager.Instance.StorageLogger != null && LoggerManager.Instance.StorageLogger.IsWarnEnabled)
{
LoggerManager.Instance.StorageLogger.Warn("LMDB.DeleteDocument", "Error Deleting Document." + GetFileInfo() + le);
}
result.Status = StoreResult.Success;
return(result);
}
result.Status = HandleException(le);
return(result);
}
}
public void IndexerTest()
{
Storage storage = new Storage();
ResetStorage(storage);
storage.AddStation("stationID", "authCode");
int uploadID = storage.AddToQueue("stationID", "LocalFileName", "recordID");
storage.UpdateAWSFileName(uploadID, "AWSFileName");
storage.UpdateStatus(uploadID, Status.AUTHORIZED);
storage.SetStationName("stationID", "stationName");
Console.WriteLine("Upload ID" + uploadID);
StorageResult result = storage[uploadID];
if (result.AuthCode != "authCode")
{
Assert.Fail("Failed to get correct auth code");
}
if (result.AWSFileName != "AWSFileName")
{
Assert.Fail("Failed to get correct aws file name");
}
if (result.LocalFileName != "LocalFileName")
{
Assert.Fail("Failed to get correct local file name");
}
if (result.RecordID != "recordID")
{
Assert.Fail("Failed to get correct recordID");
}
if (result.StationID != "stationID")
{
Assert.Fail("Failed to get correct stationID");
}
if (result.StationName != "stationName")
{
Assert.Fail("Failed to get correct station name");
}
if (result.Status != Status.AUTHORIZED)
{
Assert.Fail("Failed to get correct status number");
}
if (int.Parse(result.UploadID) != uploadID)
{
Assert.Fail("Failed to get the correct uploadID");
}
}
public async Task <ActionResult> PostMovie([FromForm] MovieModel movie)
{
// Only Admin users are allowed to perform this action
if (!IsUserAdminAutenticated())
{
return(Unauthorized(new { message = "Not allowed" }));
}
// Validating parameters
if (movie == null)
{
return(BadRequest());
}
// Uploading Image to Storage first
StorageAccountService storageService = new StorageAccountService(Configuration);
StorageResult storageResult = await storageService.UploadImageToStorage(movie.Image, movie.Title);
if (storageResult.Success)
{
// Save movie in Database
Movie movieDb = new Movie()
{
Title = movie.Title,
Description = movie.Description,
Stock = 0,
SalePrice = movie.SalePrice,
RentalPrice = movie.RentalPrice,
LikesCounter = 0,
Image = storageResult.Uri,
IsAvailable = true
};
BLResult <Movie> blResult = movieTransactionScript.AddMovie(movieDb);
if (blResult.Success)
{
return(CreatedAtAction("GetMovie", new { id = blResult.Item.IdMovie }, blResult.Item));
}
else
{
return(StatusCode(500, blResult));
}
}
else
{
return(StatusCode(500, storageResult));
}
}
public virtual StoreResult StoreKeyMetadata(ITransaction metadataTransaction, JSONDocument document, long rowId)
{
StorageResult <byte[]> result = _metadataPersister.StoreDocument(metadataTransaction,
GetKeyMetadataCollection(), rowId, GetSerializedMetadata(document.Key, rowId));
if (result.Status == StoreResult.Success || result.Status == StoreResult.SuccessOverwrite)
{
//if (_statsCollector != null && result.Status == StoreResult.Success)
//{
// _statsCollector.IncrementStatsValue(StatisticsType.DocumentCount);
// SetAverageDocumentSize();
//}
return(StoreResult.Success);
}
return(result.Status);
}
/// <summary>
/// Get an object with the given index.
/// </summary>
/// <param name="i"></param>
/// <returns></returns>
public StorageResult GetFromIndex(int i)
{
using (SQLiteCommand command = new SQLiteCommand(connection))
{
command.CommandText =
"SELECT " +
"datetime(CreationTime, 'localtime'), " +
"StationID," +
"StationName," +
"AuthCode," +
"LocalFileName," +
"AWSFileName," +
"RecordID," +
"Status," +
"UploadID " +
"FROM Stations " +
"NATURAL JOIN UploadQueue " +
"WHERE UploadID = '" + i + "'";
using (SQLiteDataReader reader = command.ExecuteReader())
{
reader.Read();
StorageResult output = null;
try
{
output = new StorageResult(reader["StationID"].ToString()
, reader["StationName"].ToString()
, reader["AuthCode"].ToString()
, reader["LocalFileName"].ToString()
, reader["AWSFileName"].ToString()
, reader["RecordID"].ToString()
, reader.GetDateTime(0)
, int.Parse(reader["Status"].ToString())
, reader["UploadID"].ToString());
reader.Dispose();
}
catch (InvalidOperationException ex)
{
throw (new InvalidOperationException("Could not get the row that was requested. Possibly out of range"));
}
return(output);
}
}
}
protected StorageResult GetStorages(string keyword = null)
{
var masterStorageUri = MasterDataSettings.Endpoint + $"master/storages?size={int.MaxValue}&keyword={keyword}";
//var masterUnitUri = $"https://com-danliris-service-core-dev.azurewebsites.net/v1/master/products/simple";
var storageResponse = _http.GetAsync(masterStorageUri).Result;
var storageResult = new StorageResult();
if (storageResponse.IsSuccessStatusCode)
{
storageResult = JsonConvert.DeserializeObject <StorageResult>(storageResponse.Content.ReadAsStringAsync().Result);
}
else
{
GetStorages(keyword);
}
return(storageResult);
}
/// <summary>
/// Calls record done handler and updates status if success.
/// </summary>
/// <param name="handler">BroadcastLoggerHandler instance.</param>
/// <param name="cur">Current item in queue.</param>
/// <param name="next">Next item in queue.</param>
private void recordDoneHelper(BroadcastLoggerHandler handler, StorageResult cur, StorageResult next)
{
// First check to see if cur has finished recording; otherwise, it will still be in use
// and any attempt to upload it will throw an IOException.
if (isFileAvailable(cur.LocalFileName))
{
// Get the AWS object name (URL to upload to Amazon S3).
bool succeeded = handler.recordingDone(cur.StationID, authCode,
Int32.Parse(cur.RecordID), Int32.Parse(next.RecordID));
if (succeeded)
{
cur.AWSFileName = handler.ObjectName;
storage.UpdateAWSFileName(Int32.Parse(cur.UploadID), cur.AWSFileName);
cur.Status = Status.REC_SET_DONE;
storage.UpdateStatus(Int32.Parse(cur.UploadID), Status.REC_SET_DONE);
}
}
}
