// </ItemOperationsWithValidPartitionKeyValue>
/// <summary>
/// The function demonstrates migrating documents that were inserted without a value for partition key, and those inserted
/// pre-migration to other logical partitions, those with a value for partition key.
/// </summary>
// <MigratedItemsFromNonePartitionKeyToValidPartitionKeyValue>
private static async Task MigratedItemsFromNonePartitionKeyToValidPartitionKeyValue(Container container)
{
// Pre-create a few items in the container to demo the migration
const int ItemsToCreate = 4;
// Insert a few items with no Partition Key
for (int i = 0; i < ItemsToCreate; i++)
{
string itemid = Guid.NewGuid().ToString();
DeviceInformationItem itemWithoutPK = GetDeviceWithNoPartitionKey(itemid);
ItemResponse <DeviceInformationItem> createResponse = await container.CreateItemAsync <DeviceInformationItem>(
partitionKey : PartitionKey.None,
item : itemWithoutPK);
}
// Query items on the container that have no partition key value by supplying NonePartitionKeyValue
// The operation is made in batches to not lose work in case of partial execution
int resultsFetched = 0;
QueryDefinition sql = new QueryDefinition("select * from r");
using (FeedIterator <DeviceInformationItem> setIterator = container.GetItemQueryIterator <DeviceInformationItem>(
sql,
requestOptions: new QueryRequestOptions()
{
PartitionKey = PartitionKey.None,
MaxItemCount = 2
}))
{
while (setIterator.HasMoreResults)
{
FeedResponse <DeviceInformationItem> queryResponse = await setIterator.ReadNextAsync();
resultsFetched += queryResponse.Count();
// For the items returned with NonePartitionKeyValue
IEnumerator <DeviceInformationItem> iter = queryResponse.GetEnumerator();
while (iter.MoveNext())
{
DeviceInformationItem item = iter.Current;
if (item.DeviceId != null)
{
// Using existing deviceID for partition key
item.PartitionKey = item.DeviceId;
Console.WriteLine("Migrating item {0} to Partition {1}", item.Id, item.DeviceId);
// Re-Insert into container with a partition key
// This could result in exception if the same item was inserted in a previous run of the program on existing container
// and the program stopped before the delete.
ItemResponse <DeviceInformationItem> createResponseWithPk = await container.CreateItemAsync <DeviceInformationItem>(
partitionKey : new PartitionKey(item.PartitionKey),
item : item);
// Deleting item from fixed container with CosmosContainerSettings.NonePartitionKeyValue.
ItemResponse <DeviceInformationItem> deleteResponseWithoutPk = await container.DeleteItemAsync <DeviceInformationItem>(
partitionKey : PartitionKey.None,
id : item.Id);
}
}
}
}
}
/// <summary>
/// The function demonstrates the Item CRUD operation using the NonePartitionKeyValue
/// NonePartitionKeyValue represents the information that the current item doesn't have a value for partitition key
/// All items inserted pre-migration are grouped into this logical partition and can be accessed by providing this value
/// for the partitionKey parameter
/// New item CRUD could be performed using this NonePartitionKeyValue to target the same logical partition
/// </summary>
private static async Task ItemOperationsWithNonePartitionKeyValue(CosmosContainer container)
{
string itemid = Guid.NewGuid().ToString();
DeviceInformationItem itemWithoutPK = GetDeviceWithNoPartitionKey(itemid);
// Insert a new item with NonePartitionKeyValue
CosmosItemResponse <DeviceInformationItem> createResponse = await container.Items.CreateItemAsync <DeviceInformationItem>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
item : itemWithoutPK);
Console.WriteLine("Creating Item {0} Status Code {1}", itemid, createResponse.StatusCode);
// Read an existing item with NonePartitionKeyValue
CosmosItemResponse <DeviceInformationItem> readResponse = await container.Items.ReadItemAsync <DeviceInformationItem>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
id : itemid);
Console.WriteLine("Reading Item {0} Status Code {1}", itemid, readResponse.StatusCode);
// Replace the content of existing item with NonePartitionKeyValue
itemWithoutPK.DeviceId = Guid.NewGuid().ToString();
CosmosItemResponse <DeviceInformationItem> replaceResponse = await container.Items.ReplaceItemAsync <DeviceInformationItem>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
id : itemWithoutPK.Id,
item : itemWithoutPK);
Console.WriteLine("Replacing Item {0} Status Code {1}", itemid, replaceResponse.StatusCode);
// Delete an item with NonePartitionKeyValue.
CosmosItemResponse <DeviceInformationItem> deleteResponse = await container.Items.DeleteItemAsync <DeviceInformationItem>(
partitionKey : CosmosContainerSettings.NonePartitionKeyValue,
id : itemid);
Console.WriteLine("Deleting Item {0} Status Code {1}", itemid, deleteResponse.StatusCode);
}
public void StopUartService()
{
if (this.InvalidateDialog != null)
{
uartService.EchoReceived -= uartService_EchoReceived;
}
this.uartService.Stop();
this.chosenDevice = null;
}
public void AddBLEDevice(BluetoothLEDevice device)
{
//var exist = this.items.FirstOrDefault(obj => obj.DeviceID == device.DeviceId);
//if (exist != null)
// this.items.Remove(exist);
this.items.Clear();
var addedDevice = new DeviceInformationItem(device);
this.items.Add(addedDevice);
}
public async Task <bool> StartDeviceFirmwareUpdate(DeviceInformationItem targetDevice)
{
GattDeviceService genericAttribute;
GattDeviceService deviceFirmwareUpdate;
targetDevice.Services.TryGetValue(ToolboxIdentifications.GattServiceNames.GENERIC_ATTRIBUTES, out genericAttribute);
targetDevice.Services.TryGetValue(ToolboxIdentifications.GattServiceNames.DEVICE_FIRMWARE_UPDATE, out deviceFirmwareUpdate);
if (genericAttribute != null && deviceFirmwareUpdate != null)
{
try
{
var type = DFUPackageHandler.GetFirmwareType(SelectedDeviceFirmwareTypeName);
if (type.Equals(FirmwareTypeEnum.Softdevice_Bootloader))
{
var imageFile = ChosenFiles.Find(x => x.Name == dfuSettingViewModel.manifestObject.manifest.softdevice_bootloader.bin_file);
var dataFile = ChosenFiles.Find(x => x.Name == dfuSettingViewModel.manifestObject.manifest.softdevice_bootloader.dat_file);
var sdSize = dfuSettingViewModel.manifestObject.manifest.softdevice_bootloader.sd_size;
var blSize = dfuSettingViewModel.manifestObject.manifest.softdevice_bootloader.bl_size;
await deviceFirmwareUpdateService.Start(deviceFirmwareUpdate, genericAttribute, type, dataFile, imageFile, sdSize, blSize);
}
else
{
var dat = ChosenFiles.Find(x => x.FileType == DeviceFirmwareUpdateSettingPageViewModel.DataFile_dat);
var img = ChosenFiles.Find(x => x.FileType == DeviceFirmwareUpdateSettingPageViewModel.ImageFile_Bin);
await deviceFirmwareUpdateService.Start(deviceFirmwareUpdate, genericAttribute, type, dat, img);
}
await deviceFirmwareUpdateService.EnableServiceChange();
await deviceFirmwareUpdateService.SwitchOnBootLoader();
}
catch (Exception e)
{
this.exception = e;
}
if (this.exception != null)
{
await UpdateDFUStatus(DeviceFirmwareUpdateStatusEnum.DFU_ERROR, 0, this.exception.GetType().ToString(), this.exception.Message);
return(false);
}
else
{
RegisterTimer();
return(true);
}
}
else
{
await UpdateDFUStatus(DeviceFirmwareUpdateStatusEnum.SERVICES_NOT_AVAILABLE);
return(false);
}
}
public void StartHeartRateMonitor(DeviceInformationItem heartRateDevice)
{
GattDeviceService hrService;
GattDeviceService baService;
if (heartRateDevice.Services.TryGetValue(ToolboxIdentifications.GattServiceNames.HEART_RATE, out hrService))
{
heartRateService.Start(hrService);
}
if (heartRateDevice.Services.TryGetValue(ToolboxIdentifications.GattServiceNames.BATTERY, out baService))
{
batteryService.Start(baService);
}
}
public async void StartServicesOnDevice(DeviceInformationItem chosenBLEDevice)
{
var linkLossServiceOnDevice = chosenBLEDevice.Device.GetGattService(GattServiceUuids.LinkLoss);
var batteryServiceOnDevice = chosenBLEDevice.Device.GetGattService(GattServiceUuids.Battery);
var ImmediateAlertServiceOnDevice = chosenBLEDevice.Device.GetGattService(GattServiceUuids.ImmediateAlert);
await BatteryService.Start(batteryServiceOnDevice);
await LinkLossService.Start(linkLossServiceOnDevice);
LinkLossService.WriteAlertLevelCharacteristicAsync(AlertLevelEnum.HighAlert);
await ImmediateAlertService.Start(ImmediateAlertServiceOnDevice);
BatteryService.ValueChangeCompleted += BatteryService_ValueChangeCompleted;
}
async void deviceFirmwareUpdateService_ServiceChanged(GattCharacteristic sender, GattValueChangedEventArgs args)
{
IsServiceChanged = true;
await Task.Delay(TimeSpan.FromMilliseconds(300)); //do we need this?
await UpdateAvailableDevice();
DeviceInformationItem newDevice = null;
GattDeviceService dfuService;
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
newDevice = DeviceSelectionViewModel.GetBLEDevice(sender.Service.Device.DeviceId);
});
if (newDevice != null && newDevice.Services.TryGetValue(ToolboxIdentifications.GattServiceNames.DEVICE_FIRMWARE_UPDATE, out dfuService))
{
deviceFirmwareUpdateService.StarDfu(dfuService);
}
}
public void InitializeDevice(DeviceInformationItem chosenUartDevice)
{
if (this.chosenDevice == null || this.chosenDevice.DeviceID != chosenUartDevice.DeviceID)
{
this.chosenDevice = chosenUartDevice;
GattDeviceService service = null;
if (chosenDevice.Services.TryGetValue(ToolboxIdentifications.GattServiceNames.NORDIC_UART, out service))
{
uartService.Start(service);
uartService.EchoReceived += uartService_EchoReceived;
IsReadyToTalk = true;
}
}
else if (this.chosenDevice != null || uartService.IsServiceStarted)
{
IsReadyToTalk = true;
}
//give error message or success message
}
// </ItemOperationsWithNonePartitionKeyValue>
/// <summary>
/// The function demonstrates CRUD operations on the migrated collection supplying a value for the partition key
/// <summary>
// <ItemOperationsWithValidPartitionKeyValue>
private static async Task ItemOperationsWithValidPartitionKeyValue(Container container)
{
string itemid = Guid.NewGuid().ToString();
string partitionKey = "a";
DeviceInformationItem itemWithPK = GetDeviceWithPartitionKey(itemid, partitionKey);
// Insert a new item
ItemResponse <DeviceInformationItem> createResponse = await container.CreateItemAsync <DeviceInformationItem>(
partitionKey : new PartitionKey(partitionKey),
item : itemWithPK);
Console.WriteLine("Creating Item {0} with Partition Key Status Code {1}", itemid, createResponse.StatusCode);
// Read the item back
ItemResponse <DeviceInformationItem> readResponse = await container.ReadItemAsync <DeviceInformationItem>(
partitionKey : new PartitionKey(partitionKey),
id : itemid);
Console.WriteLine("Reading Item {0} with Partition Key Status Code {1}", itemid, readResponse.StatusCode);
// Replace the content of the item
itemWithPK.DeviceId = Guid.NewGuid().ToString();
ItemResponse <DeviceInformationItem> replaceResponse = await container.ReplaceItemAsync <DeviceInformationItem>(
partitionKey : new PartitionKey(partitionKey),
id : itemWithPK.Id,
item : itemWithPK);
Console.WriteLine("Replacing Item {0} with Partition Key Status Code {1}", itemid, replaceResponse.StatusCode);
// Delete the item.
ItemResponse <DeviceInformationItem> deleteResponse = await container.DeleteItemAsync <DeviceInformationItem>(
partitionKey : new PartitionKey(partitionKey),
id : itemid);
Console.WriteLine("Deleting Item {0} with Partition Key Status Code {1}", itemid, deleteResponse.StatusCode);
}
