//static public bool UpdateDiagram(Guid diagramId, string doc)
//{
// using (DocumentDBContext docdb = new DocumentDBContext())
// {
// dynamic x = docdb.InsertOrUpdateItemAsync("AzureLensColl", doc);
// }
// return true;
//}
public static dynamic LoadDiagram(Guid diagramId)
{
dynamic doc = null;
try
{
dynamic id = diagramId.ToString();
using (DocumentDBContext docdb = new DocumentDBContext())
{
doc = docdb.GetItemAsync<dynamic>(id, "AzureLensColl");
}
}
catch
{
// handle exception...
}
return doc.Result;
}
static public async Task <dynamic> LoadDiagram(Guid diagramId)
{
dynamic doc = null;
try
{
var id = diagramId.ToString();
using (DocumentDBContext docdb = new DocumentDBContext())
{
doc = await docdb.GetItemAsync <dynamic>(id, DiagramCollection);
}
}
catch
{
// handle exception...
}
return(doc);
}
public static async Task <Guid?> GetIdFromHashAsync(string hash)
{
Guid?id = null;
if (!string.IsNullOrWhiteSpace(hash))
{
using (DocumentDBContext docdb = new DocumentDBContext())
{
var doc = await docdb.GetItemAsync <dynamic>(hash, DiagramCollection);
if (doc != null)
{
string diagramId = doc.diagramId;
Guid parsedId;
if (Guid.TryParse(diagramId, out parsedId))
{
id = parsedId;
}
}
}
}
return(id);
}
public static async Task<Guid?> GetIdFromHashAsync(string hash)
{
Guid? id = null;
if (!string.IsNullOrWhiteSpace(hash))
{
using (DocumentDBContext docdb = new DocumentDBContext())
{
var doc = await docdb.GetItemAsync<dynamic>(hash, DiagramCollection);
if (doc != null)
{
string diagramId = doc.diagramId;
Guid parsedId;
if (Guid.TryParse(diagramId, out parsedId))
{
id = parsedId;
}
}
}
}
return id;
}
static public async Task<dynamic> LoadDiagram(Guid diagramId)
{
dynamic doc = null;
try
{
var id = diagramId.ToString();
using (DocumentDBContext docdb = new DocumentDBContext())
{
doc = await docdb.GetItemAsync<dynamic>(id, DiagramCollection);
}
}
catch
{
// handle exception...
}
return doc;
}
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);
}
}
