protected void updateTools(PackageChange change, int index)
{
PackageUpdate update = new PackageUpdate {
change = change, index = index
};
if (!pendingUpdates.Contains(update))
{
pendingUpdates.Add(update);
Task task = Task.Delay(queuingDelay);
taskCompletion[task.Id] = false;
tasks.Add(task);
task.ContinueWith(x =>
{
taskCompletion[x.Id] = true;
if (tasks.TrueForAll(t => taskCompletion[t.Id]))
{
tasks.Clear();
taskCompletion.Clear();
foreach (var item in Tools)
{
item.handleUpdate(pendingUpdates.ToList());
}
pendingUpdates.Clear();
OnPropertyChanged(nameof(IsModified));
}
}, TaskScheduler.FromCurrentSynchronizationContext());
}
}
public async Task UpsertAsync(IEnumerable <Package> packages, CancellationToken cancellationToken = default)
{
var updatedAt = DateTime.Now;
var replacements = packages.Select(x =>
{
x.UpdatedAt = updatedAt;
var filter = Builders <Package> .Filter.Eq(x => x.Identifier, x.Identifier);
var update = Builders <Package> .Update
.Set(s => s.Identifier, x.Identifier)
.Set(s => s.Username, x.Username)
.Set(s => s.Tracking, x.Tracking)
.Set(s => s.Description, x.Description)
.Set(s => s.Weight, x.Weight)
.Set(s => s.Status, x.Status)
.Set(s => s.DeliveredAt, x.DeliveredAt)
.Set(s => s.UpdatedAt, x.UpdatedAt);
return(new UpdateOneModel <Package>(filter, update)
{
IsUpsert = true
});
}).ToList();
var updates = packages.Select(x =>
{
var change = new PackageChange {
Status = x.Status.Description, Percentage = x.Status.Percentage, Weight = x.Weight, Date = updatedAt
};
var filter = Builders <PackageHistory> .Filter.Eq(x => x.Identifier, x.Identifier);
var update = Builders <PackageHistory> .Update
.Set(s => s.Identifier, x.Identifier)
.Set(s => s.Username, x.Username)
.Set(s => s.Tracking, x.Tracking)
.AddToSet(u => u.Changes, change);
return(new UpdateOneModel <PackageHistory>(filter, update)
{
IsUpsert = true
});
}).ToList();
var task1 = _packages.BulkWriteAsync(replacements, null, cancellationToken);
var task2 = _history.BulkWriteAsync(updates, null, cancellationToken);
await Task.WhenAll(task1, task2);
}
protected void updateTools(PackageChange change, int index)
{
if (Users.Count == 0 && WeakUsers.Count == 0)
{
return;
}
PackageUpdate update = new PackageUpdate(change, index);
bool isNewUpdate;
lock (_updatelock)
{
isNewUpdate = !pendingUpdates.Contains(update);
}
if (isNewUpdate)
{
lock (_updatelock)
{
pendingUpdates.Add(update);
}
Task task = Task.Delay(queuingDelay);
taskCompletion[task.Id] = false;
tasks.Add(task);
task.ContinueWithOnUIThread(x =>
{
taskCompletion[x.Id] = true;
if (tasks.TrueForAll(t => taskCompletion[t.Id]))
{
tasks.Clear();
taskCompletion.Clear();
List <PackageUpdate> updates;
lock (_updatelock)
{
updates = pendingUpdates.ToList();
pendingUpdates.Clear();
}
var removedImports = updates.Where(u => u.Change == PackageChange.ImportRemove).Select(u => u.Index).ToList();
var removedExports = updates.Where(u => u.Change == PackageChange.ExportRemove).Select(u => u.Index).ToList();
var pendingUpdatesList = new List <PackageUpdate>();
//remove add/change updates for entries that have been removed
foreach (PackageUpdate upd in updates)
{
switch (upd.Change)
{
case PackageChange.ExportAdd:
case PackageChange.ExportData:
case PackageChange.ExportHeader:
{
if (!removedExports.Contains(upd.Index))
{
pendingUpdatesList.Add(upd);
}
break;
}
case PackageChange.ImportAdd:
case PackageChange.ImportHeader:
{
if (!removedImports.Contains(upd.Index))
{
pendingUpdatesList.Add(upd);
}
break;
}
default:
pendingUpdatesList.Add(upd);
break;
}
}
foreach (var item in Users.Concat(WeakUsers))
{
item.handleUpdate(pendingUpdatesList);
}
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsModified)));
}
});
}
}
protected void updateTools(PackageChange change, int index)
{
PackageUpdate update = new PackageUpdate {
change = change, index = index
};
if (!pendingUpdates.Contains(update))
{
pendingUpdates.Add(update);
Task task = Task.Delay(queuingDelay);
taskCompletion[task.Id] = false;
tasks.Add(task);
task.ContinueWithOnUIThread(x =>
{
taskCompletion[x.Id] = true;
if (tasks.TrueForAll(t => taskCompletion[t.Id]))
{
tasks.Clear();
taskCompletion.Clear();
var removedImports = pendingUpdates.Where(u => u.change == PackageChange.ImportRemove).Select(u => u.index).ToList();
var removedExports = pendingUpdates.Where(u => u.change == PackageChange.ExportRemove).Select(u => u.index).ToList();
var pendingUpdatesList = new List <PackageUpdate>();
foreach (PackageUpdate upd in pendingUpdates)
{
switch (upd.change)
{
case PackageChange.ExportAdd:
case PackageChange.ExportData:
case PackageChange.ExportHeader:
{
if (!removedExports.Contains(upd.index))
{
pendingUpdatesList.Add(upd);
}
break;
}
case PackageChange.ImportAdd:
case PackageChange.Import:
{
if (!removedImports.Contains(upd.index))
{
pendingUpdatesList.Add(upd);
}
break;
}
default:
pendingUpdatesList.Add(upd);
break;
}
}
pendingUpdates.Clear();
foreach (var item in Tools)
{
item.handleUpdate(pendingUpdatesList);
}
OnPropertyChanged(nameof(IsModified));
}
});
}
}
protected void updateTools(PackageChange change, int index)
{
PackageUpdate update = new PackageUpdate { change = change, index = index };
if (!pendingUpdates.Contains(update))
{
pendingUpdates.Add(update);
Task task = Task.Delay(queuingDelay);
taskCompletion[task.Id] = false;
tasks.Add(task);
task.ContinueWith(x =>
{
taskCompletion[x.Id] = true;
if (tasks.TrueForAll(t => taskCompletion[t.Id]))
{
tasks.Clear();
taskCompletion.Clear();
foreach (var item in Tools)
{
item.handleUpdate(pendingUpdates.ToList());
}
pendingUpdates.Clear();
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsModified)));
}
}, TaskScheduler.FromCurrentSynchronizationContext());
}
}
