public async Task <Result> UpdateRule(Rule rule)
{
RuleEntity newruleEntity = _clinicalFactory.MappingToRuleEntity.DefaultContext.Mapper.Map <RuleEntity>(rule);
RuleEntity originalRuleEntity = ClinicalDbService.RuleRepository.GetById(newruleEntity.RuleId);
originalRuleEntity.Description = newruleEntity.Description;
#region Update Segments ------------------------------------------------------------------------------------
IEnumerable <int> originalSegmentsId = originalRuleEntity.Segments.Select(s => s.SegmentId);
IEnumerable <int> editedSegmentsId = newruleEntity.Segments.Select(s => s.SegmentId);
IList <SegmentEntity> segmentToAdd = new List <SegmentEntity>();
IEnumerable <int> segmentsIdToAdd = editedSegmentsId.Except(originalSegmentsId);
foreach (int segmentId in segmentsIdToAdd)
{
SegmentEntity segment = ClinicalDbService.SegmentRepository.GetById(segmentId);
if (!segmentToAdd.Contains(segment))
{
segmentToAdd.Add(segment);
}
}
segmentToAdd.ToList().ForEach(s => originalRuleEntity.Segments.Add(s));
IList <SegmentEntity> segmentToRemove = new List <SegmentEntity>();
IEnumerable <int> segmentsIdRemove = originalSegmentsId.Except(editedSegmentsId);
foreach (int segmentId in segmentsIdRemove)
{
SegmentEntity segment = originalRuleEntity.Segments.FirstOrDefault(s => s.SegmentId == segmentId);
if (!segmentToRemove.Contains(segment))
{
segmentToRemove.Add(segment);
}
}
segmentToRemove.ToList().ForEach(s => originalRuleEntity.Segments.Remove(s));
#endregion
#region Update Contracts -----------------------------------------------------------------------------------
IEnumerable <int> originalContractsId = originalRuleEntity.Contracts.Select(c => c.ContractId);
IEnumerable <int> editedContractsId = newruleEntity.Contracts.Select(c => c.ContractId);
IList <ContractEntity> contractToAdd = new List <ContractEntity>();
IEnumerable <int> contractsIdToAdd = editedContractsId.Except(originalContractsId);
foreach (int contractId in contractsIdToAdd)
{
ContractEntity contract = ClinicalDbService.ContractRepository.GetById(contractId);
if (!contractToAdd.Contains(contract))
{
contractToAdd.Add(contract);
}
}
contractToAdd.ToList().ForEach(c => originalRuleEntity.Contracts.Add(c));
IList <ContractEntity> contractToRemove = new List <ContractEntity>();
IEnumerable <int> contractsIdRemove = originalContractsId.Except(editedContractsId);
foreach (int contractId in contractsIdRemove)
{
ContractEntity contract = originalRuleEntity.Contracts.FirstOrDefault(s => s.ContractId == contractId);
if (!contractToRemove.Contains(contract))
{
contractToRemove.Add(contract);
}
}
contractToRemove.ToList().ForEach(c => originalRuleEntity.Contracts.Remove(c));
#endregion
#region Update Pbp -----------------------------------------------------------------------------------------
IEnumerable <int> originalPbpId = originalRuleEntity.Pbp.Select(c => c.PbpId);
IEnumerable <int> editedPbpId = newruleEntity.Pbp.Select(c => c.PbpId);
IList <PbpEntity> pbpToAdd = new List <PbpEntity>();
IEnumerable <int> pbpsIdToAdd = editedPbpId.Except(originalPbpId);
foreach (int pbpId in pbpsIdToAdd)
{
PbpEntity pbp = ClinicalDbService.PbpRepository.GetById(pbpId);
if (!pbpToAdd.Contains(pbp))
{
pbpToAdd.Add(pbp);
}
}
pbpToAdd.ToList().ForEach(c => originalRuleEntity.Pbp.Add(c));
IList <PbpEntity> pbpToRemove = new List <PbpEntity>();
IEnumerable <int> pbpsIdRemove = originalPbpId.Except(editedPbpId);
foreach (int pbpId in pbpsIdRemove)
{
PbpEntity pbp = originalRuleEntity.Pbp.FirstOrDefault(s => s.PbpId == pbpId);
if (!pbpToRemove.Contains(pbp))
{
pbpToRemove.Add(pbp);
}
}
pbpToRemove.ToList().ForEach(c => originalRuleEntity.Pbp.Remove(c));
#endregion
#region Update TIN -----------------------------------------------------------------------------------------
IEnumerable <int> originalTinId = originalRuleEntity.Tin.Select(c => c.TinId);
IEnumerable <int> editedTinId = newruleEntity.Tin.Select(c => c.TinId);
IList <TinEntity> tinToAdd = new List <TinEntity>();
IEnumerable <int> tinsIdToAdd = editedTinId.Except(originalTinId);
foreach (int tinId in tinsIdToAdd)
{
TinEntity tin = ClinicalDbService.TinRepository.GetById(tinId);
if (!tinToAdd.Contains(tin))
{
tinToAdd.Add(tin);
}
}
tinToAdd.ToList().ForEach(c => originalRuleEntity.Tin.Add(c));
IList <TinEntity> tinToRemove = new List <TinEntity>();
IEnumerable <int> tinsIdRemove = originalTinId.Except(editedTinId);
foreach (int tinId in tinsIdRemove)
{
TinEntity tin = originalRuleEntity.Tin.FirstOrDefault(s => s.TinId == tinId);
if (!tinToRemove.Contains(tin))
{
tinToRemove.Add(tin);
}
}
tinToRemove.ToList().ForEach(c => originalRuleEntity.Tin.Remove(c));
#endregion
#region Update Measures ------------------------------------------------------------------------------------
IEnumerable <int> originalMeasuresId = originalRuleEntity.Measures.Select(c => c.MeasureId);
IEnumerable <int> editedMeasuresId = newruleEntity.Measures.Select(c => c.MeasureId);
IList <MeasureEntity> measuresToAdd = new List <MeasureEntity>();
IEnumerable <int> measuresIdToAdd = editedMeasuresId.Except(originalMeasuresId);
foreach (int measureId in measuresIdToAdd)
{
MeasureEntity measure = ClinicalDbService.MeasureRepository.GetById(measureId);
if (!measuresToAdd.Contains(measure))
{
measuresToAdd.Add(measure);
}
}
measuresToAdd.ToList().ForEach(c => originalRuleEntity.Measures.Add(c));
IList <MeasureEntity> measuresToRemove = new List <MeasureEntity>();
IEnumerable <int> measuresIdRemove = originalMeasuresId.Except(editedMeasuresId);
foreach (int measureId in measuresIdRemove)
{
MeasureEntity measure = originalRuleEntity.Measures.FirstOrDefault(s => s.MeasureId == measureId);
if (!measuresToRemove.Contains(measure))
{
measuresToRemove.Add(measure);
}
}
measuresToRemove.ToList().ForEach(c => originalRuleEntity.Measures.Remove(c));
#endregion
#region Update Applications --------------------------------------------------------------------------------
IEnumerable <int> originalApplicationsId = originalRuleEntity.Applications.Select(c => c.ApplicationId);
IEnumerable <int> editedApplicationsId = newruleEntity.Applications.Select(c => c.ApplicationId);
IList <ApplicationEntity> applicationsToAdd = new List <ApplicationEntity>();
IEnumerable <int> applicationsIdToAdd = editedApplicationsId.Except(originalApplicationsId);
foreach (int applicationId in applicationsIdToAdd)
{
ApplicationEntity application = ClinicalDbService.ApplicationRepository.GetById(applicationId);
if (!applicationsToAdd.Contains(application))
{
applicationsToAdd.Add(application);
}
}
applicationsToAdd.ToList().ForEach(c => originalRuleEntity.Applications.Add(c));
IList <ApplicationEntity> applicationsToRemove = new List <ApplicationEntity>();
IEnumerable <int> applicationsIdRemove = originalApplicationsId.Except(editedApplicationsId);
foreach (int applicationId in applicationsIdRemove)
{
ApplicationEntity application = originalRuleEntity.Applications.FirstOrDefault(s => s.ApplicationId == applicationId);
if (!applicationsToRemove.Contains(application))
{
applicationsToRemove.Add(application);
}
}
applicationsToRemove.ToList().ForEach(c => originalRuleEntity.Applications.Remove(c));
#endregion
ClinicalDbService.RuleRepository.Update(originalRuleEntity);
await ClinicalDbService.SaveAsync();
return(Result.New(originalRuleEntity));
}
public async Task <Result> UpdateRule(Rule rule)
{
RuleEntity newruleEntity = _clinicalFactory.MappingToRuleEntity.DefaultContext.Mapper.Map <RuleEntity>(rule);
RuleEntity originalRuleEntity = _GetReleById(rule.RuleId);
originalRuleEntity.Description = newruleEntity.Description;
#region Update Segments ------------------------------------------------------------------------------------
IEnumerable <int> originalSegmentsId = originalRuleEntity.RuleSegment.Select(s => s.Segment).Select(s => s.SegmentId);
IEnumerable <int> editedSegmentsId = newruleEntity.RuleSegment.Select(s => s.Segment).Select(s => s.SegmentId);
IList <SegmentEntity> segmentToAdd = new List <SegmentEntity>();
IEnumerable <int> segmentsIdToAdd = editedSegmentsId.Except(originalSegmentsId);
foreach (int segmentId in segmentsIdToAdd)
{
SegmentEntity segment = ClinicalDbService.SegmentRepository.GetById(segmentId);
if (!segmentToAdd.Contains(segment))
{
segmentToAdd.Add(segment);
}
}
segmentToAdd.ToList().ForEach(s => originalRuleEntity.RuleSegment.Add(new RuleSegmentEntity {
RuleId = originalRuleEntity.RuleId,
Segment = s
}));
IList <SegmentEntity> segmentToRemove = new List <SegmentEntity>();
IEnumerable <int> segmentsIdRemove = originalSegmentsId.Except(editedSegmentsId);
foreach (int segmentId in segmentsIdRemove)
{
SegmentEntity segment = originalRuleEntity.RuleSegment.Select(s => s.Segment).FirstOrDefault(s => s.SegmentId == segmentId);
if (!segmentToRemove.Contains(segment))
{
segmentToRemove.Add(segment);
}
}
segmentToRemove.ToList().ForEach(s => originalRuleEntity.RuleSegment.Remove(
originalRuleEntity.RuleSegment.Select(r => r).Where(r => r.SegmentId == s.SegmentId).First()
));
#endregion
#region Update Contracts -----------------------------------------------------------------------------------
IEnumerable <int> originalContractsId = originalRuleEntity.RuleContract.Select(c => c.Contract).Select(c => c.ContractId);
IEnumerable <int> editedContractsId = newruleEntity.RuleContract.Select(c => c.Contract).Select(c => c.ContractId);
IList <ContractEntity> contractToAdd = new List <ContractEntity>();
IEnumerable <int> contractsIdToAdd = editedContractsId.Except(originalContractsId);
foreach (int contractId in contractsIdToAdd)
{
ContractEntity contract = ClinicalDbService.ContractRepository.GetById(contractId);
if (!contractToAdd.Contains(contract))
{
contractToAdd.Add(contract);
}
}
contractToAdd.ToList().ForEach(c => originalRuleEntity.RuleContract.Add(new RuleContractEntity
{
RuleId = originalRuleEntity.RuleId,
Contract = c
}));
IList <ContractEntity> contractToRemove = new List <ContractEntity>();
IEnumerable <int> contractsIdRemove = originalContractsId.Except(editedContractsId);
foreach (int contractId in contractsIdRemove)
{
ContractEntity contract = originalRuleEntity.RuleContract.Select(c => c.Contract).FirstOrDefault(s => s.ContractId == contractId);
if (!contractToRemove.Contains(contract))
{
contractToRemove.Add(contract);
}
}
contractToRemove.ToList().ForEach(c => originalRuleEntity.RuleContract.Remove(
originalRuleEntity.RuleContract.Select(rc => rc).Where(rc => rc.ContractId == c.ContractId).First()
));
#endregion
#region Update Pbp -----------------------------------------------------------------------------------------
IEnumerable <int> originalContractPbpId = originalRuleEntity.RulePbp.Select(p => p.ContractPbp).Select(cp => cp.ContractPBPId);
IEnumerable <int> editedContractPbpId = newruleEntity.RulePbp.Select(p => p.ContractPbp).Select(cp => cp.ContractPBPId);
IList <ContractPbpEntity> contractPbpToAdd = new List <ContractPbpEntity>();
IEnumerable <int> contractPbpIdToAdd = editedContractPbpId.Except(originalContractPbpId);
foreach (int contractPbpId in contractPbpIdToAdd)
{
ContractPbpEntity contractPbp = ClinicalDbService.ContractPbpRepository.GetById(contractPbpId);
if (!contractPbpToAdd.Contains(contractPbp))
{
contractPbpToAdd.Add(contractPbp);
}
}
contractPbpToAdd.ToList().ForEach(cp => originalRuleEntity.RulePbp.Add(new RulePbpEntity {
RuleId = originalRuleEntity.RuleId,
ContractPbp = cp
}));
IList <ContractPbpEntity> contractPbpToRemove = new List <ContractPbpEntity>();
IEnumerable <int> contractPbpIdToRemove = originalContractPbpId.Except(editedContractPbpId);
foreach (int contractPbpId in contractPbpIdToRemove)
{
ContractPbpEntity contractPbp = originalRuleEntity.RulePbp.Select(c => c.ContractPbp).FirstOrDefault(s => s.ContractPBPId == contractPbpId);
if (!contractPbpToRemove.Contains(contractPbp))
{
contractPbpToRemove.Add(contractPbp);
}
}
contractPbpToRemove.ToList().ForEach(c => originalRuleEntity.RulePbp.Remove(
originalRuleEntity.RulePbp.Select(rc => rc).Where(rc => rc.ContractPBPId == c.ContractPBPId).First()
));
#endregion
#region Update TIN -----------------------------------------------------------------------------------------
IEnumerable <int> originalTinId = originalRuleEntity.RuleTin.Select(t => t.Tin).Select(c => c.TinId);
IEnumerable <int> editedTinId = newruleEntity.RuleTin.Select(t => t.Tin).Select(c => c.TinId);
IList <TinEntity> tinToAdd = new List <TinEntity>();
IEnumerable <int> tinsIdToAdd = editedTinId.Except(originalTinId);
foreach (int tinId in tinsIdToAdd)
{
TinEntity tin = ClinicalDbService.TinRepository.GetById(tinId);
if (!tinToAdd.Contains(tin))
{
tinToAdd.Add(tin);
}
}
tinToAdd.ToList().ForEach(t => originalRuleEntity.RuleTin.Add(
new RuleTinEntity {
RuleId = originalRuleEntity.RuleId,
Tin = t
}
));
IList <TinEntity> tinToRemove = new List <TinEntity>();
IEnumerable <int> tinsIdRemove = originalTinId.Except(editedTinId);
foreach (int tinId in tinsIdRemove)
{
TinEntity tin = originalRuleEntity.RuleTin.Select(t => t.Tin).FirstOrDefault(s => s.TinId == tinId);
if (!tinToRemove.Contains(tin))
{
tinToRemove.Add(tin);
}
}
tinToRemove.ToList().ForEach(t => originalRuleEntity.RuleTin.Remove(
originalRuleEntity.RuleTin.Select(rt => rt).Where(rt => rt.TinId == t.TinId).First()
));
#endregion
#region Update Measures ------------------------------------------------------------------------------------
IEnumerable <int> originalMeasuresId = originalRuleEntity.RuleMeasure.Select(rm => rm.Measure).Select(c => c.MeasureId);
IEnumerable <int> editedMeasuresId = newruleEntity.RuleMeasure.Select(rm => rm.Measure).Select(c => c.MeasureId);
IList <MeasureEntity> measuresToAdd = new List <MeasureEntity>();
IEnumerable <int> measuresIdToAdd = editedMeasuresId.Except(originalMeasuresId);
foreach (int measureId in measuresIdToAdd)
{
MeasureEntity measure = ClinicalDbService.MeasureRepository.GetById(measureId);
if (!measuresToAdd.Contains(measure))
{
measuresToAdd.Add(measure);
}
}
measuresToAdd.ToList().ForEach(m => originalRuleEntity.RuleMeasure.Add(
new RuleMeasureEntity {
RuleId = originalRuleEntity.RuleId,
Measure = m
}
));
IList <MeasureEntity> measuresToRemove = new List <MeasureEntity>();
IEnumerable <int> measuresIdRemove = originalMeasuresId.Except(editedMeasuresId);
foreach (int measureId in measuresIdRemove)
{
MeasureEntity measure = originalRuleEntity.RuleMeasure.Select(rm => rm.Measure).FirstOrDefault(s => s.MeasureId == measureId);
if (!measuresToRemove.Contains(measure))
{
measuresToRemove.Add(measure);
}
}
measuresToRemove.ToList().ForEach(m => originalRuleEntity.RuleMeasure.Remove(
originalRuleEntity.RuleMeasure.Select(rm => rm).Where(rm => rm.MeasureId == m.MeasureId).First()
));
#endregion
#region Update Applications --------------------------------------------------------------------------------
IEnumerable <int> originalApplicationsId = originalRuleEntity.RuleApplication.Select(ra => ra.Application).Select(a => a.ApplicationId);
IEnumerable <int> editedApplicationsId = newruleEntity.RuleApplication.Select(ra => ra.Application).Select(c => c.ApplicationId);
IList <ApplicationEntity> applicationsToAdd = new List <ApplicationEntity>();
IEnumerable <int> applicationsIdToAdd = editedApplicationsId.Except(originalApplicationsId);
foreach (int applicationId in applicationsIdToAdd)
{
ApplicationEntity application = ClinicalDbService.ApplicationRepository.GetById(applicationId);
if (!applicationsToAdd.Contains(application))
{
applicationsToAdd.Add(application);
}
}
applicationsToAdd.ToList().ForEach(a => originalRuleEntity.RuleApplication.Add(
new RuleApplicationEntity {
RuleId = originalRuleEntity.RuleId,
Application = a
}
));
IList <ApplicationEntity> applicationsToRemove = new List <ApplicationEntity>();
IEnumerable <int> applicationsIdRemove = originalApplicationsId.Except(editedApplicationsId);
foreach (int applicationId in applicationsIdRemove)
{
ApplicationEntity application = originalRuleEntity.RuleApplication.Select(ra => ra.Application).FirstOrDefault(s => s.ApplicationId == applicationId);
if (!applicationsToRemove.Contains(application))
{
applicationsToRemove.Add(application);
}
}
applicationsToRemove.ToList().ForEach(a => originalRuleEntity.RuleApplication.Remove(
originalRuleEntity.RuleApplication.Select(ra => ra).Where(ra => ra.ApplicationId == a.ApplicationId).First()
));
#endregion
ClinicalDbService.RuleRepository.Update(originalRuleEntity);
await ClinicalDbService.SaveAsync();
return(Result.New(originalRuleEntity));
}
