public override string[] LoadCprNumbers()
{
using (var dataContext = new DPRDataContext(OtherConnectionString))
{
return(dataContext.PersonTotals.OrderBy(pt => pt.PNR).Select(pt => pt.PNR.ToString()).ToArray());
}
}
public override string[] LoadCprNumbers()
{
using (var dataContext = new DPRDataContext(OtherConnectionString))
{
return(dataContext.PersonTotals.Select(t => t.PNR).ToArray().Select(pnr => pnr.ToPnrDecimalString()).ToArray());
}
}
/// <summary>
/// Ensures that the DPR database contains the given person
/// </summary>
/// <param name="cprNumber"></param>
protected void EnsurePersonDataExists(string cprNumber)
{
if (!this.DisableDiversion)
{
decimal cprNum = Convert.ToDecimal(cprNumber);
using (DPRDataContext dataContext = new DPRDataContext(ConnectionString))
{
var exists = (from personTotal in dataContext.PersonTotals
select personTotal.PNR).Contains(cprNum);
if (exists)
{
Engine.Local.Admin.AddNewLog(System.Diagnostics.TraceEventType.Information, "EnsurePersonDataExists", string.Format("PNR {0} Exists in DPR, DPR Diversion not called", cprNumber), null, null);
}
else
{
Engine.Local.Admin.AddNewLog(System.Diagnostics.TraceEventType.Information, "EnsurePersonDataExists", string.Format("Calling DPR Diversion : {0}", cprNumber), null, null);
CallDiversion(InquiryType.DataUpdatedAutomaticallyFromCpr, DetailType.ExtendedData, cprNumber);
}
}
}
else
{
Engine.Local.Admin.AddNewLog(System.Diagnostics.TraceEventType.Information, "EnsurePersonDataExists", string.Format("DPR Diversion is disabled: {0}", cprNumber), null, null);
}
}
public void ToRegistreingType1_NoErrors(decimal pnr)
{
using (var dataContext = new DPRDataContext(ConnectionString))
{
var pInfo = PersonInfo.GetPersonInfo(dataContext, pnr);
pInfo.ToRelationListeType(GetUuid, dataContext);
}
}
public override void ProcessPerson(string pnr)
{
using (var dataContext = new DPRDataContext(OtherConnectionString))
{
{
var db = PersonInfo.GetPersonInfo(dataContext, decimal.Parse(pnr));
var ret = db.ToRegisteringType1(cpr2uuidFunc, dataContext);
}
}
}
public static PersonInfo GetPersonInfo(DPRDataContext dataContext, decimal pnr)
{
var personTotal = dataContext.PersonTotals.Where(pt => pt.PNR == pnr).FirstOrDefault();
if (personTotal != null)
{
return(personTotal.ToPersonInfo());
}
return(null);
}
public override string[] LoadCprNumbers()
{
using (DPRDataContext dataContext = new DPRDataContext(OtherConnectionString))
{
var all = dataContext.PersonTotals.Select(t => t.PNR).ToArray().Select(p => p.ToPnrDecimalString()).ToList();
Random r = new Random();
var ret = new List <string>();
for (int i = 0; i < 50; i++)
{
int index = r.Next(0, all.Count);
ret.Add(all[index]);
all.RemoveAt(index);
}
return(ret.ToArray());
}
}
public void GetPersonInfo_Normal_EqualsPersonInfoExpression(decimal pnr)
{
LogText("sarted");
using (var dataContext = new DPRDataContext(OtherConnectionString))
{
// UUID mapping
var map = new Dictionary <string, Guid>();
Func <string, Guid> func = (string cpr) =>
{
if (!map.ContainsKey(cpr))
{
map[cpr] = Guid.NewGuid();
}
return(map[cpr]);
};
var simplifiedPersonInfo = PersonInfo.GetPersonInfo(dataContext, pnr);
LogText("GetPersonInfo()");
Assert.NotNull(simplifiedPersonInfo, "simplifiedPersonInfo");
LogText("Assert");
var simplifiedPersonRegistration = simplifiedPersonInfo.ToRegisteringType1(func, dataContext);
LogText("Converted");
Assert.NotNull(simplifiedPersonRegistration, "simplifiedPersonRegistration");
LogText("Assert");
var simplifiedXml = CprBroker.Utilities.Strings.SerializeObject(simplifiedPersonRegistration);
LogText("Serialization");
WriteObject(pnr.ToDecimalString(), simplifiedXml);
LogText("WriteToFile");
var expressionPersonInfo = PersonInfo.PersonInfoExpression.Compile()(dataContext).Where(pi => pi.PersonTotal.PNR == pnr).FirstOrDefault();
LogText("Expression retrieval");
if (expressionPersonInfo != null)
{
var expressionPersonRegistration = expressionPersonInfo.ToRegisteringType1(func, dataContext);
LogText("Conversion");
Assert.NotNull(expressionPersonRegistration, "expressionPersonRegistration");
LogText("Assert");
var expressionXml = CprBroker.Utilities.Strings.SerializeObject(expressionPersonRegistration);
LogText("Serialization");
WriteObject(pnr.ToDecimalString() + "-expr", expressionXml);
LogText("WriteToFile");
Assert.AreEqual(expressionXml, simplifiedXml);
LogText("Assert");
}
}
LogText("Done");
}
public decimal[] AllCprNumbers()
{
int maxCount = 100;
using (DPRDataContext dataContext = new DPRDataContext(ConnectionString()))
{
var all = new List <decimal>(dataContext.PersonTotals.Select(t => t.PNR).ToArray());
var r = new Random();
var ret = new List <decimal>();
for (int i = 0; i < maxCount; i++)
{
int index = r.Next(0, all.Count);
ret.Add(all[index]);
all.RemoveAt(index);
}
return(ret.OrderBy(pnr => pnr).ToArray());
}
}
public override void ProcessPerson(string pnr)
{
var decimalPnr = decimal.Parse(pnr);
using (DPRDataContext dataContext = new DPRDataContext(OtherConnectionString))
{
var expressionPersonInfo = PersonInfo.GetPersonInfo(dataContext, decimalPnr);
// UUID mapping
var map = new Dictionary <string, Guid>();
Func <string, Guid> func = (string cpr) =>
{
if (!map.ContainsKey(cpr))
{
map[cpr] = Guid.NewGuid();
}
return(map[cpr]);
};
var xmlObj = expressionPersonInfo.ToRegisteringType1(func, dataContext);
WriteObject(pnr, xmlObj);
}
}
public RegistreringType1 Read(PersonIdentifier uuid, LaesInputType input, Func <string, Guid> cpr2uuidFunc, out QualityLevel?ql)
{
CprBroker.Schemas.Part.RegistreringType1 ret = null;
if (IPartPerCallDataProviderHelper.CanCallOnline(uuid.CprNumber))
{
EnsurePersonDataExists(uuid.CprNumber);
}
using (var dataContext = new DPRDataContext(this.ConnectionString))
{
var db = PersonInfo.GetPersonInfo(dataContext, decimal.Parse(uuid.CprNumber));
if (db != null)
{
UuidCache cache = new UuidCache();
cache.FillCache(db.RelatedPnrs);
ret = db.ToRegisteringType1(cache.GetUuid, dataContext);
}
}
ql = QualityLevel.DataProvider;
return(ret);
}
public override string[] LoadCprNumbers()
{
Utilities.UpdateConnectionString(this.BrokerConnectionString);
BrokerContext.Initialize(this.ApplicationToken, "");
brokerContext = BrokerContext.Current;
string[] ret = null;
if (string.IsNullOrEmpty(SourceFile))
{
using (var dataContext = new DPRDataContext(OtherConnectionString))
{
ret = dataContext.PersonTotals.Select(t => t.PNR).ToArray().Select(pnr => pnr.ToPnrDecimalString()).ToArray();
}
}
else
{
ret = Utilities.LoadCprNumbersOneByOne(SourceFile);
}
UuidCache.PreLoadExistingMappings();
return(ret);
}
public override void ProcessPerson(string pnr)
{
DateTime startTime = DateTime.Now;
decimal decimalPnr = decimal.Parse(pnr);
using (DPRDataContext dataContext = new DPRDataContext(OtherConnectionString))
{
PersonInfo personInfo = null;
if (UseSimple)
{
Log("Simple");
personInfo = PersonInfo.GetPersonInfo(dataContext, decimalPnr);
SimpleTime += DateTime.Now - startTime;
}
else
{
Log("Expression");
personInfo = PersonInfo.PersonInfoExpression.Compile()(dataContext).Where(pi => pi.PersonTotal.PNR == decimalPnr).FirstOrDefault();
ExpressionTime += DateTime.Now - startTime;
}
}
UseSimple = !UseSimple;
}
public override void ProcessPerson(string pnr)
{
BrokerContext.Current = brokerContext;
try
{
CprBroker.Engine.Local.Admin.LogFormattedSuccess("Converting person <{0}> from DPR", pnr);
using (var dprDataContext = new DPRDataContext(OtherConnectionString))
{
var pId = new PersonIdentifier()
{
CprNumber = pnr, UUID = UuidCache.GetUuid(pnr)
};
var personInfo = PersonInfo.GetPersonInfo(dprDataContext, decimal.Parse(pnr));
var reg = personInfo.ToRegisteringType1(UuidCache.GetUuid, dprDataContext);
UpdateDatabase.UpdatePersonRegistration(pId, reg);
}
}
catch (Exception ex)
{
Admin.LogException(ex);
throw ex;
}
}
public void PersonInfoExpressionEqualsGetPersonInfo(
[ValueSource("AllCprNumbers")] decimal cprNumber)
{
var prov = new DprDatabaseDataProviderStub();
var dataContext = new DPRDataContext(ConnectionString());
DateTime effectDate = DateTime.Today;
var expressionDb =
(
from personInfo in PersonInfo.PersonInfoExpression.Compile()(dataContext)
where personInfo.PersonTotal.PNR == cprNumber
select personInfo
).First();
var expressionObj = expressionDb.ToRegisteringType1(UuidMap.CprStringToUuid, dataContext);
var expressionXml = CprBroker.Utilities.Strings.SerializeObject(expressionObj);
var methodDb = PersonInfo.GetPersonInfo(dataContext, cprNumber);
var methodObj = methodDb.ToRegisteringType1(UuidMap.CprStringToUuid, dataContext);
var methodXml = CprBroker.Utilities.Strings.SerializeObject(methodObj);
Assert.AreEqual(expressionXml, methodXml);
}
public bool PutSubscription(PersonIdentifier personIdentifier)
{
if (!this.DisableDiversion)
{
if (IPartPerCallDataProviderHelper.CanCallOnline(personIdentifier.CprNumber))
{
decimal cprNum = Convert.ToDecimal(personIdentifier.CprNumber);
using (DPRDataContext dataContext = new DPRDataContext(ConnectionString))
{
var exists = (from personTotal in dataContext.PersonTotals
select personTotal.PNR).Contains(cprNum);
if (exists)
{
Engine.Local.Admin.AddNewLog(System.Diagnostics.TraceEventType.Information, "PutSubscription", string.Format("PNR {0} Exists in DPR, DPR Diversion not called", personIdentifier.CprNumber), null, null);
}
else
{
Engine.Local.Admin.AddNewLog(System.Diagnostics.TraceEventType.Information, "PutSubscription", string.Format("Calling DPR Diversion : {0}", personIdentifier.CprNumber), null, null);
CallDiversion(InquiryType.DataUpdatedAutomaticallyFromCpr, DetailType.MasterData, personIdentifier.CprNumber);
}
return(true);
}
}
else
{
Engine.Local.Admin.AddNewLog(System.Diagnostics.TraceEventType.Information, "PutSubscription", string.Format("Invalid PNR: {0}", personIdentifier.CprNumber), null, null);
return(false);
}
}
else
{
Engine.Local.Admin.AddNewLog(System.Diagnostics.TraceEventType.Information, "PutSubscription", string.Format("DPR Diversion is disabled: {0}", personIdentifier.CprNumber), null, null);
return(false);
}
}
public RelationListeType ToRelationListeType(Func <string, Guid> cpr2uuidConverter, DPRDataContext dataContext)
{
Func <decimal, Guid> cpr2uuidFunc = (cpr) => cpr2uuidConverter(cpr.ToPnrDecimalString());
var ret = new RelationListeType();
// Now fill the relations
var fatherPnr = Utilities.ToParentPnr(this.PersonTotal.FatherPersonalOrBirthdate);
if (fatherPnr.HasValue)
{
ret.Fader = new PersonRelationType[]
{
PersonRelationType.Create(
cpr2uuidFunc(fatherPnr.Value),
null,
null
)
};
}
var motherPnr = Utilities.ToParentPnr(this.PersonTotal.MotherPersonalOrBirthDate);
if (motherPnr.HasValue)
{
ret.Moder = new PersonRelationType[]
{
PersonRelationType.Create
(cpr2uuidFunc(motherPnr.Value),
null,
null
)
};
}
// Fill children (including adults)
ret.Boern = Child.ToPersonFlerRelationTypeArray(Children, cpr2uuidFunc);
// TODO : Fill custody children
ret.Foraeldremyndighedsboern = null;
// Normal spouse(s)
ret.Aegtefaelle = CivilStatusWrapper.ToSpouses(null, this.CivilStatesAsInterface, cpr2uuidConverter);
// Registered partner(s)
ret.RegistreretPartner = CivilStatusWrapper.ToRegisteredPartners(null, this.CivilStatesAsInterface, cpr2uuidConverter);
//TODO: Has legal authority on
ret.RetligHandleevneVaergeForPersonen = null;
//TODO: People who have legal authority on this person
ret.Foraeldremyndighedsindehaver = null;
return(ret);
}
public RegistreringType1 ToRegisteringType1(Func <string, Guid> cpr2uuidConverter, DPRDataContext dataContext)
{
RegistreringType1 ret = new RegistreringType1()
{
AttributListe = ToAttributListeType(),
TilstandListe = ToTilstandListeType(),
RelationListe = ToRelationListeType(cpr2uuidConverter, dataContext),
AktoerRef = Constants.Actor,
CommentText = Constants.CommentText,
LivscyklusKode = LivscyklusKodeType.Rettet,
Tidspunkt = TidspunktType.Create(this.RegistrationDate),
Virkning = null
};
ret.CalculateVirkning();
return(ret);
}
