/// <summary>
/// Delete an entry.
/// </summary>
/// <param name="pe">The entry to be deleted. Must not be <c>null</c>.</param>
/// <param name="permanent">Permanent delete or move to recycle bin</param>
public void DeleteEntry(PwEntry pe, bool permanent = false)
{
if (pe == null)
{
throw new ArgumentNullException("pe");
}
PwGroup pgRecycleBin = RootGroup.FindGroup(RecycleBinUuid, true);
PwGroup pgParent = pe.ParentGroup;
if (pgParent == null)
{
return; // Can't remove
}
pgParent.Entries.Remove(pe);
bool bPermanent = false;
if (RecycleBinEnabled == false)
{
bPermanent = true;
}
else if (permanent)
{
bPermanent = true;
}
else if (pgRecycleBin == null)
{
} // if we cannot find it, we will create it later
else if (pgParent == pgRecycleBin)
{
bPermanent = true;
}
else if (pgParent.IsContainedIn(pgRecycleBin))
{
bPermanent = true;
}
DateTime dtNow = DateTime.UtcNow;
if (bPermanent)
{
PwDeletedObject pdo = new PwDeletedObject(pe.Uuid, dtNow);
DeletedObjects.Add(pdo);
}
else // Recycle
{
EnsureRecycleBin(ref pgRecycleBin);
pgRecycleBin.AddEntry(pe, true, true);
pe.Touch(false);
}
}
public void DeleteObjects(String RegistrationKey, List <DeletedObject> dOList)
{
try {
Logger.Information("In DeleteObjects");
customerNum = util.GetDentalOfficeID(RegistrationKey);
if (customerNum == 0)
{
return;
}
DeletedObjects.DeleteForMobile(dOList, customerNum);
}
catch (Exception ex) {
Logger.LogError("IpAddress=" + HttpContext.Current.Request.UserHostAddress + " DentalOfficeID=" + customerNum, ex);
throw new Exception("Exception in DeleteObjects");
}
}
private void RefreshObjectLookUps()
{
CheckLocked();
Objects.Clear();
DeletedObjects.Clear();
ObjectsByUri[EtpVersion.v11].Clear();
ObjectsByUri[EtpVersion.v12].Clear();
foreach (var dataspace in Dataspaces)
{
foreach (var @object in dataspace.Objects.Values)
{
if (@object.IsDeleted)
{
DeletedObjects[@object.Uuid] = @object;
}
else
{
Objects[@object.Uuid] = @object;
}
ObjectsByUri[EtpVersion.v11][@object.Uri(EtpVersion.v11)] = @object;
foreach (var alternateUri in @object.AlternateUris(EtpVersion.v11))
{
ObjectsByUri[EtpVersion.v11][alternateUri] = @object;
}
ObjectsByUri[EtpVersion.v12][@object.Uri(EtpVersion.v12)] = @object;
foreach (var alternateUri in @object.AlternateUris(EtpVersion.v12))
{
ObjectsByUri[EtpVersion.v12][alternateUri] = @object;
}
}
}
}
/// <summary>
/// Clears the changes.
/// </summary>
internal void ClearChanges()
{
ModifiedProperties.Clear();
AddedObjects.Clear();
DeletedObjects.Clear();
}
///<summary>a general function to reduce the amount of code for uploading</summary>
private static void SynchGeneric(List <long> PKNumList, SynchEntity entity, double totalCount, ref double currentVal)
{
//Dennis: a try catch block here has been avoid on purpose.
List <long> BlockPKNumList = null;
int localBatchSize = BatchSize;
if (IsTroubleshootMode)
{
localBatchSize = 1;
}
string AtoZpath = ImageStore.GetPreferredAtoZpath();
for (int start = 0; start < PKNumList.Count; start += localBatchSize)
{
if ((start + localBatchSize) > PKNumList.Count)
{
localBatchSize = PKNumList.Count - start;
}
try{
BlockPKNumList = PKNumList.GetRange(start, localBatchSize);
switch (entity)
{
case SynchEntity.patient:
List <Patientm> changedPatientmList = Patientms.GetMultPats(BlockPKNumList);
mb.SynchPatients(PrefC.GetString(PrefName.RegistrationKey), changedPatientmList.ToArray());
break;
case SynchEntity.appointment:
List <Appointmentm> changedAppointmentmList = Appointmentms.GetMultApts(BlockPKNumList);
mb.SynchAppointments(PrefC.GetString(PrefName.RegistrationKey), changedAppointmentmList.ToArray());
break;
case SynchEntity.prescription:
List <RxPatm> changedRxList = RxPatms.GetMultRxPats(BlockPKNumList);
mb.SynchPrescriptions(PrefC.GetString(PrefName.RegistrationKey), changedRxList.ToArray());
break;
case SynchEntity.provider:
List <Providerm> changedProvList = Providerms.GetMultProviderms(BlockPKNumList);
mb.SynchProviders(PrefC.GetString(PrefName.RegistrationKey), changedProvList.ToArray());
break;
case SynchEntity.pharmacy:
List <Pharmacym> changedPharmacyList = Pharmacyms.GetMultPharmacyms(BlockPKNumList);
mb.SynchPharmacies(PrefC.GetString(PrefName.RegistrationKey), changedPharmacyList.ToArray());
break;
case SynchEntity.labpanel:
List <LabPanelm> ChangedLabPanelList = LabPanelms.GetMultLabPanelms(BlockPKNumList);
mb.SynchLabPanels(PrefC.GetString(PrefName.RegistrationKey), ChangedLabPanelList.ToArray());
break;
case SynchEntity.labresult:
List <LabResultm> ChangedLabResultList = LabResultms.GetMultLabResultms(BlockPKNumList);
mb.SynchLabResults(PrefC.GetString(PrefName.RegistrationKey), ChangedLabResultList.ToArray());
break;
case SynchEntity.medication:
List <Medicationm> ChangedMedicationList = Medicationms.GetMultMedicationms(BlockPKNumList);
mb.SynchMedications(PrefC.GetString(PrefName.RegistrationKey), ChangedMedicationList.ToArray());
break;
case SynchEntity.medicationpat:
List <MedicationPatm> ChangedMedicationPatList = MedicationPatms.GetMultMedicationPatms(BlockPKNumList);
mb.SynchMedicationPats(PrefC.GetString(PrefName.RegistrationKey), ChangedMedicationPatList.ToArray());
break;
case SynchEntity.allergy:
List <Allergym> ChangedAllergyList = Allergyms.GetMultAllergyms(BlockPKNumList);
mb.SynchAllergies(PrefC.GetString(PrefName.RegistrationKey), ChangedAllergyList.ToArray());
break;
case SynchEntity.allergydef:
List <AllergyDefm> ChangedAllergyDefList = AllergyDefms.GetMultAllergyDefms(BlockPKNumList);
mb.SynchAllergyDefs(PrefC.GetString(PrefName.RegistrationKey), ChangedAllergyDefList.ToArray());
break;
case SynchEntity.disease:
List <Diseasem> ChangedDiseaseList = Diseasems.GetMultDiseasems(BlockPKNumList);
mb.SynchDiseases(PrefC.GetString(PrefName.RegistrationKey), ChangedDiseaseList.ToArray());
break;
case SynchEntity.diseasedef:
List <DiseaseDefm> ChangedDiseaseDefList = DiseaseDefms.GetMultDiseaseDefms(BlockPKNumList);
mb.SynchDiseaseDefs(PrefC.GetString(PrefName.RegistrationKey), ChangedDiseaseDefList.ToArray());
break;
case SynchEntity.icd9:
List <ICD9m> ChangedICD9List = ICD9ms.GetMultICD9ms(BlockPKNumList);
mb.SynchICD9s(PrefC.GetString(PrefName.RegistrationKey), ChangedICD9List.ToArray());
break;
case SynchEntity.statement:
List <Statementm> ChangedStatementList = Statementms.GetMultStatementms(BlockPKNumList);
mb.SynchStatements(PrefC.GetString(PrefName.RegistrationKey), ChangedStatementList.ToArray());
break;
case SynchEntity.document:
List <Documentm> ChangedDocumentList = Documentms.GetMultDocumentms(BlockPKNumList, AtoZpath);
mb.SynchDocuments(PrefC.GetString(PrefName.RegistrationKey), ChangedDocumentList.ToArray());
break;
case SynchEntity.recall:
List <Recallm> ChangedRecallList = Recallms.GetMultRecallms(BlockPKNumList);
mb.SynchRecalls(PrefC.GetString(PrefName.RegistrationKey), ChangedRecallList.ToArray());
break;
case SynchEntity.deletedobject:
List <DeletedObject> ChangedDeleteObjectList = DeletedObjects.GetMultDeletedObjects(BlockPKNumList);
mb.DeleteObjects(PrefC.GetString(PrefName.RegistrationKey), ChangedDeleteObjectList.ToArray());
break;
case SynchEntity.patientdel:
mb.DeletePatientsRecords(PrefC.GetString(PrefName.RegistrationKey), BlockPKNumList.ToArray());
break;
}
//progressIndicator.CurrentVal+=LocalBatchSize;//not allowed
currentVal += localBatchSize;
if (Application.OpenForms["FormProgress"] != null) // without this line the following error is thrown: "Invoke or BeginInvoke cannot be called on a control until the window handle has been created." or a null pointer exception is thrown when an automatic synch is done by the system.
{
FormP.Invoke(new PassProgressDelegate(PassProgressToDialog),
new object[] { currentVal, "?currentVal of ?maxVal records uploaded", totalCount, "" });
}
}
catch (Exception e) {
if (IsTroubleshootMode)
{
string errorMessage = entity + " with Primary Key = " + BlockPKNumList.First() + " failed to synch. " + "\n" + e.Message;
throw new Exception(errorMessage);
}
else
{
throw e;
}
}
} //for loop ends here
}
///<summary>This is the function that the worker thread uses to actually perform the upload. Can also call this method in the ordinary way if the data to be transferred is small. The timeSynchStarted must be passed in to ensure that no records are skipped due to small time differences.</summary>
private static void UploadWorker(DateTime changedSince, DateTime timeSynchStarted)
{
int totalCount = 100;
try { //Dennis: try catch may not work: Does not work in threads, not sure about this. Note that all methods inside this try catch block are without exception handling. This is done on purpose so that when an exception does occur it does not update PrefName.MobileSyncDateTimeLastRun
//The handling of PrefName.MobileSynchNewTables79 should never be removed in future versions
DateTime changedProv = changedSince;
DateTime changedDeleted = changedSince;
DateTime changedPat = changedSince;
DateTime changedStatement = changedSince;
DateTime changedDocument = changedSince;
DateTime changedRecall = changedSince;
if (!PrefC.GetBoolSilent(PrefName.MobileSynchNewTables79Done, false))
{
changedProv = DateTime.MinValue;
changedDeleted = DateTime.MinValue;
}
if (!PrefC.GetBoolSilent(PrefName.MobileSynchNewTables112Done, false))
{
changedPat = DateTime.MinValue;
changedStatement = DateTime.MinValue;
changedDocument = DateTime.MinValue;
}
if (!PrefC.GetBoolSilent(PrefName.MobileSynchNewTables121Done, false))
{
changedRecall = DateTime.MinValue;
UploadPreference(PrefName.PracticeTitle); //done again because the previous upload did not include the prefnum
}
bool synchDelPat = true;
if (PrefC.GetDateT(PrefName.MobileSyncDateTimeLastRun).Hour == timeSynchStarted.Hour)
{
synchDelPat = false; // synching delPatNumList is timeconsuming (15 seconds) for a dental office with around 5000 patients and it's mostly the same records that have to be deleted every time a synch happens. So it's done only once hourly.
}
//MobileWeb
List <long> patNumList = Patientms.GetChangedSincePatNums(changedPat);
List <long> aptNumList = Appointmentms.GetChangedSinceAptNums(changedSince, PrefC.GetDate(PrefName.MobileExcludeApptsBeforeDate));
List <long> rxNumList = RxPatms.GetChangedSinceRxNums(changedSince);
List <long> provNumList = Providerms.GetChangedSinceProvNums(changedProv);
List <long> pharNumList = Pharmacyms.GetChangedSincePharmacyNums(changedSince);
List <long> allergyDefNumList = AllergyDefms.GetChangedSinceAllergyDefNums(changedSince);
List <long> allergyNumList = Allergyms.GetChangedSinceAllergyNums(changedSince);
//exclusively Patient Portal
List <long> eligibleForUploadPatNumList = Patientms.GetPatNumsEligibleForSynch();
List <long> labPanelNumList = LabPanelms.GetChangedSinceLabPanelNums(changedSince, eligibleForUploadPatNumList);
List <long> labResultNumList = LabResultms.GetChangedSinceLabResultNums(changedSince);
List <long> medicationNumList = Medicationms.GetChangedSinceMedicationNums(changedSince);
List <long> medicationPatNumList = MedicationPatms.GetChangedSinceMedicationPatNums(changedSince, eligibleForUploadPatNumList);
List <long> diseaseDefNumList = DiseaseDefms.GetChangedSinceDiseaseDefNums(changedSince);
List <long> diseaseNumList = Diseasems.GetChangedSinceDiseaseNums(changedSince, eligibleForUploadPatNumList);
List <long> icd9NumList = ICD9ms.GetChangedSinceICD9Nums(changedSince);
List <long> statementNumList = Statementms.GetChangedSinceStatementNums(changedStatement, eligibleForUploadPatNumList, statementLimitPerPatient);
List <long> documentNumList = Documentms.GetChangedSinceDocumentNums(changedDocument, statementNumList);
List <long> recallNumList = Recallms.GetChangedSinceRecallNums(changedRecall);
List <long> delPatNumList = Patientms.GetPatNumsForDeletion();
//List<DeletedObject> dO=DeletedObjects.GetDeletedSince(changedDeleted);dennis: delete this line later
List <long> deletedObjectNumList = DeletedObjects.GetChangedSinceDeletedObjectNums(changedDeleted);
totalCount = patNumList.Count + aptNumList.Count + rxNumList.Count + provNumList.Count + pharNumList.Count
+ labPanelNumList.Count + labResultNumList.Count + medicationNumList.Count + medicationPatNumList.Count
+ allergyDefNumList.Count + allergyNumList.Count + diseaseDefNumList.Count + diseaseNumList.Count + icd9NumList.Count
+ statementNumList.Count + documentNumList.Count + recallNumList.Count
+ deletedObjectNumList.Count;
if (synchDelPat)
{
totalCount += delPatNumList.Count;
}
double currentVal = 0;
if (Application.OpenForms["FormProgress"] != null) // without this line the following error is thrown: "Invoke or BeginInvoke cannot be called on a control until the window handle has been created." or a null pointer exception is thrown when an automatic synch is done by the system.
{
FormP.Invoke(new PassProgressDelegate(PassProgressToDialog),
new object[] { currentVal, "?currentVal of ?maxVal records uploaded", totalCount, "" });
}
IsSynching = true;
SynchGeneric(patNumList, SynchEntity.patient, totalCount, ref currentVal);
SynchGeneric(aptNumList, SynchEntity.appointment, totalCount, ref currentVal);
SynchGeneric(rxNumList, SynchEntity.prescription, totalCount, ref currentVal);
SynchGeneric(provNumList, SynchEntity.provider, totalCount, ref currentVal);
SynchGeneric(pharNumList, SynchEntity.pharmacy, totalCount, ref currentVal);
//pat portal
SynchGeneric(labPanelNumList, SynchEntity.labpanel, totalCount, ref currentVal);
SynchGeneric(labResultNumList, SynchEntity.labresult, totalCount, ref currentVal);
SynchGeneric(medicationNumList, SynchEntity.medication, totalCount, ref currentVal);
SynchGeneric(medicationPatNumList, SynchEntity.medicationpat, totalCount, ref currentVal);
SynchGeneric(allergyDefNumList, SynchEntity.allergydef, totalCount, ref currentVal);
SynchGeneric(allergyNumList, SynchEntity.allergy, totalCount, ref currentVal);
SynchGeneric(diseaseDefNumList, SynchEntity.diseasedef, totalCount, ref currentVal);
SynchGeneric(diseaseNumList, SynchEntity.disease, totalCount, ref currentVal);
SynchGeneric(icd9NumList, SynchEntity.icd9, totalCount, ref currentVal);
SynchGeneric(statementNumList, SynchEntity.statement, totalCount, ref currentVal);
SynchGeneric(documentNumList, SynchEntity.document, totalCount, ref currentVal);
SynchGeneric(recallNumList, SynchEntity.recall, totalCount, ref currentVal);
if (synchDelPat)
{
SynchGeneric(delPatNumList, SynchEntity.patientdel, totalCount, ref currentVal);
}
//DeleteObjects(dO,totalCount,ref currentVal);// this has to be done at this end because objects may have been created and deleted between synchs. If this function is place above then the such a deleted object will not be deleted from the server.
SynchGeneric(deletedObjectNumList, SynchEntity.deletedobject, totalCount, ref currentVal); // this has to be done at this end because objects may have been created and deleted between synchs. If this function is place above then the such a deleted object will not be deleted from the server.
if (!PrefC.GetBoolSilent(PrefName.MobileSynchNewTables79Done, true))
{
Prefs.UpdateBool(PrefName.MobileSynchNewTables79Done, true);
}
if (!PrefC.GetBoolSilent(PrefName.MobileSynchNewTables112Done, true))
{
Prefs.UpdateBool(PrefName.MobileSynchNewTables112Done, true);
}
if (!PrefC.GetBoolSilent(PrefName.MobileSynchNewTables121Done, true))
{
Prefs.UpdateBool(PrefName.MobileSynchNewTables121Done, true);
}
Prefs.UpdateDateT(PrefName.MobileSyncDateTimeLastRun, timeSynchStarted);
IsSynching = false;
}
catch (Exception e) {
IsSynching = false; // this will ensure that the synch can start again. If this variable remains true due to an exception then a synch will never take place automatically.
if (Application.OpenForms["FormProgress"] != null) // without this line the following error is thrown: "Invoke or BeginInvoke cannot be called on a control until the window handle has been created." or a null pointer exception is thrown when an automatic synch is done by the system.
{
FormP.Invoke(new PassProgressDelegate(PassProgressToDialog),
new object[] { 0, "?currentVal of ?maxVal records uploaded", totalCount, e.Message });
}
}
}
public void RegDeletedObjects(object sender, RemoveObjInfoEventArgs e)
{
DeletedObjects.Add(e.RemovedObj);
}
public TestDataspace(string name, DateTime creation)
: base(name)
{
Logger = LogManager.GetLogger(GetType());
RootProperty = new MockPropertyKind
{
Dataspace = this,
Uuid = Guid.Parse("a48c9c25-1e3a-43c8-be6a-044224cc69cb"),
Title = "property",
Creation = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
LastUpdate = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
IsAbstract = "false",
QuantityClass = "unitless",
};
Velocity = new MockPropertyKind
{
Dataspace = this,
Uuid = Guid.Parse("d80b7b4d-f51d-4821-b1db-c595f18c51db"),
Title = "velocity",
Creation = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
LastUpdate = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
IsAbstract = "false",
QuantityClass = "length per time",
};
PenetrationRate = new MockPropertyKind
{
Dataspace = this,
Uuid = Guid.Parse("d2b70df2-6df3-4751-bd02-150e3fc96450"),
Title = "penetration rate",
Creation = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
LastUpdate = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
IsAbstract = "false",
QuantityClass = "length per time",
};
AvgPenetrationRate = new MockPropertyKind
{
Dataspace = this,
Uuid = Guid.Parse("7fbf2718-f45a-444e-ae3c-17f79f8817e2"),
Title = "avg penetration rate",
Creation = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
LastUpdate = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
IsAbstract = "false",
QuantityClass = "length per time",
};
Force = new MockPropertyKind
{
Dataspace = this,
Uuid = Guid.Parse("a5789b56-72a3-4561-b906-b5ba13852c23"),
Title = "force",
Creation = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
LastUpdate = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
IsAbstract = "false",
QuantityClass = "force",
};
Load = new MockPropertyKind
{
Dataspace = this,
Uuid = Guid.Parse("3bf92c0b-b712-4128-b7bc-b21e0270d9be"),
Title = "load",
Creation = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
LastUpdate = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
IsAbstract = "false",
QuantityClass = "force",
};
HookLoad = new MockPropertyKind
{
Dataspace = this,
Uuid = Guid.Parse("d0a7c1c5-73da-45b5-a762-eb49721d91e9"),
Title = "hook load",
Creation = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
LastUpdate = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
IsAbstract = "false",
QuantityClass = "force",
};
Length = new MockPropertyKind
{
Dataspace = this,
Uuid = Guid.Parse("4a305182-221e-4205-9e7c-a36b06fa5b3d"),
Title = "length",
Creation = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
LastUpdate = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
IsAbstract = "false",
QuantityClass = "length",
};
Depth = new MockPropertyKind
{
Dataspace = this,
Uuid = Guid.Parse("4364b378-899a-403a-8401-b06abd4fc0cf"),
Title = "depth",
Creation = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
LastUpdate = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
IsAbstract = "false",
QuantityClass = "length",
};
MeasuredDepth = new MockPropertyKind
{
Dataspace = this,
Uuid = Guid.Parse("c48c65d4-9680-4d10-903c-a1b2e30f66b5"),
Title = "measured depth",
Creation = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
LastUpdate = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
IsAbstract = "false",
QuantityClass = "length",
};
Time = new MockPropertyKind
{
Dataspace = this,
Uuid = Guid.Parse("3a72f130-4ebf-4ea9-a330-a610a4e4ed0e"),
Title = "time",
Creation = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
LastUpdate = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
IsAbstract = "false",
QuantityClass = "time",
};
AbsoluteTime = new MockPropertyKind
{
Dataspace = this,
Uuid = Guid.Parse("df21fba2-fe8c-4d66-9a73-fbd0e6013abb"),
Title = "absolute time",
Creation = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
LastUpdate = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
IsAbstract = "false",
QuantityClass = "time",
};
TimeStamp = new MockPropertyKind
{
Dataspace = this,
Uuid = Guid.Parse("6a2ecc9b-7561-41eb-8c6d-adf83538c085"),
Title = "time stamp",
Creation = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
LastUpdate = DateTime.Parse("2016-12-09T17:30:47Z").ToUniversalTime(),
IsAbstract = "false",
QuantityClass = "time",
};
Velocity.SetParent(RootProperty, creation);
PenetrationRate.SetParent(Velocity, creation);
AvgPenetrationRate.SetParent(PenetrationRate, creation);
Force.SetParent(RootProperty, creation);
Load.SetParent(Force, creation);
HookLoad.SetParent(Load, creation);
Length.SetParent(RootProperty, creation);
Depth.SetParent(Length, creation);
MeasuredDepth.SetParent(Depth, creation);
Time.SetParent(RootProperty, creation);
AbsoluteTime.SetParent(Time, creation);
TimeStamp.SetParent(AbsoluteTime, creation);
Well01 = new MockWell
{
Dataspace = this,
Title = "Well 01",
Creation = creation,
LastUpdate = creation,
};
Well02 = new MockWell
{
Dataspace = this,
Title = "Well 02",
Creation = creation,
LastUpdate = creation,
};
Wellbore01 = new MockWellbore
{
Dataspace = this,
Title = "Wellbore 01",
Creation = creation,
LastUpdate = creation,
};
Wellbore01.SetWell(Well01, creation);
Wellbore02 = new MockWellbore
{
Dataspace = this,
Title = "Wellbore 02",
Creation = creation,
LastUpdate = creation,
};
Wellbore02.SetWell(Well01, creation);
Wellbore03 = new MockWellbore
{
Dataspace = this,
Title = "Wellbore 03 - Deleted Periodically",
Creation = creation,
LastUpdate = creation,
};
Wellbore03.SetWell(Well01, creation);
Wellbore04 = new MockWellbore
{
Dataspace = this,
Title = "Wellbore 04 - Permanently Deleted",
Creation = creation,
LastUpdate = creation,
};
Wellbore04.SetWell(Well01, creation);
Wellbore05 = new MockWellbore
{
Dataspace = this,
Title = "Wellbore 05 - Automatic Subscription",
Creation = creation,
LastUpdate = creation,
};
Wellbore05.SetWell(Well01, creation);
TimeChannel01 = new MockChannel(true)
{
Dataspace = this,
Title = "Average ROP",
Creation = creation,
LastUpdate = creation,
ChannelPropertyKind = AvgPenetrationRate,
Mnemonic = "ROPA",
Uom = "m/h",
};
TimeChannel01.SetWellbore(Wellbore01, creation);
TimeChannel02 = new MockChannel(true)
{
Dataspace = this,
Title = "Hook Load",
Creation = creation,
LastUpdate = creation,
ChannelPropertyKind = HookLoad,
Mnemonic = "HKLD",
Uom = "10 kN",
};
TimeChannel02.SetWellbore(Wellbore01, creation);
TimeChannel03 = new MockChannel(true)
{
Dataspace = this,
Title = "Bit Depth - Periodically Deleted",
Creation = creation,
LastUpdate = creation,
ChannelPropertyKind = MeasuredDepth,
Mnemonic = "BDEP",
Uom = "m",
};
TimeChannel03.SetWellbore(Wellbore01, creation);
TimeChannel04 = new MockChannel(true)
{
Dataspace = this,
Title = "Hole Depth - Periodically Unjoined",
Creation = creation,
LastUpdate = creation,
ChannelPropertyKind = MeasuredDepth,
Mnemonic = "HDEP",
Uom = "m",
};
TimeChannel04.SetWellbore(Wellbore01, creation);
TimeChannelSet01 = new MockChannelSet
{
Dataspace = this,
Title = "Time ChannelSet 01",
Creation = creation,
LastUpdate = creation,
};
TimeChannelSet01.SetWellbore(Wellbore01, creation);
TimeChannel01.JoinContainer(TimeChannelSet01, creation);
TimeChannel02.JoinContainer(TimeChannelSet01, creation);
TimeChannel03.JoinContainer(TimeChannelSet01, creation);
TimeChannel04.JoinContainer(TimeChannelSet01, creation);
DepthChannel01 = new MockChannel(false)
{
Dataspace = this,
Title = "Average ROP",
Creation = creation,
LastUpdate = creation,
ChannelPropertyKind = AvgPenetrationRate,
Mnemonic = "ROPA",
Uom = "m/h",
};
DepthChannel01.SetWellbore(Wellbore01, creation);
DepthChannel02 = new MockChannel(false)
{
Dataspace = this,
Title = "Hook Load",
Creation = creation,
LastUpdate = creation,
ChannelPropertyKind = HookLoad,
Mnemonic = "HKLD",
Uom = "10 kN",
};
DepthChannel02.SetWellbore(Wellbore01, creation);
DepthChannelSet01 = new MockChannelSet
{
Dataspace = this,
Title = "Depth ChannelSet 01",
Creation = creation,
LastUpdate = creation,
};
DepthChannelSet01.SetWellbore(Wellbore01, creation);
DepthChannel01.JoinContainer(DepthChannelSet01, creation);
DepthChannel02.JoinContainer(DepthChannelSet01, creation);
var objects = new List <MockObject>
{
Well01,
Well02,
Wellbore01,
Wellbore02,
Wellbore03,
Wellbore05,
RootProperty,
Velocity,
PenetrationRate,
AvgPenetrationRate,
Force,
Load,
HookLoad,
Length,
Depth,
MeasuredDepth,
Time,
AbsoluteTime,
TimeStamp,
TimeChannelSet01,
TimeChannel01,
TimeChannel02,
TimeChannel03,
TimeChannel04,
DepthChannelSet01,
DepthChannel01,
DepthChannel02,
};
Objects.Clear();
foreach (var @object in objects)
{
Objects[@object.Uuid] = @object;
@object.Create(creation);
}
var deletedObjects = new List <MockObject>
{
Wellbore04,
};
DeletedObjects.Clear();
foreach (var deletedObject in deletedObjects)
{
DeletedObjects[deletedObject.Uuid] = deletedObject;
}
Witsml = new MockFamily
{
Dataspace = this,
Title = "WITSML Store (2.0)",
Type = MockWitsmlObject.Type,
};
Eml = new MockFamily
{
Dataspace = this,
Title = "EML Common (2.1)",
Type = MockCommonObject.Type,
};
var families = new List <MockFamily> {
Witsml, Eml
};
Families.Clear();
Families.AddRange(families);
}
/// <summary>
/// Delete a group.
/// </summary>
/// <param name="pg">Group to be added. Must not be <c>null</c>.</param>
/// <param name="permanent">Permanent delete or move to recycle bin</param>
public void DeleteGroup(PwGroup pg, bool permanent = false)
{
if (pg == null)
{
throw new ArgumentNullException("pg");
}
PwGroup pgParent = pg.ParentGroup;
if (pgParent == null)
{
throw new ArgumentNullException("pgParent"); // Can't remove virtual or root group
}
PwGroup pgRecycleBin = RootGroup.FindGroup(RecycleBinUuid, true);
bool bPermanent = false;
if (RecycleBinEnabled == false)
{
bPermanent = true;
}
else if (permanent)
{
bPermanent = true;
}
else if (pgRecycleBin == null)
{
} // if we cannot find it, we will create it later
else if (pg == pgRecycleBin)
{
bPermanent = true;
}
else if (pg.IsContainedIn(pgRecycleBin))
{
bPermanent = true;
}
else if (pgRecycleBin.IsContainedIn(pg))
{
bPermanent = true;
}
pgParent.Groups.Remove(pg);
if (bPermanent)
{
pg.DeleteAllObjects(this);
PwDeletedObject pdo = new PwDeletedObject(pg.Uuid, DateTime.UtcNow);
DeletedObjects.Add(pdo);
}
else // Recycle
{
EnsureRecycleBin(ref pgRecycleBin);
try { pgRecycleBin.AddGroup(pg, true, true); }
catch (Exception)
{
if (pgRecycleBin.Groups.IndexOf(pg) < 0)
{
pgParent.AddGroup(pg, true, true); // Undo removal
}
}
pg.Touch(false);
}
}
public override void Delete(object instance)
{
DeletedObjects.Add(instance);
}
public void Deserialize(XmlReader reader)
{
Reset();
SoodaObject currentObject = null;
SoodaRelationTable currentRelation = null;
bool inDebug = false;
// state data for just-being-read object
bool objectForcePostCommit = false;
bool objectDisableObjectTriggers = false;
bool objectDelete = false;
string objectClassName;
string objectMode = null;
object[] objectPrimaryKey = null;
ClassInfo objectClassInfo;
ISoodaObjectFactory objectFactory = null;
int objectKeyCounter = 0;
int objectTotalKeyCounter = 0;
try
{
_savingObjects = true;
// in case we get any "deleteobject" which require us to delete the objects
// within transaction
foreach (SoodaDataSource source in _dataSources)
{
source.BeginSaveChanges();
}
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && !inDebug)
{
switch (reader.Name)
{
case "field":
if (currentObject == null)
{
throw new Exception("Field without an object during deserialization!");
}
currentObject.DeserializeField(reader);
break;
case "persistent":
if (currentObject == null)
{
throw new Exception("Field without an object during deserialization!");
}
currentObject.DeserializePersistentField(reader);
break;
case "object":
if (currentObject != null)
{
// end deserialization
currentObject.EnableFieldUpdateTriggers();
currentObject = null;
}
objectKeyCounter = 0;
objectForcePostCommit = false;
objectDisableObjectTriggers = false;
objectClassName = reader.GetAttribute("class");
objectMode = reader.GetAttribute("mode");
objectDelete = false;
objectFactory = GetFactory(objectClassName);
objectClassInfo = objectFactory.GetClassInfo();
objectTotalKeyCounter = objectClassInfo.GetPrimaryKeyFields().Length;
if (objectTotalKeyCounter > 1)
{
objectPrimaryKey = new object[objectTotalKeyCounter];
}
if (reader.GetAttribute("forcepostcommit") != null)
{
objectForcePostCommit = true;
}
if (reader.GetAttribute("disableobjecttriggers") != null)
{
objectDisableObjectTriggers = true;
}
if (reader.GetAttribute("delete") != null)
{
objectDelete = true;
}
break;
case "key":
int ordinal = Convert.ToInt32(reader.GetAttribute("ordinal"));
object val = objectFactory.GetFieldHandler(ordinal).RawDeserialize(reader.GetAttribute("value"));
if (objectTotalKeyCounter > 1)
{
objectPrimaryKey[objectKeyCounter] = val;
}
objectKeyCounter++;
if (objectKeyCounter == objectTotalKeyCounter)
{
object primaryKey = objectTotalKeyCounter == 1 ? val : new SoodaTuple(objectPrimaryKey);
currentObject = BeginObjectDeserialization(objectFactory, primaryKey, objectMode);
if (objectForcePostCommit)
{
currentObject.ForcePostCommit();
}
if (objectDisableObjectTriggers)
{
currentObject.DisableObjectTriggers();
}
currentObject.DisableFieldUpdateTriggers();
if (objectDelete)
{
DeletedObjects.Add(currentObject);
currentObject.DeleteMarker = true;
currentObject.CommitObjectChanges();
currentObject.SetObjectDirty();
}
}
break;
case "transaction":
break;
case "relation":
currentRelation = GetRelationFromXml(reader);
break;
case "tuple":
currentRelation.DeserializeTuple(reader);
break;
case "debug":
if (!reader.IsEmptyElement)
{
inDebug = true;
}
break;
default:
throw new NotImplementedException("Element not implemented in deserialization: " + reader.Name);
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.Name == "debug")
{
inDebug = false;
}
else if (reader.Name == "object")
{
currentObject.EnableFieldUpdateTriggers();
}
}
}
foreach (WeakSoodaObject wr in _objectList)
{
SoodaObject ob = wr.TargetSoodaObject;
if (ob != null)
{
ob.AfterDeserialize();
}
}
}
finally
{
_savingObjects = false;
foreach (SoodaDataSource source in _dataSources)
{
source.FinishSaveChanges();
}
}
}
