private void CreateProblem(ProblemDto dto, long patientKey, Provenance provenance)
{
var clinicalCase = _clinicalCaseRepository.GetActiveClinicalCaseByPatient(patientKey);
CodedConcept problemCode = null;
if (dto.ProblemCodeCodedConcept != null)
{
problemCode = new CodedConceptBuilder().WithCodedConceptDto(dto.ProblemCodeCodedConcept);
}
var problem = _problemFactory.CreateProblem(clinicalCase, problemCode, provenance);
var problemType = _mappingHelper.MapLookupField <ProblemType> (dto.ProblemType);
var problemStatus = _mappingHelper.MapLookupField <ProblemStatus> (dto.ProblemStatus);
problem.ReviseProblemType(problemType);
problem.ReviseOnsetDateRange(new DateRange(dto.OnsetStartDate, dto.OnsetEndDate));
problem.UpdateProblemStatus(problemStatus, dto.StatusChangedDate);
problem.ReviseCauseOfDeathIndicator(dto.CauseOfDeathIndicator);
if (dto.ObservedByStaff != null)
{
var staff = Session.Load <Staff> (dto.ObservedByStaff.Key);
problem.ReviseObservationInfo(staff, dto.ObservedDate);
}
}
private void CreateImmunization(ImmunizationDto dto, long patientKey, Provenance provenance)
{
var clinicalCase = _clinicalCaseRepository.GetActiveClinicalCaseByPatient(patientKey);
var immunization = _immunizationFactory.CreateImmunization(
clinicalCase, provenance, new DateTimeRange(dto.ActivityStartDateTime, dto.ActivityStartDateTime));
CodedConcept vaccineCodedConcept = null;
if (dto.VaccineCodedConcept != null)
{
vaccineCodedConcept = new CodedConceptBuilder().WithCodedConceptDto(dto.VaccineCodedConcept);
}
var unitOfMeasure = _mappingHelper.MapLookupField <ImmunizationUnitOfMeasure> (dto.ImmunizationUnitOfMeasure);
var notGivenReason = _mappingHelper.MapLookupField <ImmunizationNotGivenReason> (dto.ImmunizationNotGivenReason);
immunization.ReviseImmunizationVaccineInfo(
new ImmunizationVaccineInfo(
vaccineCodedConcept,
dto.VaccineLotNumber,
new ImmunizationVaccineManufacturer(dto.VaccineManufacturerCode, dto.VaccineManufacturerName)));
immunization.ReviseImmunizationAdministration(new ImmunizationAdministration(dto.AdministeredAmount, unitOfMeasure));
immunization.ReviseImmunizationNotGivenReason(notGivenReason);
}
private void CreateAllergy(AllergyDto dto, Patient patient, Provenance provenance)
{
var allergyStatus = _mappingHelper.MapLookupField <AllergyStatus> (dto.AllergyStatus);
CodedConcept allergenCodedConcept = null;
if (dto.AllergenCodedConcept != null)
{
allergenCodedConcept = new CodedConceptBuilder().WithCodedConceptDto(dto.AllergenCodedConcept);
}
var allergy = patient.AddAllergy(allergyStatus, allergenCodedConcept, provenance);
var allergySeverityType = _mappingHelper.MapLookupField <AllergySeverityType> (dto.AllergySeverityType);
var allergyType = _mappingHelper.MapLookupField <AllergyType> (dto.AllergyType);
allergy.ReviseAllergySeverityType(allergySeverityType);
allergy.ReviseAllergyType(allergyType);
allergy.ReviseOnsetDateRange(new DateRange(dto.OnsetStartDate, dto.OnsetEndDate));
// Map reactions
var deletedReactions = allergy.AllergyReactions.Where(
a => dto.AllergyReactions.All(ad => ad.Key != a.Reaction.Key)).ToList();
deletedReactions.ForEach(allergy.DeleteReaction);
var addedReactions = dto.AllergyReactions.Where(
a => allergy.AllergyReactions.All(ad => ad.Reaction.Key != a.Key)).ToList();
addedReactions.ForEach(r => allergy.AddReaction(_mappingHelper.MapLookupField <Reaction> (r)));
}
private void CreateMedication(MedicationDto dto, Patient patient, Provenance provenance)
{
CodedConcept medicationCode = null;
if (dto.MedicationCodeCodedConcept != null)
{
medicationCode = new CodedConceptBuilder().WithCodedConceptDto(dto.MedicationCodeCodedConcept);
}
var medication = patient.AddMedication(medicationCode, provenance);
CodedConcept rootMedicationCode = null;
if (dto.RootMedicationCodedConcept != null)
{
rootMedicationCode = new CodedConceptBuilder().WithCodedConceptDto(dto.RootMedicationCodedConcept);
}
var discontinuedReason = _mappingHelper.MapLookupField <DiscontinuedReason> (dto.DiscontinuedReason);
var medicationStatus = dto.MedicationStatus == null
? _mappingHelper.MapLookupField <MedicationStatus> (WellKnownNames.PatientModule.MedicationStatus.Inactive)
: _mappingHelper.MapLookupField <MedicationStatus> (dto.MedicationStatus);
medication.ReviseOverTheCounterIndicator(dto.OverTheCounterIndicator);
medication.RevisePrescribingPhysicianName(dto.PrescribingPhysicianName);
medication.ReviseUsageDateRange(new DateRange(dto.StartDate, dto.EndDate));
medication.ReviseDiscontinuedByPhysicianName(dto.DiscontinuedByPhysicianName);
medication.ReviseDiscontinuedReason(discontinuedReason);
medication.ReviseDiscontinuedReasonOtherDescription(dto.DiscontinuedReasonOtherDescription);
medication.ReviseFrequencyDescription(dto.FrequencyDescription);
medication.ReviseInstructionsNote(dto.InstructionsNote);
medication.ReviseMedicationStatus(medicationStatus);
medication.ReviseRootMedicationCodedConcept(rootMedicationCode);
}
private async Task <UpsertResourceResponse> GenericHandle(RequestHandlerDelegate <UpsertResourceResponse> next, CancellationToken cancellationToken)
{
if (_state.Intercepted)
{
return(await next());
}
_state.Intercepted = true;
Provenance provenance = GetProvenanceFromHeader();
var response = await next();
if (response != null && provenance != null)
{
// Set target to provided resource.
provenance.Target = new System.Collections.Generic.List <ResourceReference>()
{
new ResourceReference($"{response.Outcome.RawResourceElement.InstanceType}/{response.Outcome.RawResourceElement.Id}"),
};
// Create Provenance resource.
// TODO: It should probaby go through controller to trigger audit events, but it's quite tricky to do now.
await _mediator.Send <UpsertResourceResponse>(new CreateResourceRequest(provenance.ToResourceElement()), cancellationToken);
}
return(response);
}
private void CreateVitalSign(VitalSignDto dto, long patientKey, Provenance provenance)
{
if (dto == null)
{
return;
}
var clinicalCase = _clinicalCaseRepository.GetActiveClinicalCaseByPatient(patientKey);
var vitalSign = _vitalSignFactory.CreateVitalSign(
clinicalCase, provenance, new DateTimeRange(dto.ActivityStartDateTime, dto.ActivityEndDateTime));
vitalSign.ReviseHeight(new Height(dto.HeightFeetMeasure, dto.HeightInchesMeasure));
vitalSign.ReviseWeight(dto.WeightLbsMeasure);
new AggregateNodeCollectionMapper <BloodPressureDto, VitalSign, BloodPressure> (
dto.BloodPressures, vitalSign, vitalSign.BloodPressures)
.MapRemovedItem(RemoveBloodPressure)
.MapAddedItem(AddBloodPressure)
.MapChangedItem(ChangeBloodPressure)
.Map();
new AggregateNodeCollectionMapper <HeartRateDto, VitalSign, HeartRate> (dto.HeartRates, vitalSign, vitalSign.HeartRates)
.MapRemovedItem(RemoveHeartRate)
.MapAddedItem(AddHeartRate)
.MapChangedItem(ChangeHeartRate)
.Map();
}
public static IEnumerable <Metadata> MetaList(IList <XElement> metaList)
{
if (metaList == null || metaList.Count == 0)
{
yield break;
}
foreach (var item in metaList)
{
switch (item.Name.LocalName)
{
case "oai_dc":
yield return(DublinCore.Decode(item));
break;
case "provenance":
yield return(Provenance.Decode(item));
break;
case "pan_simple":
yield return(PanSimple.Decode(item));
break;
// TODO: Add format here
default:
break;
}
}
}
public void SetUp()
{
p1 = MockRepository.GenerateMock <Provenance>();
p2 = MockRepository.GenerateMock <Provenance>();
p3 = MockRepository.GenerateMock <Provenance>();
p4 = MockRepository.GenerateMock <Provenance>();
}
public async Task AddressWasPositionedSetsPosition(
AddressId addressId,
WkbGeometry geometry,
Provenance provenance,
AddressWasRegistered addressWasRegistered)
{
var addressWasPositioned = new AddressWasPositioned(addressId, new AddressGeometry(GeometryMethod.Interpolated, GeometrySpecification.BuildingUnit, GeometryHelpers.CreateEwkbFrom(geometry)));
((ISetProvenance)addressWasPositioned).SetProvenance(provenance);
await Assert(
Given(addressWasRegistered, addressWasPositioned)
.Expect(
new AddressComparer <AddressDetailItem>(),
ctx => ctx.AddressDetail,
new AddressDetailItem
{
AddressId = addressWasRegistered.AddressId,
StreetNameId = addressWasRegistered.StreetNameId,
HouseNumber = addressWasRegistered.HouseNumber,
Position = addressWasPositioned.ExtendedWkbGeometry.ToByteArray(),
PositionMethod = addressWasPositioned.GeometryMethod,
PositionSpecification = addressWasPositioned.GeometrySpecification,
VersionTimestamp = addressWasPositioned.Provenance.Timestamp
}));
}
public static IEnumerable <XElement> MetaList(string containerName, IList <Metadata> metaList, string granularity)
{
if (string.IsNullOrEmpty(containerName) || metaList == null || metaList.Count == 0 || string.IsNullOrEmpty(granularity))
{
yield break;
}
foreach (var metaItem in metaList)
{
switch (FormatList.Int2Format(metaItem.MdFormat))
{
case Enums.MetadataFormats.DublinCore:
yield return(new XElement(containerName, DublinCore.Encode(metaItem, granularity)));
break;
case Enums.MetadataFormats.PanSimple:
yield return(new XElement(containerName, PanSimple.Encode(metaItem, granularity)));
break;
case Enums.MetadataFormats.Provenance:
yield return(new XElement(containerName, Provenance.Encode(metaItem, granularity)));
break;
// TODO: Add format here
case Enums.MetadataFormats.None:
default:
break;
}
}
}
public static Generator <IEnumerable <object> > StreetName(Guid streetNameId, string nameDutch = null)
{
var provenance = new Provenance(
Instant.FromDateTimeOffset(DateTimeOffset.Now),
(Application)Produce.Integer(1, 5).Generate(new Random()),
new Reason(Produce.AlphaNumericString(5, 15).Generate(new Random())),
new Operator(Produce.AlphaNumericString(5, 15).Generate(new Random())),
(Modification)Produce.Integer(1, 3).Generate(new Random()),
(Organisation)Produce.Integer(1, 10).Generate(new Random()));
return(new Generator <IEnumerable <object> >(r =>
{
var events = new List <IGenerator <object> >
{
StreetNameWasRegistered
.Select(e =>
e.WithId(streetNameId)
.WithProvenance(provenance))
};
if (nameDutch != null)
{
events.Add(StreetNameNameWasNamed
.Select(e => e.WithId(streetNameId)
.WithName(nameDutch)
.WithLanguage(StreetNameRegistry.Language.Dutch)
.WithProvenance(provenance)));
}
return events.Select(e => e.Generate(r));
}));
}
public async Task <IActionResult> Create([Bind("Id,Place,WayBill,ReceiptDate,Note,BookId")] Provenance provenance)
{
if (!_context.Books.Any(b => b.Id == provenance.BookId))
{
ModelState.AddModelError("BookId", "Книги з даним інвентарним номером не існує");
}
else if (_context.Provenances.Any(i => i.BookId == provenance.BookId))
{
ModelState.AddModelError("BookId", "Книга з даним інвентарним номером вже має запис про походження");
}
if (_context.Provenances.Any(i => i.WayBill == provenance.WayBill))
{
ModelState.AddModelError("WayBill", "Запис про походження з даним номером накладної вже існує");
}
if (ModelState.IsValid)
{
_context.Add(provenance);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewData["BookId"] = provenance.BookId;
ViewData["Fail"] = true;
return(View(provenance));
}
public async Task AddressPositionWasRemovedSetsPositionToNull(
AddressId addressId,
WkbGeometry geometry,
Provenance provenance,
AddressWasRegistered addressWasRegistered,
AddressPositionWasRemoved addressPositionWasRemoved)
{
var addressPositionWasCorrected =
new AddressPositionWasCorrected(addressId, new AddressGeometry(GeometryMethod.AppointedByAdministrator, GeometrySpecification.Entry, GeometryHelpers.CreateEwkbFrom(geometry)));
((ISetProvenance)addressPositionWasCorrected).SetProvenance(provenance);
await Assert(
Given(addressWasRegistered,
addressPositionWasCorrected, addressPositionWasRemoved)
.Expect(ctx => ctx.AddressDetail, new AddressDetailItem
{
AddressId = addressWasRegistered.AddressId,
StreetNameId = addressWasRegistered.StreetNameId,
HouseNumber = addressWasRegistered.HouseNumber,
Position = null,
PositionSpecification = null,
PositionMethod = null,
VersionTimestamp = addressPositionWasRemoved.Provenance.Timestamp
}));
}
public override int GetHashCode()
{
int hash = 1;
if (Type.Length != 0)
{
hash ^= Type.GetHashCode();
}
hash ^= subject_.GetHashCode();
if (PredicateType.Length != 0)
{
hash ^= PredicateType.GetHashCode();
}
if (predicateCase_ == PredicateOneofCase.Provenance)
{
hash ^= Provenance.GetHashCode();
}
if (predicateCase_ == PredicateOneofCase.SlsaProvenance)
{
hash ^= SlsaProvenance.GetHashCode();
}
hash ^= (int)predicateCase_;
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public SetMunicipalityToCurrent(
MunicipalityId municipalityId,
Provenance provenance)
{
MunicipalityId = municipalityId;
Provenance = provenance;
}
public static XElement Metadata(string containerName, Metadata metadata, string granularity)
{
if (string.IsNullOrEmpty(containerName) || metadata == null || string.IsNullOrEmpty(granularity))
{
return(null);
}
switch (FormatList.Int2Format(metadata.MdFormat))
{
case Enums.MetadataFormats.DublinCore:
return(new XElement(containerName, DublinCore.Encode(metadata, granularity)));
case Enums.MetadataFormats.PanSimple:
return(new XElement(containerName, PanSimple.Encode(metadata, granularity)));
case Enums.MetadataFormats.Provenance:
return(new XElement(containerName, Provenance.Encode(metadata, granularity)));
// TODO: Add format here
case Enums.MetadataFormats.None:
default:
return(null);
}
}
public void ThenNoPostalCodeChangeWhenOlderLifetime(
Fixture fixture,
AddressId addressId,
CrabLifetime lifetime,
string mailCantonCode,
Provenance provenance,
AddressHouseNumberMailCantonWasImportedFromCrab addressHouseNumberMailCantonWasImportedFromCrab,
ImportHouseNumberMailCantonFromCrab importHouseNumberMailCantonFromCrab)
{
addressHouseNumberMailCantonWasImportedFromCrab = addressHouseNumberMailCantonWasImportedFromCrab
.WithBeginDate(lifetime.BeginDateTime.Value.PlusDays(1))
.WithPostalCode(mailCantonCode);
importHouseNumberMailCantonFromCrab = importHouseNumberMailCantonFromCrab
.WithLifetime(lifetime);
var addressPostalCodeWasChanged = new AddressPostalCodeWasChanged(addressId, new PostalCode(mailCantonCode));
((ISetProvenance)addressPostalCodeWasChanged).SetProvenance(provenance);
Assert(RegisteredAddressScenario(fixture)
.Given(addressId,
addressPostalCodeWasChanged,
addressHouseNumberMailCantonWasImportedFromCrab)
.When(importHouseNumberMailCantonFromCrab)
.Then(addressId,
importHouseNumberMailCantonFromCrab.ToLegacyEvent()));
}
public RetireMunicipality(
MunicipalityId municipalityId,
Provenance provenance)
{
MunicipalityId = municipalityId;
Provenance = provenance;
}
public override int GetHashCode()
{
int hash = 1;
if (provenance_ != null)
{
hash ^= Provenance.GetHashCode();
}
if (ProvenanceBytes.Length != 0)
{
hash ^= ProvenanceBytes.GetHashCode();
}
if (intotoProvenance_ != null)
{
hash ^= IntotoProvenance.GetHashCode();
}
if (intotoStatement_ != null)
{
hash ^= IntotoStatement.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
/// <summary>
/// Deserialize JSON into a FHIR Provenance
/// </summary>
public static void DeserializeJson(this Provenance current, ref Utf8JsonReader reader, JsonSerializerOptions options)
{
string propertyName;
while (reader.Read())
{
if (reader.TokenType == JsonTokenType.EndObject)
{
return;
}
if (reader.TokenType == JsonTokenType.PropertyName)
{
propertyName = reader.GetString();
if (Hl7.Fhir.Serialization.FhirSerializerOptions.Debug)
{
Console.WriteLine($"Provenance >>> Provenance.{propertyName}, depth: {reader.CurrentDepth}, pos: {reader.BytesConsumed}");
}
reader.Read();
current.DeserializeJsonProperty(ref reader, options, propertyName);
}
}
throw new JsonException($"Provenance: invalid state! depth: {reader.CurrentDepth}, pos: {reader.BytesConsumed}");
}
public static StreetNameWasNamed WithProvenance(this StreetNameWasNamed e, Provenance provenance)
{
var newEvent = new StreetNameWasNamed(new StreetNameId(e.StreetNameId), new StreetNameName(e.Name, e.Language));
((ISetProvenance)newEvent).SetProvenance(provenance);
return(newEvent);
}
public bool AddEntryAssume(BoxedExpression assumeExpression, Provenance provenance)
{
if (!this.CanAddAssumes())
{
return(false);
}
this.inferredEntryAssumes.Add(new Pair <BoxedExpression, Provenance>(assumeExpression, provenance));
return(true);
}
public Hl7.Fhir.Model.Provenance WithProvenance(Provenance prov, Resource resource, string fullUrl)
{
// create the resource reference (with the full URL intact)
ResourceReference resRef = null;
ResourceReference relativeRef = null;
if (!string.IsNullOrEmpty(resource.Id))
{
resRef = new ResourceReference(resource.ResourceIdentity(resource.ResourceBase).OriginalString);
relativeRef = new ResourceReference(ResourceIdentity.Build(resource.TypeName, resource.Id, resource.Meta?.VersionId).OriginalString);
// Append the display (like all good servers should)
if (resource is Organization org)
{
resRef.Display = org.Name;
}
if (resource is Location loc)
{
resRef.Display = loc.Name;
}
if (resource is Endpoint ep)
{
resRef.Display = ep.Name;
}
if (resource is HealthcareService hcs)
{
resRef.Display = hcs.Name;
}
if (resource is Practitioner prac)
{
resRef.Display = prac.Name.FirstOrDefault()?.Text;
}
if (resource is PractitionerRole pracRole)
{
resRef.Display = pracRole.Practitioner.Display + " - " + string.Join(", ", pracRole.Code?.FirstOrDefault()?.Coding?.FirstOrDefault()?.Display);
}
relativeRef.Display = resRef.Display;
}
// include the resource in the provenance
Element what = resRef;
if (resRef != null)
{
prov.Target.Add(relativeRef);
}
else
{
what = new FhirUri(fullUrl);
}
prov.Entity.Add(new Provenance.EntityComponent()
{
Role = Provenance.ProvenanceEntityRole.Source,
// this is the URL of the original source content
What = what
});
return(prov);
}
public ChangeMunicipalityNisCode(
MunicipalityId municipalityId,
NisCode nisCode,
Provenance provenance)
{
MunicipalityId = municipalityId;
NisCode = nisCode;
Provenance = provenance;
}
/// <summary>
/// Creates the immunization.
/// </summary>
/// <param name="clinicalCase">The clinical case.</param>
/// <param name="provenance">The provenance.</param>
/// <param name="activityDateTimeRange">The activity date time range.</param>
/// <returns>An immunization.</returns>
public Immunization CreateImmunization(ClinicalCase clinicalCase, Provenance provenance, DateTimeRange activityDateTimeRange)
{
var activityType = _lookupValueRepository.GetLookupByWellKnownName <ActivityType>(WellKnownNames.VisitModule.ActivityType.Immunization);
var immunization = new Immunization(clinicalCase, activityType, provenance, activityDateTimeRange);
_immunizationRepository.MakePersistent(immunization);
return(immunization);
}
public ImportMunicipality(
MunicipalityId municipalityId,
NisCode nisCode,
Provenance provenance)
{
MunicipalityId = municipalityId;
NisCode = nisCode;
Provenance = provenance;
}
protected ProofObligationWithDecoder(APC pc, BoxedExpressionDecoder <Variable> decoder,
IMethodDriver <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, Expression, Variable, ILogOptions> mdriver
, Provenance provenance)
: base(pc, mdriver.CurrentMethodName(), provenance)
{
Contract.Requires(mdriver != null);
this.decoder = decoder;
this.MethodDriver = mdriver;
}
/// <summary>
/// Creates the vital sign.
/// </summary>
/// <param name="clinicalCase">The clinical case.</param>
/// <param name="provenance">The provenance.</param>
/// <param name="activityDateTimeRange">The activity date time range.</param>
/// <returns>Vital Sign</returns>
public VitalSign CreateVitalSign(ClinicalCase clinicalCase, Provenance provenance, DateTimeRange activityDateTimeRange)
{
var type = _lookupValueRepository.GetLookupByWellKnownName <ActivityType> (WellKnownNames.VisitModule.ActivityType.VitalSign);
var vitalSign = new VitalSign(clinicalCase, type, provenance, activityDateTimeRange);
_vitalSignRepository.MakePersistent(vitalSign);
return(vitalSign);
}
public readonly string definingMethod; // can be null
#endregion
#region Constructor
public ProofObligation(APC pc, string definingMethod, Provenance provenance)
{
this.PC = pc;
this.definingMethod = definingMethod; // can be null
this.codeFixes = new List <ICodeFix>();
this.hasCodeFix = false;
this.hasSufficientAndNecessaryCondition = false;
this.ID = nextID++;
this.Provenance = provenance;
}
public bool AddObjectInvariant(BoxedExpression objinv, Provenance provenance)
{
if (!this.CanAddInvariants())
{
this.AddEntryAssume(objinv, provenance); // record as assume instead
return(false);
}
this.inferredObjectInvariants.Add(new Pair <BoxedExpression, Provenance>(objinv, provenance));
return(true);
}
public static Composition CreateComposition(global::System.Guid ID, int instrument_Id, int key_Id, int timeSignature_Id, Provenance provenance, Audit audit, short staffConfiguration)
{
Composition composition = new Composition();
composition.Id = ID;
composition.Instrument_Id = instrument_Id;
composition.Key_Id = key_Id;
composition.TimeSignature_Id = timeSignature_Id;
if ((provenance == null))
{
throw new global::System.ArgumentNullException("provenance");
}
composition.Provenance = provenance;
if ((audit == null))
{
throw new global::System.ArgumentNullException("audit");
}
composition.Audit = audit;
composition.StaffConfiguration = staffConfiguration;
return composition;
}
public static Provenance CreateProvenance(string titleLine, string fontFamily, string smallFontSize, string largeFontSize)
{
Provenance provenance = new Provenance();
provenance.TitleLine = titleLine;
provenance.FontFamily = fontFamily;
provenance.SmallFontSize = smallFontSize;
provenance.LargeFontSize = largeFontSize;
return provenance;
}
partial void OnProvenanceChanging(Provenance value);
