/// <summary>
/// Resource listener
/// </summary>
public MdmResourceHandler()
{
// Register the master
this.m_dataManager = MdmDataManagerFactory.GetDataManager <TModel>();
this.m_policyEnforcement = ApplicationServiceContext.Current.GetService <IPolicyEnforcementService>();
this.m_batchRepository = ApplicationServiceContext.Current.GetService <IDataPersistenceService <Bundle> >();
this.m_adhocCache = ApplicationServiceContext.Current.GetService <IAdhocCacheService>();
// Validate the match configuration exists
var matchConfigService = ApplicationServiceContext.Current.GetService <IRecordMatchingConfigurationService>();
this.m_notifyRepository = ApplicationServiceContext.Current.GetService <IRepositoryService <TModel> >() as INotifyRepositoryService <TModel>;
if (this.m_notifyRepository == null)
{
throw new InvalidOperationException($"Could not find repository service for {typeof(TModel)}");
}
this.m_classConceptKey = typeof(TModel).GetCustomAttributes <ClassConceptKeyAttribute>(false).Select(o => Guid.Parse(o.ClassConcept)).ToArray();
// Subscribe
this.m_notifyRepository.Inserting += this.OnPrePersistenceValidate;
this.m_notifyRepository.Saving += this.OnPrePersistenceValidate;
this.m_notifyRepository.Obsoleting += this.OnPrePersistenceValidate;
this.m_notifyRepository.Inserting += this.OnInserting;
this.m_notifyRepository.Saving += this.OnSaving;
this.m_notifyRepository.Obsoleting += this.OnObsoleting;
this.m_notifyRepository.Retrieved += this.OnRetrieved;
this.m_notifyRepository.Retrieving += this.OnRetrieving;
this.m_notifyRepository.Querying += this.OnQuerying;
// Bind down the repository services
// TODO: Determine if this level of interception is required - this only impacts when (for example) IRepositoryService<Patient>
// is bound to MDM and someone calls IRepositoryService<Person> - without it calls to the former will return MDM based resources
// whereas calls to the latter will return raw non-MDM resources (even if they are patients - they will be local, non-MDM patients).
var baseType = typeof(TModel).BaseType;
while (typeof(Entity).IsAssignableFrom(baseType) || typeof(Act).IsAssignableFrom(baseType))
{
var repoType = typeof(INotifyRepositoryService <>).MakeGenericType(baseType);
var repoInstance = ApplicationServiceContext.Current.GetService(repoType);
if (repoInstance == null)
{
break;
}
// Hand off reflection notifcation
var eventHandler = repoType.GetEvent("Queried");
var parmType = typeof(QueryResultEventArgs <>).MakeGenericType(baseType);
var parameter = Expression.Parameter(parmType);
var dataAccess = Expression.MakeMemberAccess(parameter, parmType.GetProperty("Results"));
var principalAccess = Expression.MakeMemberAccess(parameter, parmType.GetProperty("Principal"));
var methodInfo = this.GetType().GetGenericMethod(nameof(OnGenericQueried), new Type[] { baseType }, new Type[] { typeof(IEnumerable <>).MakeGenericType(baseType), typeof(IPrincipal) });
var lambdaMethod = typeof(Expression).GetGenericMethod(nameof(Expression.Lambda), new Type[] { eventHandler.EventHandlerType }, new Type[] { typeof(Expression), typeof(ParameterExpression[]) });
var lambdaAccess = lambdaMethod.Invoke(null, new object[] { Expression.Assign(dataAccess, Expression.Call(Expression.Constant(this), (MethodInfo)methodInfo, dataAccess, principalAccess)), new ParameterExpression[] { Expression.Parameter(typeof(Object)), parameter } }) as LambdaExpression;
eventHandler.AddEventHandler(repoInstance, lambdaAccess.Compile());
//var lamdaAccess = Expression.Lambda(Expression.Call(Expression.Constant(this), this.GetType().GetMethod(nameof(OnGenericQueried))), dataAccess), Expression.Parameter(typeof(Object)), parameter);
// Continue down base types
baseType = baseType.BaseType;
}
}
/// <summary>
/// Data policy filter service with DI
/// </summary>
public DataPolicyFilterService(IConfigurationManager configurationManager, IPasswordHashingService passwordService, IPolicyDecisionService pdpService, IThreadPoolService threadPoolService,
IDataCachingService dataCachingService, ISubscriptionExecutor subscriptionExecutor = null, IAdhocCacheService adhocCache = null)
{
this.m_hasher = passwordService;
this.m_adhocCache = adhocCache;
this.m_pdpService = pdpService;
this.m_subscriptionExecutor = subscriptionExecutor;
this.m_dataCachingService = dataCachingService;
this.m_threadPool = threadPoolService;
// Configuration load
this.m_configuration = configurationManager.GetSection <DataPolicyFilterConfigurationSection>();
if (this.m_configuration == null)
{
this.m_tracer.TraceWarning("No data policy configuration exists. Setting all to HIDE");
this.m_configuration = new DataPolicyFilterConfigurationSection()
{
DefaultAction = ResourceDataPolicyActionType.Hide, Resources = new List <ResourceDataPolicyFilter>()
};
}
if (this.m_configuration.Resources != null)
{
foreach (var t in this.m_configuration.Resources)
{
if (typeof(Act).IsAssignableFrom(t.ResourceType.Type) || typeof(Entity).IsAssignableFrom(t.ResourceType.Type) || typeof(AssigningAuthority).IsAssignableFrom(t.ResourceType.Type))
{
this.m_tracer.TraceInfo("Binding privacy action {0} to {1}", t.Action, t.ResourceType.Type);
this.m_actions.TryAdd(t.ResourceType.Type, t);
}
}
}
}
/// <summary>
/// Privacy enforcement service
/// </summary>
public LocalConceptRepository(IPolicyEnforcementService policyService, ILocalizationService localizationService, IDataPersistenceService <ConceptReferenceTerm> referenceTermService,
IDataPersistenceService <ConceptName> conceptNameService,
IPrivacyEnforcementService privacyService = null, IAdhocCacheService adhocCacheService = null) : base(policyService, localizationService, privacyService)
{
this.m_adhocCacheService = adhocCacheService;
this.m_conceptNameService = conceptNameService;
this.m_referenceTermService = referenceTermService;
}
#pragma warning restore CS0067
/// <summary>
/// Create new audit repository service
/// </summary>
public AdoAuditRepositoryService(IConfigurationManager configurationManager,
IDataCachingService dataCachingService,
IBiMetadataRepository biMetadataRepository,
IConceptRepositoryService conceptRepository,
IAdhocCacheService adhocCacheService = null)
{
this.m_configuration = configurationManager.GetSection <AdoAuditConfigurationSection>();
this.m_adhocCache = adhocCacheService;
this.m_dataCachingService = dataCachingService;
this.m_conceptRepository = conceptRepository;
try
{
this.m_configuration.Provider.UpgradeSchema("SanteDB.Persistence.Audit.ADO");
ApplicationServiceContext.Current.Started += (o, e) =>
{
using (AuthenticationContext.EnterSystemContext())
{
// Add audits as a BI data source
biMetadataRepository
.Insert(new BiDataSourceDefinition()
{
IsSystemObject = true,
ConnectionString = this.m_configuration.ReadonlyConnectionString,
MetaData = new BiMetadata()
{
Version = typeof(AdoAuditRepositoryService).Assembly.GetName().Version.ToString(),
Status = BiDefinitionStatus.Active,
Demands = new List <string>()
{
PermissionPolicyIdentifiers.AccessAuditLog
}
},
Id = "org.santedb.bi.dataSource.audit",
Name = "audit",
ProviderType = typeof(OrmBiDataProvider)
});
}
};
this.m_mapper = new ModelMapper(typeof(AdoAuditRepositoryService).Assembly.GetManifestResourceStream("SanteDB.Persistence.Auditing.ADO.Data.Map.ModelMap.xml"));
this.m_builder = new QueryBuilder(this.m_mapper, this.m_configuration.Provider);
}
catch (ModelMapValidationException e)
{
this.m_traceSource.TraceError("Error validing map: {0}", e.Message);
foreach (var i in e.ValidationDetails)
{
this.m_traceSource.TraceError("{0}:{1} @ {2}", i.Level, i.Message, i.Location);
}
throw;
}
}
/// <summary>
/// Create new service with adhoc cache
/// </summary>
public AdoPolicyInformationService(IPolicyEnforcementService pepService, IPolicyDecisionService pdpService, IAdhocCacheService adhocCache = null)
{
this.m_adhocCache = adhocCache;
this.m_policyEnforcement = pepService;
this.m_policyDecisionService = pdpService;
}
/// <summary>
/// Creates a new instance with DI
/// </summary>
public ExemptablePolicyFilterService(IConfigurationManager configManager, IPasswordHashingService passwordService, IPolicyDecisionService pdpService, IThreadPoolService threadPoolService, IDataCachingService dataCachingService, IAdhocCacheService adhocCache = null, ISubscriptionExecutor subscriptionExecutor = null)
: base(configManager, passwordService, pdpService, threadPoolService, dataCachingService, subscriptionExecutor, adhocCache)
{
}
/// <summary>
/// Resource handler subscription
/// </summary>
public PatientResourceHandler(IRepositoryService <Core.Model.Roles.Patient> repo, IRepositoryService <EntityRelationship> erRepository, IRepositoryService <Concept> conceptRepository, ILocalizationService localizationService, IAdhocCacheService adhocCacheService = null) : base(repo, localizationService)
{
this.m_erRepository = erRepository;
this.m_adhocCacheService = adhocCacheService;
this.m_conceptRepository = conceptRepository;
}
/// <summary>
/// Default policy decision service
/// </summary>
public DefaultPolicyDecisionService(IPasswordHashingService hashService, IAdhocCacheService adhocCache = null)
{
this.m_adhocCacheService = adhocCache;
this.m_hasher = hashService;
}
/// <summary>
/// Create a new DI service instance
/// </summary>
public CachedResourceCheckoutService(IAdhocCacheService adhocCacheService)
{
this.m_adhocCache = adhocCacheService;
}
/// <summary>
/// Javascript business rules bridge ctor
/// </summary>
internal JavascriptEngineBridge(JavascriptExecutor owner)
{
this.m_owner = owner;
this.m_adhocCache = ApplicationServiceContext.Current.GetService <IAdhocCacheService>();
}
/// <summary>
/// Creates cache service
/// </summary>
public DefaultPolicyDecisionService(IPasswordHashingService hashService, IAdhocCacheService cacheService = null) : base(hashService, cacheService)
{
}