public async Task <IEnumerable <ExternalData> > GetExternalUnitData(int unitId)
{
await SignIn(unitId);
var externalDataList = new List <ExternalData>();
var subEntities = await _unimicroClient.GetSubEntities();
foreach (var subentity in subEntities.Where(se => !se.Deleted))
{
var externalData = new ExternalData();
externalData.Identifiers.Add(new Identifier {
Entity = unimicro.IdentifierEntity.SubEntity.ToString(), Property = unimicro.IdentifierProperty.Id.ToString(), Value = subentity.Id.ToString()
});
externalData.Identifiers.Add(new Identifier {
Entity = unimicro.IdentifierEntity.SubEntity.ToString(), Property = unimicro.IdentifierProperty.OrganizationNumber.ToString(), Value = subentity?.OrgNumber
});
externalData.DataSet.Add(new Data {
Code = PropertyName.Name.ToString(), Value = subentity?.BusinessRelationInfo?.Name
});
externalData.DataSet.Add(new Data {
Code = PropertyName.OrganizationNumber.ToString(), Value = subentity.OrgNumber
});
externalDataList.Add(externalData);
}
RemoveNullData(externalDataList);
return(externalDataList);
}
public async Task <IEnumerable <ExternalData> > GetExternalReportees()
{
var externalDataList = new List <ExternalData>();
var reportees = await _altinnClient.GetReportees();
foreach (var reportee in reportees)
{
var externalData = new ExternalData();
externalData.Identifiers.Add(new Identifier {
Entity = IdentifierEntity.Reportee.ToString(), Property = IdentifierProperty.ReporteeId.ToString(), Value = reportee.ReporteeId
});
externalData.DataSet.Add(new Data {
Code = PropertyName.Name.ToString(), Value = reportee.Name
});
externalData.DataSet.Add(new Data {
Code = PropertyName.Type.ToString(), Value = reportee.Type
});
externalData.DataSet.Add(new Data {
Code = PropertyName.Status.ToString(), Value = reportee.Status
});
externalData.DataSet.Add(new Data {
Code = PropertyName.OrganizationNumber.ToString(), Value = reportee.OrganizationNumber
});
externalDataList.Add(externalData);
}
RemoveNullData(externalDataList);
return(externalDataList);
}
private void CheckIfIsSupported(ExternalData externalData, unimicro.WorkRelation wr, unimicro.Employment employment, unimicro.Worker worker, unimicro.Employee employee)
{
externalData.ValidForUse = true;
var supportedWorkPercent = 100d;
var hoursInAWeek = 37.5d;
var minutesInAnOur = 60.0d;
var minutesInANormalWeek = (int)(hoursInAWeek * minutesInAnOur);
if (wr == null)
{
externalData.ValidForUse = false;
externalData.NotValidReasons.Add($"WorkRelation is not found");
externalData.NotValidReasonsEnums.Add(((int)EmployeeError.WorkrelationMissingError).ToString());
}
else
{
if (wr.WorkPercentage != supportedWorkPercent)
{
externalData.ValidForUse = false;
externalData.NotValidReasons.Add("Only a workpercentage of 100 is supported on workrelation");
externalData.NotValidReasonsEnums.Add(((int)EmployeeError.WorkPercentageError).ToString());
}
if (wr.WorkProfile?.MinutesPerWeek != minutesInANormalWeek)
{
externalData.ValidForUse = false;
externalData.NotValidReasons.Add($"Only a normal week of {minutesInANormalWeek} minutes a week is supported");
externalData.NotValidReasonsEnums.Add(((int)EmployeeError.HoursOfWeekError).ToString());
}
}
if (employment == null)
{
externalData.ValidForUse = false;
externalData.NotValidReasons.Add($"Employment is not found");
externalData.NotValidReasonsEnums.Add(((int)EmployeeError.EmploymentMissingError).ToString());
}
else
{
if (employment.WorkPercent != supportedWorkPercent)
{
externalData.ValidForUse = false;
externalData.NotValidReasons.Add("Only a workpercentage of 100 is supported on employement");
externalData.NotValidReasonsEnums.Add(((int)EmployeeError.WorkPercentageError).ToString());
}
if (employment?.HoursPerWeek != hoursInAWeek)
{
externalData.ValidForUse = false;
externalData.NotValidReasons.Add($"Only a normal week of {hoursInAWeek} hours a week is supported");
externalData.NotValidReasonsEnums.Add(((int)EmployeeError.HoursOfWeekError).ToString());
}
}
if (worker == null)
{
externalData.ValidForUse = false;
externalData.NotValidReasons.Add($"Worker related to Employee is not found");
externalData.NotValidReasonsEnums.Add(((int)EmployeeError.WorkerMissingError).ToString());
}
}
public ExternalData ReadData()
{
ExternalData res = new ExternalData();
if (readCompetition)
{
var competition = competitionProvider.GetData(string.Format($"{API_URL}{COMPETITION_URL}{startId}/")) as CompetitionExt;
res.Competition = competition;
if (readTeams)
{
var teams = teamsProvider.GetData(competition._links.Teams.Href) as TeamsList;
competition.Teams = teams;
if (readPlayers)
{
foreach (var team in teams.Teams)
{
var players = playersProvider.GetData(team._links.Players.Href) as PlayersList;
team.Players = players;
}
}
}
if (readGames)
{
var games = gamesProvider.GetData(competition._links.Fixtures.Href) as FixturesList;
competition.Fixtures = games;
}
}
return(res);
}
/// <summary>
/// Starts this instance.
/// </summary>
internal void Start()
{
_gameState = GUIStates.Loading;
_guiLevel = 1;
StartCoroutine(ExternalData.LoadData());
}
public async Task <IEnumerable <ExternalData> > GetExternalAbsenceCodeData(int unitId)
{
await SignIn(unitId);
var externalDataList = new List <ExternalData>();
var workTypes = _unimicroClient.GetWorkTypes().Result.Where(wt => !wt.Deleted);
foreach (var workType in workTypes)
{
var externalData = new ExternalData();
externalData.Identifiers.Add(new Identifier {
Entity = unimicro.IdentifierEntity.WorkType.ToString(), Property = unimicro.IdentifierProperty.Id.ToString(), Value = workType.Id.ToString()
});
externalData.DataSet.Add(new Data {
Code = PropertyName.Name.ToString(), Value = workType.Name
});
externalDataList.Add(externalData);
}
RemoveNullData(externalDataList);
AddExternalLeaveTypes(externalDataList);
return(externalDataList);
}
public virtual void AddTestResultDetail(
TestResultDetailTypes detailType,
string detail)
{
if (TmxHelper.TestCaseStarted == DateTime.MinValue)
{
TmxHelper.TestCaseStarted = DateTime.Now;
}
DetailType = detailType;
switch (detailType)
{
case TestResultDetailTypes.Screenshot:
ScreenshotDetail = detail;
break;
// case TestResultDetailTypes.ErrorRecord:
//
// break;
case TestResultDetailTypes.Comment:
TextDetail = detail;
break;
case TestResultDetailTypes.Log:
LogDetail = detail;
break;
case TestResultDetailTypes.ExternalData:
ExternalData.Add(detail);
break;
default:
throw new Exception("Invalid value for TestResultDetailTypes");
}
}
private void DoRefreshInternal()
{
var businessList = Database.GetBusinessLineList(null);
List <Task> tasks = new List <Task>();
foreach (var biz in businessList)
{
foreach (var ln in biz.Line)
{
log.DebugFormat("Creating cache task for business {0}, line {1}", biz.Id, ln.Id);
tasks.Add(
new Task(() =>
{
var items = ExternalData.Fetch(biz.Id, ln.Id, 2);
if (items.Count == 0)
{
log.DebugFormat("Nothing found in external data for line {0}", ln.Id);
}
else
{
var lastLineQueueId = items.OrderByDescending(i => i.QueueId).First().QueueId;
var lastStoredLineQueueId = Database.GetLastLineQueueId(ln.Id);
if (!lastStoredLineQueueId.HasValue)
{
log.DebugFormat("Nothing in database for line {0}, going to merge {1} items", ln.Id, items.Count);
var dbItems = Mapper.Map <IEnumerable <Models.Shared.DataItem>, IEnumerable <AdapterDb.DataItem> >(items).ToList();
Database.MergeDataItems(dbItems);
log.DebugFormat("Line {0} merged", ln.Id);
}
else if (lastLineQueueId.Value > lastStoredLineQueueId.Value)
{
log.DebugFormat("External data has new items for line {0}, going to merge {1} items", ln.Id, items.Count);
var dbItems = Mapper.Map <IEnumerable <Models.Shared.DataItem>, IEnumerable <AdapterDb.DataItem> >(items).ToList();
Database.MergeDataItems(dbItems);
log.DebugFormat("Line {0} merged", ln.Id);
}
else if (lastLineQueueId.Value == lastStoredLineQueueId.Value)
{
log.DebugFormat("Nothing to refresh for line {0}, last queue id: {1}, skip refresh from db", ln.Id, lastQueueId);
return;
}
else if (lastLineQueueId.Value < lastStoredLineQueueId.Value)
{
log.ErrorFormat("Line {0}, last external data queue id ({1}) is older than last database queue id ({2})", ln.Id, lastLineQueueId.Value, lastStoredLineQueueId.Value);
}
}
SetItemList(biz.Id, ln.Id, items);
log.DebugFormat("Finished cache task for business {0}, line {1}", biz.Id, ln.Id);
}));
}
}
}
private void ImportCsv(string file)
{
try
{
string[] lines = File.ReadAllLines(file);
Data = new ObservableCollection <ExternalData>();
foreach (string line in lines)
{
ExternalData externalData = new ExternalData();
var data = line.Split(',');
if (data.Length > 0)
{
externalData.Row1 = data[0];
}
if (data.Length > 1)
{
externalData.Row2 = data[1];
}
if (data.Length > 2)
{
externalData.Row3 = data[2];
}
if (data.Length > 3)
{
externalData.Row4 = data[3];
}
if (data.Length > 4)
{
externalData.Row5 = data[4];
}
if (data.Length > 5)
{
externalData.Row6 = data[5];
}
if (data.Length > 6)
{
externalData.Row7 = data[6];
}
if (data.Length > 7)
{
externalData.Row8 = data[7];
}
if (data.Length > 8)
{
externalData.Row9 = data[8];
}
if (data.Length > 9)
{
externalData.FileName = data[9];
}
Data.Add(externalData);
}
}
catch (Exception ex)
{
Log.Error("Error import file", ex);
}
}
public void Execute(IJobExecutionContext context)
{
log.Debug("executing job: cache refresh...");
try
{
var businessList = Database.GetBusinessLineList(null);
List <Task> tasks = new List <Task>();
foreach (var biz in businessList)
{
foreach (var ln in biz.Line)
{
log.DebugFormat("starting cache task for business {0}, line {1}...", biz.Id, ln.Id);
Task t = new Task(() =>
{
var items = ExternalData.Fetch(biz.Id, ln.Id, 2);
CacheEngine.Instance.SetItemList(biz.Id, ln.Id, items);
log.DebugFormat("finished cache task for business {0}, line {1}", biz.Id, ln.Id);
});
tasks.Add(t);
}
}
Task ending = Task.WhenAll(tasks);
try
{
ending.Wait();
CacheEngine.Instance.State = CacheEngineState.Ready;
}
catch (Exception ex)
{
log.ErrorFormat("cache tasks failed: {0}", ex);
}
if (ending.Status == TaskStatus.RanToCompletion)
{
CacheEngine.Instance.State = CacheEngineState.Ready;
}
else if (ending.Status == TaskStatus.Faulted)
{
CacheEngine.Instance.State = CacheEngineState.Invalid;
}
}
catch (Exception ex)
{
log.ErrorFormat("job failed: {0}", ex);
}
log.Debug("executed job: cache refresh");
}
public NumberInputNode() : base(new ExternalNumberOperator())
{
//Source.Data = new PNumber(15);
var d = new ExternalNumber(15);
var ext = new ExternalData(d);
Source.ConnectToData(new List <ExternalData>()
{
ext
});
d.RequestChange(15);
}
private void FilterDynamicData()
{
string[] sSolutionTypesFiltered = oSolution_Types.Options.Where(oFilter => oFilter.Available && oFilter.Filtered).Select(oFilter => oFilter.Code).ToArray();
string[] sCustodians = oCustodians.Options.Where(oFilter => oFilter.Available && oFilter.Filtered).Select(oFilter => oFilter.Code).ToArray();
if (sSolutionTypesFiltered.Count() == 0 && sCustodians.Count() == 0)
{
oFilteredServiceResultData = ExternalData;
}
else
{
oFilteredServiceResultData = ExternalData.AsParallel().Where(oExternalResult => sCustodians.Contains(oExternalResult.CustodianCode) || sSolutionTypesFiltered.Contains(oExternalResult.SolutionTypeCode)).ToArray();
}
}
public void ReadFullCompetitionFromFile(int competitionId)
{
string fileName = ExternalDataTools.MapIdToFileName(competitionId);
string path = $@"{env.ContentRootPath}/AppData/{fileName}.json";
ExternalData data = new ExternalData();
using (StreamReader sr = new StreamReader(path))
{
JsonSerializer serializer = new JsonSerializer();
data = (ExternalData)serializer.Deserialize(sr, typeof(ExternalData));
}
externalDataSaver.Create(data);
}
/// <summary>
/// Validate the Content for this Related Document
/// </summary>
/// <param name="path">The path to this object as a string</param>
/// <param name="messages">the validation messages, these may be added to within this method</param>
void IDocumentDetails.Validate(string path, List <ValidationMessage> messages)
{
var vb = new ValidationBuilder(path, messages);
if (vb.ArgumentRequiredCheck("ExternalData", ExternalData))
{
ExternalData.Validate(path + "ExternalData", messages);
}
if (vb.ArgumentRequiredCheck("DocumentProvenance", DocumentProvenance))
{
DocumentProvenance.Validate(path + "DocumentProvenance", messages);
}
}
public IHttpActionResult ExternalLogin(string provider, string error = null)
{
if (error != null)
{
return(BadRequest(Uri.EscapeDataString(error)));
}
if (!User.Identity.IsAuthenticated)
{
return(new ExternalAuthenticationChallengeResult(provider, this));
}
string redirectUri;
bool isValidUri = CommonValidations.TryParseRedirectUri(Request, out redirectUri);
if (isValidUri == false)
{
if (string.IsNullOrEmpty(redirectUri))
{
return(BadRequest("Invalid redirect URI(redirect_uri)."));
}
return(BadRequest(redirectUri));
}
try
{
ExternalData externalLoginData = new ExternalData(User.Identity as ClaimsIdentity);
if (externalLoginData == null)
{
return(InternalServerError());
}
if (externalLoginData.LoginProvider != provider)
{
ExternalProvider.SignOut(Request, DefaultAuthenticationTypes.ExternalCookie);
return(new ExternalAuthenticationChallengeResult(provider, this));
}
externalLoginData.LocalBearerToken = GenerateLocalAccessTokenResponse(User.Identity as ClaimsIdentity);
redirectUri = ExternalProvider.GetCompleteRedirectUri(redirectUri, externalLoginData);
return(Redirect(redirectUri));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
private DataTable GetCustomFieldsTable()
{
if (!ExternalData.ContainsKey("CustomFieldDataSet"))
{
throw new ExternalDataRequiredException("Provide a CustomFieldDataSet object as external data for ProjectCustomFieldsDataTableMappingObject")
{
DataKeyName = "CustomFieldDataSet"
};
}
var customFieldsDs = ExternalData["CustomFieldDataSet"] as DataSet;
var customFieldsTable = customFieldsDs.Tables["CustomFields"];
return(customFieldsTable);
}
public async Task <IEnumerable <EntityMatch> > MatchUnitData(int unitId, int[] ids)
{
var externalUnits = await _externalDataService.GetExternalUnitData(unitId);
var externalUnitsMapped = _mapper.Map <IEnumerable <ExternalData> >(externalUnits);
var internalUnits = await _unitService.SearchUnits(new commonContracts.SearchQueryUnit {
UnitIds = ids.ToList()
});
var factorRank = 10.0 / 2.0;
var matchedData = new List <EntityMatch>();
foreach (var unit in internalUnits)
{
var bestFactor = 0.0;
var bestMatch = new ExternalData();
var matchEntity = new EntityMatch()
{
EntityId = unit.Id,
EntityMap = EntityType.Unit.ToString(),
};
foreach (var externalEmployee in externalUnitsMapped)
{
var factor = 0.0;
if (externalEmployee.DataSet.Any(x => x.Value.Contains(unit.Name)))
{
factor += factorRank;
}
if (!string.IsNullOrWhiteSpace(unit.BusinessOrganizationNumber) && externalEmployee.DataSet.Any(x => x.Value.Contains(unit.BusinessOrganizationNumber)))
{
factor += factorRank;
}
if (factor > bestFactor)
{
bestFactor = factor;
bestMatch = externalEmployee;
}
}
if (bestFactor != 0)
{
matchEntity.ExternalData = bestMatch;
matchEntity.MatchFactor = bestFactor;
}
matchedData.Add(matchEntity);
}
return(matchedData);
}
/// <summary>
/// Creates a Related Document.
/// </summary>
/// <returns>RelatedDocument</returns>
public static RelatedDocument CreateRelatedDocument(Boolean mandatorySectionsOnly)
{
RelatedDocument relatedDocument = PathologyResultReport.CreateRelatedDocument();
// Pathology PDF
ExternalData attachmentPdf = BaseCDAModel.CreateExternalData();
attachmentPdf.ExternalDataMediaType = MediaType.PDF;
attachmentPdf.Path = AttachmentFileNameAndPath;
relatedDocument.ExaminationResultRepresentation = attachmentPdf;
// Document Provenance
relatedDocument.DocumentDetails = CreateDocumentProvenance(mandatorySectionsOnly);
return(relatedDocument);
}
private void KeywordSeachDynamicData(string sKeyword)
{
oFilteredServiceResultData = ExternalData.AsParallel().Where(oExternalResult =>
{
if (oExternalResult.Title.IndexOf(sKeyword, StringComparison.OrdinalIgnoreCase) > -1 ||
oExternalResult.Srategist.LastIndexOf(sKeyword, StringComparison.OrdinalIgnoreCase) > -1 ||
oExternalResult.Custodian.LastIndexOf(sKeyword, StringComparison.OrdinalIgnoreCase) > -1 ||
oExternalResult.SolutionType.LastIndexOf(sKeyword, StringComparison.OrdinalIgnoreCase) > -1)
{
return(true);
}
else
{
return(false);
}
}).ToArray();
}
private object Get(string column)
{
if (_rowIdx == -1)
{
_rowIdx++;
}
if (ExternalData.ContainsKey("TASK_UID"))
{
if ((bool)((DataRow)Current)["TASK_IS_SUMMARY"])
{
_rowIdx++;
}
}
return(_dataTable.Rows[_rowIdx][column]);
}
private void AddExternalLeaveTypes(List <ExternalData> externalDataList)
{
var typeOfEnum = typeof(LeaveType);
var enumDictionary = Enum.GetValues(typeOfEnum).Cast <int>().ToDictionary(e => e, e => Enum.GetName(typeOfEnum, e));
foreach (var leaveTypeEnum in enumDictionary)
{
var externalData = new ExternalData();
externalData.Identifiers.Add(new Identifier {
Entity = unimicro.IdentifierEntity.EmploymentLeaveType.ToString(), Property = unimicro.IdentifierProperty.Id.ToString(), Value = leaveTypeEnum.Key.ToString()
});
externalData.DataSet.Add(new Data {
Code = PropertyName.Name.ToString(), Value = leaveTypeEnum.Value
});
externalDataList.Add(externalData);
}
}
private void UpdateFromExternalData(ExternalData dat)
{
if (_data.Count == 1)
{
Data = _data[0];
UpdateData(Data);
}
else
{
var t = new DataTree();
foreach (var d in _data)
{
t.AddElement(d);
}
Data = t;
UpdateData(Data);
}
}
public static void GraphTest()
{
var n = new AddNode();
var n2 = new NumberInputNode();
var numer = 152.2;
var exNum = new ExternalNumber(numer);
var exData = new ExternalData(exNum);
n2.ConnectToData(new List <ExternalData>()
{
exData
});
Print(n2.OutputSockets[0].Data);
exNum.RequestChange(130);
Print(n2.OutputSockets[0].Data);
n.InputSockets[0].ConnectTo(n2.OutputSockets[0]);
}
/// <summary>
/// Validate the Content for this Requested Service
/// </summary>
/// <param name="path">The path to this object as a string</param>
/// <param name="messages">the validation messages, these may be added to within this method</param>
public void Validate(string path, List <ValidationMessage> messages)
{
var vb = new ValidationBuilder(path, messages);
if (vb.ArgumentRequiredCheck("LinkNature", LinkNature))
{
LinkNature.Validate(path + "LinkNature", messages);
}
if (vb.ArgumentRequiredCheck("ExternalData", ExternalData))
{
ExternalData.Validate(path + "ExternalData", messages);
}
if (vb.ArgumentRequiredCheck("ReportIdentifier", ReportIdentifier))
{
ReportIdentifier.Validate(path + "ReportIdentifier", messages);
}
vb.ArgumentRequiredCheck("ReportStatus", ReportStatus);
}
public void Create(ExternalData data)
{
using (var transaction = _context.Database.BeginTransaction())
{
_context.Database.ExecuteSqlCommand("SET IDENTITY_INSERT [dbo].[Competitions] ON");
var competition = SaveCompetition(data.Competition);
_context.Database.ExecuteSqlCommand("SET IDENTITY_INSERT [dbo].[Competitions] OFF");
_context.Database.ExecuteSqlCommand("SET IDENTITY_INSERT [dbo].[Teams] ON");
SaveCompetitionTeams(data.Competition.Teams, competition.CompetitionId);
_context.Database.ExecuteSqlCommand("SET IDENTITY_INSERT [dbo].[Teams] OFF");
foreach (var team in data.Competition.Teams.Teams)
{
SaveTeamPlayers(team);
}
SaveCompetitionGames(data.Competition.Fixtures, competition.CompetitionId);
transaction.Commit();
}
}
/// <summary>
/// Creates and hydrates the 'Other Test Result' Attachment section.
/// </summary>
/// <returns>A hydrated 'OtherTestResult' object.</returns>
public static OtherTestResult CreateOtherTestResultAttachment()
{
var otherTestResult = BaseCDAModel.CreateOtherTestResult();
// Report Name
otherTestResult.ReportName = BaseCDAModel.CreateCodableText("Report with Attachment");
// Report Status
otherTestResult.ReportStatus = BaseCDAModel.CreateCodableText(Hl7V3ResultStatus.NoOrderOnRecordForThisTest);
// Report ExternalData
ExternalData report = BaseCDAModel.CreateExternalData(MediaType.PDF, AttachmentFileNameAndPath, "Path File");
otherTestResult.ReportContent = BaseCDAModel.CreateEncapsulatedData();
otherTestResult.ReportContent.ExternalData = report;
// Report Date
otherTestResult.ReportDate = new ISO8601DateTime(DateTime.Now.AddDays(-2));
return(otherTestResult);
}
private static void DoBackup()
{
log.Debug("executing task: database backup from web service...");
try
{
var dbCfgItems = Database.GetConfigItems();
var backupDays = int.Parse(dbCfgItems.First(i => i.Name.Equals("BackupDays")).Value);
Database.DoBackup((lineId, businessId) =>
{
var dataItems = ExternalData.Fetch(businessId, lineId, backupDays);
var dbDataItems = Mapper.Map <List <AdapterDb.DataItem> >(dataItems);
return(dbDataItems);
});
}
catch (Exception ex)
{
log.ErrorFormat("job failed: {0}", ex);
}
}
public void Setup()
{
DriverHelper.InitBrowser();
Driver.Navigate().GoToUrl("https://testdo.bitwarden.com");
ExternalData.filldatafromCsv();
}
/// <summary>
/// This method populates an PCML model with either the mandatory sections only, or both
/// the mandatory and optional sections
/// </summary>
/// <param name="mandatorySectionsOnly">mandatorySectionsOnly</param>
/// <returns>PCML</returns>
public static Nehta.VendorLibrary.CDA.Common.PCML PopulatePCML_1B(Boolean mandatorySectionsOnly)
{
var pharmacyCuratedMedsList = Nehta.VendorLibrary.CDA.Common.PCML.CreatePCML();
// Include Logo
pharmacyCuratedMedsList.IncludeLogo = false;
// Set Creation Time
pharmacyCuratedMedsList.DocumentCreationTime = new ISO8601DateTime(DateTime.Now);
#region Setup and populate the CDA context model
// Setup and populate the CDA context model
var cdaContext = Nehta.VendorLibrary.CDA.Common.PCML.CreateCDAContext();
// Document Id
cdaContext.DocumentId = BaseCDAModel.CreateIdentifier(BaseCDAModel.CreateOid(), null);
// Custodian
cdaContext.Custodian = BaseCDAModel.CreateCustodian();
GenericObjectReuseSample.HydrateCustodian(cdaContext.Custodian, mandatorySectionsOnly);
//Optional sections
// Legal authenticator
if (!mandatorySectionsOnly)
{
// Set Id
cdaContext.SetId = BaseCDAModel.CreateIdentifier(BaseCDAModel.CreateOid(), null);
// CDA Context Version
cdaContext.Version = "1";
cdaContext.LegalAuthenticator = BaseCDAModel.CreateLegalAuthenticator();
GenericObjectReuseSample.HydrateAuthenticator(cdaContext.LegalAuthenticator, mandatorySectionsOnly);
}
pharmacyCuratedMedsList.CDAContext = cdaContext;
#endregion
#region Setup and Populate the SCS Context model
// Setup and Populate the SCS Context model
pharmacyCuratedMedsList.SCSContext = Nehta.VendorLibrary.CDA.Common.PCML.CreateSCSContext();
var authorHealthcareProvider = BaseCDAModel.CreateAuthorHealthcareProvider();
GenericObjectReuseSample.HydrateAuthorHealthcareProvider(authorHealthcareProvider, mandatorySectionsOnly);
pharmacyCuratedMedsList.SCSContext.Author = authorHealthcareProvider;
//Cannot use as a device : prohibited by CORE Level One
//healthCheckAssessment.SCSContext.Author = GenericObjectReuseSample.CreateAuthorDevice();
pharmacyCuratedMedsList.SCSContext.Encounter = new Encounter
{
HealthcareFacility = PopulateHealthcareFacility(mandatorySectionsOnly)
};
pharmacyCuratedMedsList.SCSContext.SubjectOfCare = BaseCDAModel.CreateSubjectOfCare();
GenericObjectReuseSample.HydrateSubjectofCare(pharmacyCuratedMedsList.SCSContext.SubjectOfCare, mandatorySectionsOnly);
IParticipationPersonOrOrganisation person = Nehta.VendorLibrary.CDA.Common.PCML.CreateParticipationPersonOrOrganisation();
person.Participant = Nehta.VendorLibrary.CDA.Common.PCML.CreateParticipantPersonOrOrganisation();
person.Role = BaseCDAModel.CreateRole(HealthcareFacilityTypeCodes.AgedCareResidentialServices);
person.Participant.Person = BaseCDAModel.CreatePersonWithOrganisation();
var name1 = BaseCDAModel.CreatePersonName();
name1.FamilyName = "Grant";
name1.GivenNames = new List <string> {
"Sally", "Wally"
};
name1.Titles = new List <string> {
"Miss"
};
name1.NameUsages = new List <NameUsage> {
NameUsage.Legal
};
person.Participant.Person.PersonNames = new List <IPersonName> {
name1
};
// Subject of Care > Participant > Person or Organisation or Device > Person > Demographic Data > Sex
var address1 = BaseCDAModel.CreateAddress();
address1.AddressPurpose = AddressPurpose.Residential;
address1.AustralianAddress = BaseCDAModel.CreateAustralianAddress();
address1.AustralianAddress.UnstructuredAddressLines = new List <string> {
"1 Clinician Street"
};
address1.AustralianAddress.SuburbTownLocality = "Nehtaville";
address1.AustralianAddress.State = AustralianState.NSW;
address1.AustralianAddress.PostCode = "5555";
address1.AustralianAddress.DeliveryPointId = 32568931;
person.Participant.Addresses = new List <IAddress> {
address1
};
person.Participant.Person.Organisation = BaseCDAModel.CreateEmploymentOrganisation();
person.Participant.Person.Organisation = BaseCDAModel.CreateEmploymentOrganisation();
person.Participant.Person.Organisation.Name = "Hay Bill Hospital";
person.Participant.Person.Organisation.NameUsage = OrganisationNameUsage.Other;
person.Participant.Person.Organisation.Identifiers = new List <Identifier> {
BaseCDAModel.CreateHealthIdentifier(HealthIdentifierType.HPIO, "8003620833333789"),
//BaseCDAModel.CreateIdentifier("SampleAuthority", null, null, "1.2.3.4.5.66666", null)
};
if (!mandatorySectionsOnly)
{
//populate with full person details
// Subject of Care > Participant > Address
// Subject of Care > Participant > Person or Organisation or Device > Person > Demographic Data > Indigenous Status
// Subject of Care > Participant > Electronic Communication Detail
var coms1 = BaseCDAModel.CreateElectronicCommunicationDetail(
"0345754566",
ElectronicCommunicationMedium.Telephone,
ElectronicCommunicationUsage.WorkPlace);
var coms2 = BaseCDAModel.CreateElectronicCommunicationDetail(
"*****@*****.**",
ElectronicCommunicationMedium.Email,
ElectronicCommunicationUsage.WorkPlace);
person.Participant.ElectronicCommunicationDetails = new List <ElectronicCommunicationDetail> {
coms1, coms2
};
// Subject of Care > Participant > Entitlement
var entitlement1 = BaseCDAModel.CreateEntitlement();
entitlement1.Id = BaseCDAModel.CreateMedicareNumber(MedicareNumberType.MedicareCardNumber, "1234567881");
entitlement1.Type = EntitlementType.MedicareBenefits;
entitlement1.ValidityDuration = BaseCDAModel.CreateInterval("1", TimeUnitOfMeasure.Year);
var entitlement2 = BaseCDAModel.CreateEntitlement();
entitlement2.Id = BaseCDAModel.CreateMedicareNumber(MedicareNumberType.MedicareCardNumber, "1234567881");
entitlement2.Type = EntitlementType.MedicareBenefits;
entitlement2.ValidityDuration = BaseCDAModel.CreateInterval("1", TimeUnitOfMeasure.Year);
person.Participant.Entitlements = new List <Entitlement> {
entitlement1, entitlement2
};
}
pharmacyCuratedMedsList.SCSContext.Participant = new List <IParticipationPersonOrOrganisation>();
pharmacyCuratedMedsList.SCSContext.Participant.Add(person);
#endregion
#region Setup and populate the SCS Content model
// Setup and populate the SCS Content model
pharmacyCuratedMedsList.SCSContent = Nehta.VendorLibrary.CDA.Common.PCML.CreateSCSContent();
pharmacyCuratedMedsList.SCSContent.EncapsulatedData = BaseCDAModel.CreateEncapsulatedData();
ExternalData report1 = EventSummary.CreateExternalData();
//report1.ExternalDataMediaType = MediaType.PDF;
//report1.Path = StructuredFileAttachment;
//report1.Caption = "Attachment One";
//healthCheckAssessment.SCSContent.EncapsulatedData.ExternalData = report1;
#endregion
return(pharmacyCuratedMedsList);
}
public async Task <IEnumerable <EntityMatch> > MatchEmployeeData(int unitId, int[] ids)
{
var externalEmployees = await _externalDataService.GetExternalEmployeeData(unitId);
var externalEmployeesMapped = _mapper.Map <IEnumerable <ExternalData> >(externalEmployees);
var internalEmployees = await _employeeService.SearchEmployee(new SearchQueryEmployee { EmployeesIds = ids.ToList() });
var factorRank = 10.0 / 4.0;
var matchedData = new List <EntityMatch>();
foreach (var employee in internalEmployees)
{
var bestFactor = 0.0;
var bestMatch = new ExternalData();
var matchEntity = new EntityMatch()
{
EntityId = employee.Id,
EntityMap = EntityType.Employee.ToString(),
};
foreach (var externalEmployee in externalEmployeesMapped)
{
var factor = 0.0;
if (externalEmployee.DataSet.Any(x => !string.IsNullOrWhiteSpace(x.Value) &&
!string.IsNullOrWhiteSpace(employee.FirstName) &&
x.Value.Contains(employee.FirstName)))
{
factor += factorRank;
}
if (externalEmployee.DataSet.Any(x => !string.IsNullOrWhiteSpace(x.Value) &&
!string.IsNullOrWhiteSpace(employee.Email) &&
x.Value.Contains(employee.Email)))
{
factor += factorRank;
}
if (externalEmployee.DataSet.Any(x => !string.IsNullOrWhiteSpace(x.Value) &&
!string.IsNullOrWhiteSpace(employee.LastName) &&
x.Value.Contains(employee.LastName)))
{
factor += factorRank;
}
if (externalEmployee.DataSet.Any(x => !string.IsNullOrWhiteSpace(x.Value) &&
!string.IsNullOrWhiteSpace(employee.JobTitle) &&
x.Value.Contains(employee.JobTitle)))
{
factor += factorRank;
}
if (factor > bestFactor)
{
bestFactor = factor;
bestMatch = externalEmployee;
}
}
if (bestFactor != 0)
{
matchEntity.ExternalData = bestMatch;
matchEntity.MatchFactor = bestFactor;
}
matchedData.Add(matchEntity);
}
return(matchedData);
}
