public void MergePersonRegistration_ExistsWithSource_NewWithouSource_NoUpdate(
[Range(1, 10)] int dummy)
{
using (var dataContext = new PartDataContext())
{
// Insert old record
var oio = Utilities.CreateFakePerson(true);
var pId = new PersonIdentifier()
{
UUID = Guid.NewGuid(), CprNumber = Utilities.RandomCprNumber()
};
CprBroker.Engine.Local.UpdateDatabase.MergePersonRegistration(pId, oio, out personRegistrationId);
var xml = oio.SourceObjectsXml;
oio.SourceObjectsXml = null;
var newRet = CprBroker.Engine.Local.UpdateDatabase.MergePersonRegistration(pId, oio, out personRegistrationId);
Assert.False(newRet);
var dbPersons = dataContext.PersonRegistrations.Where(pr => pr.UUID == pId.UUID).OrderBy(p => p.BrokerUpdateDate).ToArray();
Assert.AreEqual(1, dbPersons.Length);
var tmpElement = System.Xml.Linq.XElement.Parse(xml);
Assert.AreEqual(tmpElement.ToString(), dbPersons[0].SourceObjects.ToString());
}
}
public async Task Handle(GiveTriggerCommand command)
{
var giverId = new PersonIdentifier(command.GiverId);
var receiverId = new PersonIdentifier(command.ReceiverId);
var giverTreasury = await _treasuryRepository.GetByPersonIdentifier(giverId);
var receiverTreasury = await _treasuryRepository.GetByPersonIdentifier(receiverId);
var trigger = new Trigger(
Description: command.Description,
Money: new Money(command.Amount, (Currency)Enum.Parse(typeof(Currency), command.Currency)),
Giver: giverId,
Receiver: receiverId,
MoneyType: (TreasuryMoneyType)Enum.Parse(typeof(TreasuryMoneyType), command.MoneyType));
if (!giverTreasury.CanPayTrigger(trigger))
{
throw new DomainException($"{giverId.Id} cannot pay trigger");
}
giverTreasury.PayTrigger(trigger);
receiverTreasury.ReceiveTrigger(trigger);
await _treasuryRepository.Update(giverTreasury);
await _treasuryRepository.Update(receiverTreasury);
await _triggerRepository.Save(trigger);
}
public async Task <PersonIdentifier> AddPersonIdentifierType(int requestPersonId, int requestIdentifierId, string requestIdentifierValue, int requestUserId)
{
try
{
PersonIdentifier personIdentifier = new PersonIdentifier()
{
PersonId = requestPersonId,
IdentifierId = requestIdentifierId,
IdentifierValue = requestIdentifierValue,
CreatedBy = requestUserId,
CreateDate = DateTime.Now,
DeleteFlag = false
};
await _commonUnitOfWork.Repository <PersonIdentifier>().AddAsync(personIdentifier);
await _commonUnitOfWork.SaveAsync();
return(personIdentifier);
}
catch (Exception e)
{
throw e;
}
}
public static void ImportPersonRegistrationFromXmlFile(string path)
{
var xml = System.IO.File.ReadAllText(path);
var oio = Utilities.Strings.Deserialize <Schemas.Part.RegistreringType1>(xml);
var uuid = new PersonIdentifier()
{
UUID = new Guid(path.Substring(path.LastIndexOf("\\") + 1))
};
if (oio.AttributListe.RegisterOplysning[0].Item is CprBroker.Schemas.Part.CprBorgerType)
{
uuid.CprNumber = (oio.AttributListe.RegisterOplysning[0].Item as Schemas.Part.CprBorgerType).PersonCivilRegistrationIdentifier;
}
else if (oio.AttributListe.RegisterOplysning[0].Item is Schemas.Part.UdenlandskBorgerType)
{
uuid.CprNumber = (oio.AttributListe.RegisterOplysning[0].Item as Schemas.Part.UdenlandskBorgerType).PersonCivilRegistrationReplacementIdentifier;
}
else
{
uuid.CprNumber = (oio.AttributListe.RegisterOplysning[0].Item as Schemas.Part.UkendtBorgerType).PersonCivilRegistrationReplacementIdentifier;
}
UpdatePersonUuid(uuid.CprNumber, uuid.UUID.Value);
UpdatePersonRegistration(uuid, oio);
}
public CprBroker.Schemas.Part.RegistreringType1 Read(PersonIdentifier uuid, CprBroker.Schemas.Part.LaesInputType input, Func <string, Guid> cpr2uuidFunc, out QualityLevel?ql)
{
Schemas.Part.RegistreringType1 ret = null;
var fromRegistrationDate = TidspunktType.ToDateTime(input.RegistreringFraFilter);
var toRegistrationDate = TidspunktType.ToDateTime(input.RegistreringTilFilter);
var fromEffectDate = TidspunktType.ToDateTime(input.VirkningFraFilter);
var ToEffectDate = TidspunktType.ToDateTime(input.VirkningTilFilter);
using (var dataContext = new PartDataContext())
{
Data.Part.PersonRegistration.SetChildLoadOptions(dataContext);
ret =
(
from personReg in dataContext.PersonRegistrations
where personReg.UUID == uuid.UUID
// Filter by registration date
&& (!fromRegistrationDate.HasValue || personReg.RegistrationDate >= fromRegistrationDate) &&
(!toRegistrationDate.HasValue || personReg.RegistrationDate <= toRegistrationDate)
// TODO: Filter by effect date
orderby personReg.RegistrationDate descending, personReg.BrokerUpdateDate descending
select Data.Part.PersonRegistration.ToXmlType(personReg)
).FirstOrDefault();
}
ql = QualityLevel.LocalCache;
return(ret);
}
public async Task <PersonIdentifier> addPersonIdentifiers(int personId, int identifierId, string identifierValue, int userId)
{
try
{
PersonIdentifier personIdentifier = new PersonIdentifier()
{
PersonId = personId,
IdentifierId = identifierId,
IdentifierValue = identifierValue,
DeleteFlag = false,
CreatedBy = userId,
CreateDate = DateTime.Now
};
await _unitOfWork.Repository <PersonIdentifier>().AddAsync(personIdentifier);
await _unitOfWork.SaveAsync();
return(personIdentifier);
}
catch (Exception e)
{
throw e;
}
}
public void CanLoad_4()
{
var identity = new PersonIdentifierBuilder().BuildSLLIdentifier();
var loaded = PersonIdentifier.Load(SLLIdentifier.Oid, identity.ToString(PersonIdentifierFormatOption.None));
Assert.IsInstanceOfType(loaded, typeof(SLLIdentifier));
Print(identity);
}
public void CanLoad_3()
{
var identity = PersonIdentifier.Load(SLLIdentifier.Oid, "991993000033");
Assert.IsInstanceOfType(identity, typeof(SLLIdentifier));
Assert.IsFalse(identity.CanCalculateBirthDate);
Assert.IsFalse(identity.CanCalculateGender);
Print(identity);
}
public int AddPersonIdentifier(PersonIdentifier personIdentifier)
{
using (UnitOfWork unitOfWork = new UnitOfWork(new GreencardContext()))
{
unitOfWork.PersonIdentifierRepository.Add(personIdentifier);
unitOfWork.Complete();
unitOfWork.Dispose();
return(personIdentifier.Id);
}
}
public int UpdatePersondentifier(PersonIdentifier personIdentifier)
{
using (UnitOfWork _unitOfWork = new UnitOfWork(new RecordContext()))
{
_unitOfWork.PersonIdentifierRepository.Update(personIdentifier);
Result = _unitOfWork.Complete();
_unitOfWork.Dispose();
return(Result);
}
}
public async Task <Result <AddPersonIdentifierResponse> > Handle(PersonIdentifierCommand request, CancellationToken cancellationToken)
{
try
{
RegisterPersonService rs = new RegisterPersonService(_unitOfWork);
if (request.PersonId > 0)
{
PersonIdentifier pidm = new PersonIdentifier();
pidm = await rs.GetCurrentPersonIdentifier(request.IdentifierId, request.PersonId);
if (pidm != null)
{
//pidm.DeleteFlag = true;
//var pdm = await Task.Run(() => rs.UpdatePersonIdentifier(pidm));
pidm.IdentifierId = request.IdentifierId;
pidm.IdentifierValue = request.IdentifierValue;
var finalupdate = await Task.Run(() => rs.UpdatePersonIdentifier(pidm));
//var finalupdate = await rs.addPersonIdentifiers(request.PersonId, request.IdentifierId, request.IdentifierValue, request.UserId);
if (finalupdate != null)
{
if (finalupdate.Id > 0)
{
msg += "PersonIdentifier updated successfully";
}
}
}
else
{
var finalIdent = await rs.addPersonIdentifiers(request.PersonId, request.IdentifierId, request.IdentifierValue, request.UserId);
if (finalIdent != null)
{
if (finalIdent.Id > 0)
{
msg += "PersonIdentifierType added successfully";
}
}
}
}
return(Result <AddPersonIdentifierResponse> .Valid(new AddPersonIdentifierResponse()
{
Message = msg
}));
}
catch (Exception e)
{
return(Result <AddPersonIdentifierResponse> .Invalid(e.Message));
}
}
/// <summary>
/// Updates the system database with person registration objects
/// </summary>
/// <param name="personIdentifier"></param>
/// <param name="personRegistraion"></param>
public static void UpdatePersonRegistration(PersonIdentifier personIdentifier, Schemas.Part.RegistreringType1 personRegistraion)
{
// TODO: differentiate the 'true' returned between cases when new data is inserted or just SourceObjects is updated
Guid?personRegistrationId = null;
if (MergePersonRegistration(personIdentifier, personRegistraion, out personRegistrationId))
{
// TODO: move this call to a separate phase in request processing
NotifyPersonRegistrationUpdate(personIdentifier.UUID.Value, personRegistrationId.Value);
}
}
public void CanLoad_2()
{
var identity = PersonIdentifier.Load(ROLIdentifier.Oid, "19810829TB1F");
Assert.IsInstanceOfType(identity, typeof(ROLIdentifier));
Assert.IsFalse(identity.CanCalculateBirthDate);
Assert.IsFalse(identity.CanCalculateGender);
Print(identity);
}
public IViewComponentResult Invoke(PersonIdentifier identifier, DefinitionRegistry registry, bool raw)
{
if (identifier == null)
{
return(Empty());
}
var result = View(GetViewName(registry, identifier.Definition), identifier.Value);
result.ViewData["Raw"] = raw;
return(result);
}
private bool TryCreatePerson()
{
var identifier = new PersonIdentifier(TextBoxIdentifier.Text);
Person temp;
if (RepositoryManager.TryGet(identifier, out temp))
{
MessageBox.Show(this, "Já existe uma pessoa com esse identificador único.", "Identificador ÚNICO repetido ._.", MessageBoxButtons.OK, MessageBoxIcon.Error);
return false;
}
Person = new Person(new PersonIdentifier(TextBoxIdentifier.Text), TextBoxName.Text);
return true;
}
ContainSingleIdentifierValue(
this GenericCollectionAssertions <PersonIdentifierEntity> assertions,
PersonIdentifier identifier,
bool deleted = false
)
{
return(assertions.ContainSingleMarshalledIdentifierValue(
identifier.Definition,
identifier.Definition.CreateXmlMarshaller().MarshallToXml(identifier)
.ToString(SaveOptions.DisableFormatting),
deleted));
}
public bool PutSubscription(PersonIdentifier personIdentifier)
{
if (IPartPerCallDataProviderHelper.CanCallOnline(personIdentifier.CprNumber))
{
IndividualRequestType request = new IndividualRequestType(true, DataType.NoData, decimal.Parse(personIdentifier.CprNumber));
IndividualResponseType response = this.GetResponse(request);
return(true);
}
else
{
return(false);
}
}
public async Task UpdatePersonIdentifierType(PersonIdentifier personIdentifierType)
{
try
{
_commonUnitOfWork.Repository <PersonIdentifier>().Update(personIdentifierType);
await _commonUnitOfWork.SaveAsync();
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
throw e;
}
}
public void MergePersonRegistration_New_True(
[Range(1, 10)] int dummy)
{
using (var dataContext = new PartDataContext())
{
var oio = Utilities.CreateFakePerson();
var pId = new PersonIdentifier()
{
UUID = Guid.NewGuid(), CprNumber = Utilities.RandomCprNumber()
};
var ret = CprBroker.Engine.Local.UpdateDatabase.MergePersonRegistration(pId, oio, out personRegistrationId);
Assert.True(ret);
}
}
public void CanParse_4()
{
var identity = PersonIdentifier.Parse("00749852-BZK0");
Assert.IsInstanceOfType(identity, typeof(NationalReserveNumberIdentifier));
Assert.AreEqual("00749852BZK0", identity.Value);
Assert.AreEqual(NationalReserveNumberIdentifier.Oid, identity.System);
Assert.IsFalse(identity.CanCalculateBirthDate);
Assert.IsFalse(identity.CanCalculateGender);
Print(identity);
}
public void CanLoad_2()
{
var identity = PersonIdentifier.Load(VGRIdentifier.Oid, "19450829K087");
Assert.IsInstanceOfType(identity, typeof(VGRIdentifier));
Assert.IsTrue(identity.CanCalculateBirthDate);
Assert.AreEqual(74, identity.CalculateAge(new DateTime(2020, 1, 1)));
Assert.IsTrue(identity.CanCalculateGender);
Assert.AreEqual(PersonIdentityGender.Female, identity.CalculatedGender);
Print(identity);
}
public void CanLoad_1()
{
var identity = PersonIdentifier.Load(LiVIdentifier.Oid, "19810829-SU3A");
Assert.IsInstanceOfType(identity, typeof(LiVIdentifier));
Assert.IsTrue(identity.CanCalculateBirthDate);
Assert.AreEqual(38, identity.CalculateAge(new DateTime(2020, 1, 1)));
Assert.IsTrue(identity.CanCalculateGender);
Assert.AreEqual(PersonIdentityGender.Male, identity.CalculatedGender);
Print(identity);
}
public void CanLoad_3()
{
var identity = PersonIdentifier.Load(VGRIdentifier.Oid, "19930829X801");
Assert.IsInstanceOfType(identity, typeof(VGRIdentifier));
Assert.IsTrue(identity.CanCalculateBirthDate);
Assert.AreEqual(26, identity.CalculateAge(new DateTime(2020, 1, 1)));
Assert.IsTrue(identity.CanCalculateGender);
Assert.AreEqual(PersonIdentityGender.Unknown, identity.CalculatedGender);
Print(identity);
}
private static PersonRegistration[] MatchPersonRegistration(PersonIdentifier personIdentifier, RegistreringType1 oioRegistration, PartDataContext dataContext, out bool dataChanged)
{
//TODO: Modify this method to allow searching for registrations that have a fake date of Today, these should be matched by content rather than registration date
dataChanged = false;
// Match db registrations by UUID, ActorId and registration date
var existingInDb = (
from dbReg in dataContext.PersonRegistrations
where dbReg.UUID == personIdentifier.UUID &&
dbReg.RegistrationDate == TidspunktType.ToDateTime(oioRegistration.Tidspunkt)
&&
(
(
oioRegistration.AktoerRef == null &&
dbReg.ActorRef == null
)
||
(
oioRegistration.AktoerRef != null &&
dbReg.ActorRef != null &&
oioRegistration.AktoerRef.Item == dbReg.ActorRef.Value &&
(int)oioRegistration.AktoerRef.ItemElementName == dbReg.ActorRef.Type
)
)
select dbReg
).ToArray();
var ret = new List <PersonRegistration>(existingInDb.Length);
// Perform a content match if key match is found
foreach (var dbReg in existingInDb)
{
if (dbReg.Equals(oioRegistration))
{
// Exact content match
ret.Add(dbReg);
}
else
{
// Content match due to bug fix
if (UpdateRules.MatchRule.ApplyRules(dbReg, oioRegistration))
{
dataChanged = true;
ret.Add(dbReg);
}
}
}
return(ret.ToArray());
}
public async Task <Result <GetPersonDetailsResponse> > Handle(GetPersonDetailsCommand request, CancellationToken cancellationToken)
{
try
{
RegisterPersonService rs = new RegisterPersonService(_unitOfWork);
int id = request.PersonId;
if (request.PersonId > 0)
{
persondetail = await rs.GetPerson(id);
personEducation = await rs.GetCurrentPersonEducation(id);
personocc = await rs.GetCurrentOccupation(id);
personmarital = await rs.GetFirstPatientMaritalStatus(id);
personlocation = await rs.GetCurrentPersonLocation(id);
personcontact = await rs.GetCurrentPersonContact(id);
personemerg = await rs.GetCurrentPersonEmergency(id);
pid = await rs.GetCurrentPersonIdentifier(id);
pt = await rs.GetPatientByPersonId(id);
}
_unitOfWork.Dispose();
return(Result <GetPersonDetailsResponse> .Valid(new GetPersonDetailsResponse()
{
personDetail = persondetail,
personEducation = personEducation,
personOccupation = personocc,
personMaritalStatus = personmarital,
personLocation = personlocation,
personContact = personcontact,
PersonEmergencyView = personemerg,
personIdentifier = pid,
patient = pt
}));
}
catch (Exception ex)
{
return(Result <GetPersonDetailsResponse> .Invalid(ex.Message));
}
}
public override RegistreringType1 RunMainMethod(IPartReadDataProvider prov)
{
this.PersonIdentifier = UuidToPersonIdentifier(Input.UUID);
if (this.PersonIdentifier != null)
{
return(prov.Read
(
this.PersonIdentifier,
Input,
(cprNumber) => CprToUuid(cprNumber),
out QualityLevel
));
}
return(null);
}
public void StringMarshaller_CorrectlyMarshalsValue(
IDefinitionType definitionType, object value, string expectedText)
{
var identifier = new PersonIdentifier(
new SimpleIdentifierValue(value),
new IdentifierDefinition("Identifier", definitionType));
var marshaller = CreateMarshallerFor(identifier.Definition);
var marshalledValue = marshaller.MarshallToXml(identifier);
Assert.Equal(
new XElement("identifier", expectedText).ToString(SaveOptions.DisableFormatting),
marshalledValue.ToString(SaveOptions.DisableFormatting));
}
public void MergePersonRegistration_FromExisting_False(
[Random(0, 99, 10)] int index)
{
using (var dataContext = new PartDataContext())
{
var dbPerson = dataContext.PersonRegistrations.Where(pr => pr.Person != null).Skip(index).First();
var oio = PersonRegistration.ToXmlType(dbPerson);
var pId = new PersonIdentifier()
{
UUID = dbPerson.UUID, CprNumber = dbPerson.Person.UserInterfaceKeyText
};
var ret = CprBroker.Engine.Local.UpdateDatabase.MergePersonRegistration(pId, oio, out personRegistrationId);
Assert.False(ret);
}
}
public void CanParse_2()
{
var identity = PersonIdentifier.Parse("25780404-KHD5");
Assert.IsInstanceOfType(identity, typeof(NationalReserveNumberIdentifier));
Assert.AreEqual("25780404KHD5", identity.Value);
Assert.AreEqual(NationalReserveNumberIdentifier.Oid, identity.System);
Assert.IsTrue(identity.CanCalculateBirthDate);
Assert.AreEqual(41, identity.CalculateAge(new DateTime(2020, 1, 1)));
Assert.IsFalse(identity.CanCalculateGender);
Print(identity);
}
public void CanParse_3()
{
var identity = PersonIdentifier.Parse("00342145-BZ31");
Assert.IsInstanceOfType(identity, typeof(NationalReserveNumberIdentifier));
Assert.AreEqual("00342145BZ31", identity.Value);
Assert.AreEqual(NationalReserveNumberIdentifier.Oid, identity.System);
Assert.IsFalse(identity.CanCalculateBirthDate);
Assert.IsTrue(identity.CanCalculateGender);
Assert.AreEqual(PersonIdentityGender.Male, identity.CalculatedGender);
Print(identity);
}
public static Person EnsurePersonExists(PartDataContext dataContext, PersonIdentifier personIdentifier)
{
var dbPerson = (from dbPers in dataContext.Persons
where dbPers.UUID == personIdentifier.UUID
select dbPers).FirstOrDefault();
if (dbPerson == null)
{
dbPerson = new CprBroker.Data.Part.Person()
{
UUID = personIdentifier.UUID.Value,
UserInterfaceKeyText = personIdentifier.CprNumber
};
dataContext.Persons.InsertOnSubmit(dbPerson);
}
return(dbPerson);
}
public static void SaveDayOfWeekDismisses(PersonIdentifier id, IEnumerable<DayOfWeekDismiss> dismisses)
{
if (id == null)
throw new ArgumentNullException(nameof(id));
if (dismisses == null)
throw new ArgumentNullException(nameof(dismisses));
if (!GetPersonRepository().Contains(id))
throw new ArgumentException("Identifier not found in PersonRepository.");
var repository = GetDayOfWeekDismissRepository();
var dismissCollection = new DayOfWeekDismissCollection(id, dismisses);
repository.Save(dismissCollection);
repository.FlushRepositoryToDisk();
}
public static bool TryGet(PersonIdentifier id, out TemporaryDismissCollection entity) => TemporaryDismissRepository.TryGet(id, out entity);
public static DayOfWeekDismissCollection GetDayOfWeekDismisses(PersonIdentifier id)
{
if (id == null)
throw new ArgumentNullException(nameof(id));
if (!GetPersonRepository().Contains(id))
throw new ArgumentException("Identifier not found in PersonRepository.");
var repository = GetDayOfWeekDismissRepository();
DayOfWeekDismissCollection dismisses;
if (repository.TryGet(id, out dismisses))
return dismisses;
else
return new DayOfWeekDismissCollection(id, Array.Empty<DayOfWeekDismiss>());
}
public static bool TryGet(PersonIdentifier id, out DayOfWeekDismissCollection entity) => DayOfWeekDismissRepository.TryGet(id, out entity);
public static bool DeletePerson(PersonIdentifier id)
{
var deleted = PersonRepository.Delete(id);
if (deleted)
{
TemporaryDismissRepository.Delete(id);
DayOfWeekDismissRepository.Delete(id);
}
return deleted;
}
public static bool DeleteTemporaryDismisses(PersonIdentifier id) => TemporaryDismissRepository.Delete(id);
public static bool DeleteDayOfWeekDismisses(PersonIdentifier id) => DayOfWeekDismissRepository.Delete(id);
public static bool TryGet(PersonIdentifier id, out Person entity) => PersonRepository.TryGet(id, out entity);
