/// <summary>
/// Add ImportQueueRecordFiles to database
/// </summary>
/// <param name="instances">ImportQueueRecordFile instance array</param>
/// <param name="importQueueRecord">ImportQueueRecord instance for instances</param>
/// <param name="saveAfterInsert">Save database after insertion</param>
/// <param name="waitUntilSaving">Wait until saving</param>
public void ImportQueueRecordFileInfoAdd(IEnumerable<ImportQueueRecordFileInfo> instances, ImportQueueRecord importQueueRecord, bool saveAfterInsert = true, bool waitUntilSaving = true)
{
try
{
if (instances == null)
throw new ArgumentNullException("instances");
if (importQueueRecord == null)
throw new ArgumentNullException("importQueueRecord");
instances = instances.Where(i => i != null).ToArray();
try
{
foreach (var i in instances)
i.ImportQueueRecord = importQueueRecord;
this.Context.ImportQueueRecordFileInfoes.AddRange(instances);
if (saveAfterInsert)
this.SaveChanges(waitUntilSaving);
}
catch (Exception ex)
{
var e = new Exception(ex.Message, ex);
for (int i = 0; i < instances.Count();i++)
e.Data.Add(string.Format("instance_{0}", i), instances.ElementAt(i).ToString());
throw e;
}
}
catch (Exception ex)
{
Helpers.Log.Add(ex, string.Format("Repository.ImportQueueRecordFileInfoAdd(instances=[{0}],saveAfterInsert={1},waitUntilSaving={2})", instances == null ? "NULL" : instances.Count().ToString(), saveAfterInsert, waitUntilSaving));
throw;
}
}
private void OnImportQueueRecordUpdated(ImportQueueRecord newValue, ImportQueueRecord oldValue)
{
if (oldValue != null)
oldValue.PropertyChanged -= ImportQueueRecord_PropertyChanged;
if (newValue != null)
newValue.PropertyChanged += ImportQueueRecord_PropertyChanged;
RaiseCommands();
}
//private Task<bool> SaveTask(ImportQueueRecord item)
//{
// var startTask = Task.Factory.StartNew(() =>
// {
// IsBusy = true;
// }, GetCancellationToken(), TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext());
// var clientTask = startTask.ContinueWith((t) =>
// {
// var client = new RoyaltyServiceWorker.AccountService.AccountServiceClient();
// try
// {
// return item.Id == default(Guid)
// ? client.PutImportQueueRecord(item)
// : client.UpdateImportQueueRecord(item);
// }
// finally
// {
// try { client.Close(); } catch { }
// }
// }, GetCancellationToken(), TaskContinuationOptions.AttachedToParent, TaskScheduler.Default);
// var taskRes = clientTask.ContinueWith((res) =>
// {
// try
// {
// if (res.Result.Error != null)
// throw new Exception(res.Result.Error);
// item.CopyObjectFrom(res.Result.Value);
// return true;
// }
// catch(Exception ex)
// {
// Error = ex.ToString();
// return false;
// }
// finally
// {
// IsBusy = false;
// }
// }, GetCancellationToken(), TaskContinuationOptions.AttachedToParent, TaskScheduler.FromCurrentSynchronizationContext());
// return taskRes;
//}
private Task<ImportQueueRecord[]> DeleteTask(ImportQueueRecord[] items)
{
var startTask = Task.Factory.StartNew(() =>
{
IsBusy = true;
}, GetCancellationToken(), TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext());
var clientTask = startTask.ContinueWith((t) =>
{
var client = new RoyaltyServiceWorker.AccountService.AccountServiceClient();
try
{
return client.RemoveImportQueueRecordRange(items.Select(i => i.Id).ToList());
}
finally
{
try { client.Close(); } catch { }
}
}, GetCancellationToken(), TaskContinuationOptions.AttachedToParent, TaskScheduler.Default);
var taskRes = clientTask.ContinueWith((res) =>
{
try
{
if (res.Result.Error != null)
throw new Exception(res.Result.Error);
return items
.Where(i => !res.Result.Values.Contains(i.Id))
.ToArray();
}
catch (Exception ex)
{
Error = ex.ToString();
return items;
}
finally
{
IsBusy = false;
}
}, GetCancellationToken(), TaskContinuationOptions.AttachedToParent, TaskScheduler.FromCurrentSynchronizationContext());
return taskRes;
}
private void DeleteFromCollection(ImportQueueRecord item)
{
if (item == null)
return;
var task = DeleteTask(new[] { item });
task.ContinueWith((t) => {
if (t.Exception != null)
return;
if (t.Result.Length > 0)
return;
localCollection.Remove(item);
}, GetCancellationToken(), TaskContinuationOptions.AttachedToParent, TaskScheduler.FromCurrentSynchronizationContext());
}
private void InsertNew(string[] filePath, bool forAnalize, Encoding encoding)
{
IsBusy = true;
var accountId = Account.Id;
var cancellationToken = GetCancellationToken();
var fullLoadTask = Task.Factory.StartNew(() => {
var storageClient = new RoyaltyServiceWorker.StorageService.FileServiceClient();
var accountClient = new RoyaltyServiceWorker.AccountService.AccountServiceClient();
var loadFileTasks = storageClient.UploadFiles(filePath, encoding, cancellationToken);
//wait upload all files
Task.WaitAll(loadFileTasks);
var loadFileResult = loadFileTasks.Select(t => t.Result).ToArray();
var newRecord = new ImportQueueRecord() {
AccountUID = accountId,
FileInfoes = loadFileResult.Select(f =>
new ImportQueueRecordFileInfo()
{
ForAnalize = forAnalize,
SourceFilePath = f.FileName,
Files = (new[] { new ImportQueueRecordFileInfoFile() { FileUID = f.Id } }).ToList()
}
).ToList()
};
var res = accountClient.PutImportQueueRecord(newRecord);
if (res.Error != null)
throw new Exception(res.Error);
newRecord.CopyObjectFrom(res.Value);
return newRecord;
}, GetCancellationToken(), TaskCreationOptions.None, TaskScheduler.Default)
.ContinueWith(r => {
IsBusy = false;
if (r.Exception != null)
Error = r.Exception.ToString();
localCollection.UpdateCollectionAddOrUpdate(new[] { r.Result });
}, System.Threading.CancellationToken.None, TaskContinuationOptions.AttachedToParent, TaskScheduler.FromCurrentSynchronizationContext());
}
/// <summary>
/// Remove ImportQueueRecord from database
/// </summary>
/// <param name="instance">ImportQueueRecord instance</param>
/// <param name="saveAfterRemove">Save database after removing</param>
/// <param name="waitUntilSaving">Wait until saving</param>
public void ImportQueueRecordRemove(ImportQueueRecord instance, bool saveAfterRemove = true, bool waitUntilSaving = true)
{
ImportQueueRecordRemove(new ImportQueueRecord[] { instance }, saveAfterRemove, waitUntilSaving);
}
/// <summary>
/// Add ImportQueueRecord to database
/// </summary>
/// <param name="instance">ImportQueueRecord instance</param>
/// <param name="saveAfterInsert">Save database after insertion</param>
/// <param name="waitUntilSaving">Wait until saving</param>
public void ImportQueueRecordAdd(ImportQueueRecord instance, bool saveAfterInsert = true, bool waitUntilSaving = true)
{
ImportQueueRecordAdd(new ImportQueueRecord[] { instance }, saveAfterInsert, waitUntilSaving);
}
/// <summary>
/// Create/Get new ImportQueueRecord without any link to database
/// </summary>
/// <param name="ImportQueueRecordNumber">ImportQueueRecord number</param>
/// <returns>ImportQueueRecord instance</returns>
public ImportQueueRecord ImportQueueRecordNew(Account account = null)
{
try
{
var res = new ImportQueueRecord()
{
ImportQueueRecordUID = Guid.NewGuid(),
Account = account,
CreatedDate = DateTime.UtcNow,
};
if (account != null)
account.ImportQueue.Add(res);
return res;
}
catch (Exception ex)
{
Helpers.Log.Add(ex, string.Format("Repository.ImportQueueRecordNew(account='{0}')", account == null ? "NULL" : account.ToString()));
throw;
}
}
/// <summary>
/// Add ImportQueueRecordFile to database
/// </summary>
/// <param name="instance">ImportQueueRecordFile instance</param>
/// <param name="importQueueRecord">ImportQueueRecord instance for instance</param>
/// <param name="saveAfterInsert">Save database after insertion</param>
/// <param name="waitUntilSaving">Wait until saving</param>
public void ImportQueueRecordFileInfoAdd(ImportQueueRecordFileInfo instance, ImportQueueRecord importQueueRecord, bool saveAfterInsert = true, bool waitUntilSaving = true)
{
ImportQueueRecordFileInfoAdd(new ImportQueueRecordFileInfo[] { instance }, importQueueRecord, saveAfterInsert, waitUntilSaving);
}
/// <summary>
/// Create/Get new ImportQueueRecordFile instance without any link to database
/// </summary>
/// <returns>ImportQueueRecordFile instance</returns>
public ImportQueueRecordFileInfo ImportQueueRecordFileInfoNew(ImportQueueRecord importQueueRecord = null, object anonymousFiller = null)
{
try
{
var dt = DateTime.UtcNow;
var res = new ImportQueueRecordFileInfo()
{
ImportQueueRecordFileInfoUID = Guid.NewGuid(),
ImportQueueRecordState = ImportQueueRecordStateGetDefault(),
};
if (anonymousFiller != null)
res.FillFromAnonymousType(anonymousFiller);
importQueueRecord = importQueueRecord ?? res.ImportQueueRecord;
if (importQueueRecord != null)
importQueueRecord.FileInfoes.Add(res);
return res;
}
catch(Exception ex)
{
Helpers.Log.Add(ex, string.Format("Repository.ImportQueueRecordFileInfoNew()"));
throw;
}
}
