private static async Task DeleteCollection(string appDataPath)
{
try
{
string settingsFile = appDataPath + "\\" + FolderConstants.GIN_APP_DATA_FOLDER + "\\settings.txt";
string encryptedString = System.IO.File.ReadAllText(settingsFile);
string decryptedString = CottonDBMS.Helpers.EncryptionHelper.Decrypt(encryptedString);
var parms = Newtonsoft.Json.JsonConvert.DeserializeObject <TruckAppInstallParams>(decryptedString);
if (!string.IsNullOrEmpty(parms.EndPoint) &&
!string.IsNullOrEmpty(parms.Key))
{
DocumentDBContext.Initialize(parms.EndPoint, parms.Key);
//remove document tracking lists this truck has downloaded
//this allows them to be released for delete etc at the gin
await DocumentDBContext.DeleteCollectionAsync();
}
else
{
Console.WriteLine("One or more settings null.");
}
}
catch (Exception exc)
{
Console.WriteLine(exc.Message);
Console.WriteLine(exc.StackTrace);
Console.WriteLine("Press enter to continue.");
Console.ReadLine();
}
}
public async Task DoSync()
{
var newSyncTime = DateTime.UtcNow;
try
{
if (!SyncHelper.HasConnection())
{
return;
}
using (var uow = new UnitOfWork())
{
var documentDbSetting = uow.SettingsRepository.FindSingle(x => x.Key == BridgeSettingKeys.DOCUMENT_DB_KEY);
var endpointSetting = uow.SettingsRepository.FindSingle(x => x.Key == BridgeSettingKeys.DOCUMENTDB_ENDPOINT);
DocumentDBContext.Initialize(endpointSetting.Value, documentDbSetting.Value);
if (DocumentDBContext.Initialized)
{
try
{
var lastSyncTime = DateTime.Parse(uow.SettingsRepository.GetSettingWithDefault(BridgeSettingKeys.LAST_SYNC_TIME, "01/01/2019"));
lastSyncTime = lastSyncTime.AddMinutes(-1);
await ExecuteSteps(uow, lastSyncTime);
uow.SettingsRepository.UpsertSetting(BridgeSettingKeys.LAST_SYNC_TIME, newSyncTime.ToString());
uow.SaveChanges();
}
catch (Exception exc)
{
Logging.Logger.Log(exc);
}
}
}
}
catch (Exception outerExc)
{
Logging.Logger.Log(outerExc);
}
}
private static async Task ClearDownloadedListsData(string appDataPath)
{
try
{
Console.WriteLine("Releasing downloaded lists...");
string settingsFile = appDataPath + "\\Truck\\settings.txt";
string encryptedString = System.IO.File.ReadAllText(settingsFile);
string decryptedString = CottonDBMS.Helpers.EncryptionHelper.Decrypt(encryptedString);
var parms = Newtonsoft.Json.JsonConvert.DeserializeObject <TruckAppInstallParams>(decryptedString);
if (!string.IsNullOrEmpty(parms.EndPoint) &&
!string.IsNullOrEmpty(parms.Key) &&
!string.IsNullOrEmpty(parms.TruckID))
{
DocumentDBContext.Initialize(parms.EndPoint, parms.Key);
Console.WriteLine("Looking for downloaded lists...");
var docs = await DocumentDBContext.GetAllItemsAsync <TruckListsDownloaded>(p => p.Id == "TRUCKDOWNLOADS_" + parms.TruckID);
if (docs.Count() > 0)
{
Console.WriteLine("Releasing lists...");
//remove document tracking lists this truck has downloaded
//this allows them to be released for delete etc at the gin
await DocumentDBContext.DeleteItemAsync <TruckListsDownloaded>("TRUCKDOWNLOADS_" + parms.TruckID);
}
}
else
{
Console.WriteLine("One or more settings null.");
}
}
catch (Exception exc)
{
Console.WriteLine(exc.Message);
Console.WriteLine(exc.StackTrace);
Console.WriteLine("Press enter to continue.");
Console.ReadLine();
}
}
private async Task <bool> CreateDatabase()
{
DocumentDBContext.Initialize(tbAzureCosmosEndpoint.Text.Trim(), tbAzureKey.Text.Trim());
bool exists = await DocumentDBContext.DatabaseExistsAsync();
bool createSucceded = true;
if (!exists)
{
try
{
await DocumentDBContext.CreateDatabaseAsync();
}
catch (Exception exc)
{
Logging.Logger.Log(exc);
createSucceded = false;
}
}
return(createSucceded);
}
public NavViewModel()
{
LockSettingsCommand = new GalaSoft.MvvmLight.CommandWpf.RelayCommand(this.ExecuteLockSettings);
SavePasswordCommand = new GalaSoft.MvvmLight.CommandWpf.RelayCommand(this.ExecuteSavePasswordCommand);
CancelCommand = new GalaSoft.MvvmLight.CommandWpf.RelayCommand(this.ExecuteCancelCommand);
UnlockCommand = new GalaSoft.MvvmLight.CommandWpf.RelayCommand(this.ExecuteUnlockCommand);
SaveUnlockCommand = new GalaSoft.MvvmLight.CommandWpf.RelayCommand(this.ExecuteSaveUnlockCommand);
Drivers = new ObservableCollection <ComboBoxItemViewModel>();
PasswordModalVisible = false;
UnlockPasswordModalVisible = false;
using (var dp = SimpleIoc.Default.GetInstance <IUnitOfWorkFactory>().CreateUnitOfWork())
{
var setting = dp.SettingsRepository.FindSingle(k => k.Key == TruckClientSettingKeys.ADMIN_PASSWORD);
if (setting != null && !string.IsNullOrWhiteSpace(setting.Value))
{
SettingsLocked = true;
}
else
{
SettingsLocked = false;
}
var documentDbSetting = dp.SettingsRepository.FindSingle(x => x.Key == TruckClientSettingKeys.DOCUMENT_DB_KEY);
var syncIntervalSetting = dp.SettingsRepository.FindSingle(x => x.Key == TruckClientSettingKeys.DATA_SYNC_INTERVAL);
var endpointSetting = dp.SettingsRepository.FindSingle(x => x.Key == TruckClientSettingKeys.DOCUMENTDB_ENDPOINT);
string key = "";
string endpoint = "";
if (documentDbSetting != null)
{
key = documentDbSetting.Value;
}
if (endpointSetting != null)
{
endpoint = endpointSetting.Value;
}
if (string.IsNullOrWhiteSpace(key) || string.IsNullOrWhiteSpace(endpoint))
{
CloudDBInitialized = false;
HasCloudSettings = false;
}
else
{
HasCloudSettings = true;
try
{
Task.Run(async() => {
DocumentDBContext.Initialize(endpoint, key);
if (!await DocumentDBContext.DatabaseExistsAsync())
{
CloudDBInitialized = true;
}
});
}
catch (Exception exc)
{
Logging.Logger.Log(exc);
}
}
}
Messenger.Default.Register <BusyMessage>(this, (action) => ReceiveBusyMessage(action));
Messenger.Default.Register <DialogClosedMessage>(this, (action => ReceiveDialogClosed(action)));
Messenger.Default.Register <DialogOpenedMessage>(this, (action => ReceiveDialogOpened(action)));
refresh();
Timer timer = new Timer(25000);
timer.Elapsed += (sender, e) => refresh();
timer.Start();
}
private async Task InitializeDataSourcesAsync()
{
using (IUnitOfWork uow = UnitOfWorkFactory.CreateUnitOfWork())
{
BusyMessage.Show("Checking for Azure database.", this);
var settingsRepo = uow.SettingsRepository;
string endpoint = settingsRepo.FindSingle(t => t.Key == GinAppSettingKeys.AZURE_DOCUMENTDB_ENDPOINT).Value;
string key = settingsRepo.FindSingle(t => t.Key == GinAppSettingKeys.AZURE_DOCUMENTDB_KEY).Value;
if (endpoint.ToLower().IndexOf("azure.com") >= 0 && !string.IsNullOrEmpty(key))
{
DocumentDBContext.Initialize(endpoint, key);
bool exists = await DocumentDBContext.DatabaseExistsAsync();
bool createSucceded = true;
if (!exists)
{
BusyMessage.UpdateMessage("Creating Azure document database..");
try
{
await DocumentDBContext.CreateDatabaseAsync();
}
catch (Exception exc)
{
Logging.Logger.Log(exc);
createSucceded = false;
BusyMessage.UpdateMessage("Creating Azure document database failed.");
System.Threading.Thread.Sleep(2000);
}
}
if (createSucceded)
{
exists = await DocumentDBContext.CollectionExistsAsync();
if (!exists)
{
try
{
BusyMessage.UpdateMessage("Creating Azure document database collections..");
await DocumentDBContext.CreateCollectionAsync();
createSucceded = true;
}
catch (Exception exc)
{
BusyMessage.UpdateMessage("Creating Azure document database collections failed.");
System.Threading.Thread.Sleep(2000);
Logging.Logger.Log(exc);
createSucceded = false;
}
}
}
if (createSucceded)
{
try
{
await DocumentDBContext.CreateStoredProceduresAsync();
}
catch (Exception exc)
{
BusyMessage.UpdateMessage("Creating database stored procedures failed.");
System.Threading.Thread.Sleep(2000);
Logging.Logger.Log(exc);
createSucceded = false;
}
}
DbIntitialized = true;
BusyMessage.Close();
}
else
{
BusyMessage.Close();
DbIntitialized = false;
appTabs.TabPages.Remove(tabHome);
appTabs.TabPages.Remove(tabFields);
appTabs.TabPages.Remove(tabModules);
appTabs.TabPages.Remove(tabPickupLists);
appTabs.TabPages.Remove(tabClients);
appTabs.TabPages.Remove(tabFarms);
appTabs.TabPages.Remove(tabTrucks);
appTabs.TabPages.Remove(tabDrivers);
appTabs.TabPages.Remove(tabReports);
appTabs.TabIndex = 0;
MessageBox.Show("Azure Document DB connection settings are missing or incorrect. Please update Azure information in the Settings tab then restart the application.");
}
}
}
private async Task <bool> ValidateForm()
{
bool isValid = true;
clearErrors();
if (string.IsNullOrWhiteSpace(_documentDbConnection))
{
isValid = false;
HasDocumentDbConnectionErrorMessage = true;
DocumentDbConnectionErrorMessage = "required";
}
if (string.IsNullOrWhiteSpace(DocumentDbEndpoint))
{
isValid = false;
HasDocumentDbEndpointErrorMessage = true;
DocumentDbEndpointErrorMessage = "required";
}
else if (!ValidationHelper.ValidUrl(DocumentDbEndpoint))
{
isValid = false;
HasDocumentDbEndpointErrorMessage = true;
DocumentDbEndpointErrorMessage = "Invalid URL";
}
if (!HasDocumentDbConnectionErrorMessage && !HasDocumentDbEndpointErrorMessage)
{
try
{
DocumentDBContext.Initialize(_documentDbEndpoint, _documentDbConnection);
var trucks = await DocumentDBContext.GetAllItemsAsync <TruckEntity>(p => p.EntityType == EntityType.TRUCK);
}
catch (Exception exc)
{
isValid = false;
HasDocumentDbEndpointErrorMessage = true;
DocumentDbEndpointErrorMessage = "Unable to connect.";
Logging.Logger.Log(exc);
}
}
if (string.IsNullOrWhiteSpace(TareWeight))
{
isValid = false;
HasTareWeightErrorMessage = true;
TareWeightErrorMessage = "required";
}
else if (!ValidationHelper.ValidDecimal(TareWeight))
{
isValid = false;
HasTareWeightErrorMessage = true;
TareWeightErrorMessage = "Invalid decimal number.";
}
if (BarcodePortName != "NONE" && BarcodePortName == PortName)
{
isValid = false;
HasBarcodePortErrorMessage = true;
}
return(isValid);
}
public static async Task DoSync()
{
try
{
if (!hasConnection())
{
return;
}
using (var uow = new UnitOfWork())
{
var documentDbSetting = uow.SettingsRepository.FindSingle(x => x.Key == TruckClientSettingKeys.DOCUMENT_DB_KEY);
var endpointSetting = uow.SettingsRepository.FindSingle(x => x.Key == TruckClientSettingKeys.DOCUMENTDB_ENDPOINT);
DocumentDBContext.Initialize(endpointSetting.Value, documentDbSetting.Value);
//return;
if (DocumentDBContext.Initialized)
{
try
{
var truck = uow.SettingsRepository.GetCurrentTruck();
List <PickupListEntity> pickupLists = new List <PickupListEntity>();
Logging.Logger.Log("INFO", "Fetching pickuplists.");
if (truck != null)
{
//process deleted documents - this mainly cleans out the Docs to process table
//except for PickupLists if the truck deleted a pickup list a Release request doc is put in the cloud
//so the gin can remove the truck assignment
List <TruckPickupListRelease> releaseDocs = new List <TruckPickupListRelease>();
//get all lists that have been released by this truck previously
await processDeletedDocuments(uow, token, truck.Id, releaseDocs);
var cloudReleaseDocs = await DocumentDBContext.GetAllItemsAsync <TruckPickupListRelease>(x => x.TruckID == truck.Id);
releaseDocs.AddRange(cloudReleaseDocs);
var tempLists = await DocumentDBContext.GetAllItemsAsync <PickupListEntity>(p => p.EntityType == EntityType.PICKUPLIST && p.Source == InputSource.GIN && p.AssignedTruckIDs.Contains(truck.Id), 100);
foreach (var list in tempLists) //only add lists that have not been released by truck
{
if (!releaseDocs.Any(x => x.PickupListID == list.Id))
{
pickupLists.Add(list);
}
}
}
//immediately mark lists that have been downloaded
TruckListsDownloaded document = new TruckListsDownloaded();
document.Id = "TRUCKDOWNLOADS_" + truck.Id;
document.Name = truck.Id;
document.Source = InputSource.TRUCK;
document.SyncedToCloud = true;
document.Created = DateTime.UtcNow;
document.PickupListsDownloaded = new List <string>();
document.PickupListsDownloaded.AddRange(pickupLists.Select(x => x.Id).ToArray());
await DocumentDBContext.UpsertItemAsync <TruckListsDownloaded>(document);
var driver = uow.SettingsRepository.GetCurrentDriver();
if (truck == null || driver == null)
{
return; //only sync if a truck and driver is configured
}
//pull down clients/farms/fields/trucks and pickuplists
Logging.Logger.Log("INFO", "Downloading data.");
var clients = await DocumentDBContext.GetAllItemsAsync <ClientEntity>(p => p.EntityType == EntityType.CLIENT && p.Source == InputSource.GIN, 500);
var farms = await DocumentDBContext.GetAllItemsAsync <FarmEntity>(p => p.EntityType == EntityType.FARM && p.Source == InputSource.GIN, 500);
var fields = await DocumentDBContext.GetAllItemsAsync <FieldEntity>(p => p.EntityType == EntityType.FIELD && p.Source == InputSource.GIN, 500);
var trucks = await DocumentDBContext.GetAllItemsAsync <TruckEntity>(p => p.EntityType == EntityType.TRUCK);
var drivers = await DocumentDBContext.GetAllItemsAsync <DriverEntity>(p => p.EntityType == EntityType.DRIVER);
var syncedSettings = await DocumentDBContext.GetAllItemsAsync <SyncedSettings>(p => p.EntityType == EntityType.SETTING_SUMMARY);
var clientIdsToIgnore = new List <string>();
clientIdsToIgnore.Add(GUIDS.UNASSIGNED_CLIENT_ID);
var farmIdsToIgnore = new List <string>();
farmIdsToIgnore.Add(GUIDS.UNASSIGNED_FARM_ID);
var fieldIdsToIgnore = new List <string>();
fieldIdsToIgnore.Add(GUIDS.UNASSIGNED_FIELD_ID);
var listIdsToIgnore = new List <string>();
listIdsToIgnore.Add(GUIDS.UNASSIGNED_LIST_ID);
Logging.Logger.Log("INFO", "Fetching local data.");
var localClients = uow.ClientRepository.GetAll().Where(c => c.Id != GUIDS.UNASSIGNED_CLIENT_ID);
var localFarms = uow.FarmRepository.GetAll().Where(c => c.Id != GUIDS.UNASSIGNED_FARM_ID);
var localFields = uow.FieldRepository.GetAll().Where(c => c.Id != GUIDS.UNASSIGNED_FIELD_ID);
var localSyncedSettings = uow.SyncedSettingsRepo.GetAll();
var localPickupLists = uow.PickupListRepository.GetAll(new string[] { "DownloadedToTrucks", "AssignedTrucks", "Field.Farm.Client" }).Where(c => c.Id != GUIDS.UNASSIGNED_LIST_ID);
var localModules = uow.ModuleRepository.GetAll(new string[] { "Field.Farm.Client", "PickupList" });
var localDrivers = uow.DriverRepository.GetAll();
var localTrucks = uow.TruckRepository.GetAll();
var pickUpListIds = pickupLists.Select(t => t.Id).Distinct().ToArray();
Logging.Logger.Log("INFO", "Fetching modules");
//TODO PICKUPLIST ID
var modules = await DocumentDBContext.GetAllItemsAsync <ModuleEntity>(p => p.PickupListId != null && pickUpListIds.Contains(p.PickupListId) && p.EntityType == EntityType.MODULE, 50000);
Logging.Logger.Log("INFO", "Computing records to delete.");
var fieldsToRemove = localFields.Where(f => !fields.Any(x => x.Id == f.Id)).ToList();
var farmsToRemove = localFarms.Where(f => !farms.Any(x => x.Id == f.Id)).ToList();
var clientsToRemove = localClients.Where(f => !clients.Any(x => x.Id == f.Id)).ToList();
var trucksToRemove = localTrucks.Where(t => !trucks.Any(x => x.Id == t.Id)).ToList();
var driversToRemove = localDrivers.Where(d => !drivers.Any(x => x.Id == d.Id)).ToList();
var listsToRemove = localPickupLists.Where(p => !pickupLists.Any(x => x.Id == p.Id)).ToList();
if (token.IsCancellationRequested)
{
return;
}
//if there are items that were deleted at gin but got linked to truck entered data before
//truck data was synced then mark records to be sent to gin again to preserve
//data integrity
if (truck != null && trucksToRemove.Any(t => t.Id == truck.Id))
{
truck.Source = InputSource.TRUCK;
truck.Updated = DateTime.UtcNow;
uow.TruckRepository.Update(truck);
uow.SaveChanges();
}
if (token.IsCancellationRequested)
{
return;
}
if (driver != null && driversToRemove.Any(d => d.Id == driver.Id))
{
driver.Source = InputSource.TRUCK;
driver.Updated = DateTime.UtcNow;
uow.DriverRepository.Update(driver);
uow.SaveChanges();
}
///////////// THIS SECTION COULD PROBABLY BE REMOVED SINCE WE ARE PREVENTING DELETE OF LISTS ONCE DOWNLOADED //////////////////////
foreach (var list in listsToRemove) //if list was removed at gin but had modules added, force it to be re-added
{
bool canDelete = true;
var cloudDocument = await DocumentDBContext.GetItemAsync <PickupListEntity>(list.Id);
//make sure modules get put back in cloud for reassignment
//TODO PICKUPLISTID
foreach (var m in localModules.Where(m => m.PickupListId == list.Id))
{
var eventsWithSerial = uow.AggregateEventRepository.FindMatching(evt => evt.SerialNumber == m.Name).ToList();
if (eventsWithSerial.Count() > 0)
{
canDelete = false;
m.Source = InputSource.TRUCK;
m.Updated = DateTime.UtcNow;
uow.ModuleRepository.Update(m);
}
}
//TODO PICKUPLISTID
if (localModules.Any(m => m.PickupListId == list.Id) && !canDelete)
{
list.Source = InputSource.TRUCK;
list.Updated = DateTime.UtcNow;
uow.PickupListRepository.Update(list);
if (cloudDocument != null) //list is in cloud but this truck was removed - add to ignored list to prevent overwriting
{
listIdsToIgnore.Add(list.Id);
}
}
}
uow.SaveChanges();
foreach (var list in localPickupLists.Where(p => p.Source == InputSource.TRUCK))
{
if (token.IsCancellationRequested)
{
return;
}
var field = localFields.SingleOrDefault(x => x.Id == list.FieldId);
if (field != null && fieldsToRemove.Any(x => x.Id == field.Id))
{
field.Source = InputSource.TRUCK;
field.Updated = DateTime.UtcNow;
uow.FieldRepository.Update(field);
if (farmsToRemove.Any(x => x.Id == field.FarmId))
{
field.Farm.Source = InputSource.TRUCK;
field.Updated = DateTime.UtcNow;
uow.FarmRepository.Update(field.Farm);
}
if (clientsToRemove.Any(x => x.Id == field.Farm.Client.Id))
{
field.Farm.Client.Source = InputSource.TRUCK;
field.Farm.Client.Updated = DateTime.UtcNow;
}
}
}
uow.SaveChanges();
///////////// THE ABOVE SECTION COULD PROBABLY BE REMOVED SINCE WE ARE PREVENTING DELETE OF LISTS ONCE DOWNLOADED //////////////////////
if (token.IsCancellationRequested)
{
return;
}
await pushEntitiesOfType <DriverEntity>(uow, uow.DriverRepository, token, drivers, new List <string>());
await pushEntitiesOfType <TruckEntity>(uow, uow.TruckRepository, token, trucks, new List <string>());
await pushEntitiesOfType <ClientEntity>(uow, uow.ClientRepository, token, clients, clientIdsToIgnore);
await pushEntitiesOfType <FarmEntity>(uow, uow.FarmRepository, token, farms, farmIdsToIgnore);
await pushEntitiesOfType <FieldEntity>(uow, uow.FieldRepository, token, fields, fieldIdsToIgnore);
await pushEntitiesOfType <PickupListEntity>(uow, uow.PickupListRepository, token, pickupLists, listIdsToIgnore);
await pushModules(uow, uow.ModuleRepository, token, modules);
if (token.IsCancellationRequested)
{
return;
}
using (var addWork = new UnitOfWork())
{
addWork.DisableChangeTracking();
addEntitiesOfType <DriverEntity>(addWork, addWork.DriverRepository, token, drivers, localDrivers);
addEntitiesOfType <TruckEntity>(addWork, addWork.TruckRepository, token, trucks, localTrucks);
addEntitiesOfType <ClientEntity>(addWork, addWork.ClientRepository, token, clients, localClients);
addEntitiesOfType <FarmEntity>(addWork, addWork.FarmRepository, token, farms, localFarms);
addEntitiesOfType <FieldEntity>(addWork, addWork.FieldRepository, token, fields, localFields);
addEntitiesOfType <PickupListEntity>(addWork, addWork.PickupListRepository, token, pickupLists, localPickupLists);
addEntitiesOfType <SyncedSettings>(addWork, addWork.SyncedSettingsRepo, token, syncedSettings, localSyncedSettings);
addEntitiesOfType <ModuleEntity>(addWork, addWork.ModuleRepository, token, modules, localModules);
}
if (token.IsCancellationRequested)
{
return;
}
using (var updateWork = new UnitOfWork())
{
updateWork.DisableChangeTracking();
updateEntitiesOfType <DriverEntity>(updateWork, updateWork.DriverRepository, token, drivers, localDrivers, false);
updateEntitiesOfType <TruckEntity>(updateWork, updateWork.TruckRepository, token, trucks, localTrucks, true);
updateEntitiesOfType <ClientEntity>(updateWork, updateWork.ClientRepository, token, clients, localClients, false);
updateEntitiesOfType <FarmEntity>(updateWork, updateWork.FarmRepository, token, farms, localFarms, false);
updateEntitiesOfType <FieldEntity>(updateWork, updateWork.FieldRepository, token, fields, localFields, false);
updateEntitiesOfType <PickupListEntity>(updateWork, updateWork.PickupListRepository, token, pickupLists, localPickupLists, false);
updateEntitiesOfTypeIfNewer <ModuleEntity>(updateWork, updateWork.ModuleRepository, token, modules, localModules, false);
updateEntitiesOfType <SyncedSettings>(updateWork, updateWork.SyncedSettingsRepo, token, syncedSettings, localSyncedSettings, false);
}
if (token.IsCancellationRequested)
{
return;
}
deleteEntitiesOfType <DriverEntity>(uow, uow.DriverRepository, token, drivers);
deleteEntitiesOfType <TruckEntity>(uow, uow.TruckRepository, token, trucks);
deleteEntitiesOfType <ModuleEntity>(uow, uow.ModuleRepository, token, modules);
deleteEntitiesOfType <PickupListEntity>(uow, uow.PickupListRepository, token, pickupLists);
deleteEntitiesOfType <FieldEntity>(uow, uow.FieldRepository, token, fields);
deleteEntitiesOfType <FarmEntity>(uow, uow.FarmRepository, token, farms);
deleteEntitiesOfType <ClientEntity>(uow, uow.ClientRepository, token, clients);
cleanDupedModules(uow, uow.ModuleRepository, token);
if (truck != null)
{
//send aggregate events to cloud
Logging.Logger.Log("INFO", "Send aggregate events");
foreach (var moduleEvent in uow.AggregateEventRepository.GetDirtyOrderedByTime())
{
if (token.IsCancellationRequested)
{
return;
}
if (truck != null)
{
moduleEvent.TruckID = truck.Id;
}
if (driver != null)
{
moduleEvent.DriverID = driver.Id;
}
moduleEvent.Source = InputSource.TRUCK;
//lookup module
var module = uow.ModuleRepository.FindSingle(m => m.Name == moduleEvent.SerialNumber, "Field.Farm.Client", "PickupList");
//add on field/farm/client/pickup list info it may be needed to re-create list at gin
if (module != null)
{
moduleEvent.PickupListId = module.PickupListId;
moduleEvent.PickupListName = module.ListName;
if (module.Field != null)
{
moduleEvent.FarmId = module.Field.FarmId;
}
moduleEvent.FarmName = module.FarmName;
moduleEvent.FieldId = module.FieldId;
moduleEvent.FieldName = module.FieldName;
moduleEvent.ModuleId = module.Id;
if (module.Field.Farm != null)
{
moduleEvent.ClientId = module.Field.Farm.ClientId;
}
moduleEvent.ClientName = module.ClientName;
}
await DocumentDBContext.UpsertItemAsync <AggregateEvent>(moduleEvent);
uow.AggregateEventRepository.Update(moduleEvent, true);
uow.SaveChanges();
}
if (token.IsCancellationRequested)
{
return;
}
//send list of pickup lists this truck has
Logging.Logger.Log("INFO", "Send list of pickup lists this truck has downloaded.");
var lists = uow.PickupListRepository.FindMatching(t => t.AssignedTrucks.Any(x => x.Id == truck.Id), new string[] { "AssignedTrucks" });
TruckListsDownloaded document2 = new TruckListsDownloaded();
document2.Id = "TRUCKDOWNLOADS_" + truck.Id;
document2.Name = truck.Id;
document2.Source = InputSource.TRUCK;
document2.SyncedToCloud = true;
document2.Created = DateTime.UtcNow;
document2.PickupListsDownloaded = new List <string>();
document2.PickupListsDownloaded.AddRange(lists.Select(x => x.Id).ToArray());
await DocumentDBContext.UpsertItemAsync <TruckListsDownloaded>(document2);
}
}
catch (Exception exc)
{
Logging.Logger.Log(exc);
}
}
}
}
catch (Exception outerExc)
{
Logging.Logger.Log(outerExc);
}
}
