/// <summary>
/// DI constructor
/// </summary>
public OrmBiDataProvider(IPolicyEnforcementService policyEnforcementService, IConfigurationManager configurationManager, IBiMetadataRepository biMetadataRepository = null, IBiPivotProvider biPivotProvider = null)
{
this.m_policyEnforcementService = policyEnforcementService;
this.m_configurationManager = configurationManager;
this.m_metadataRepository = biMetadataRepository;
this.m_pivotProvider = biPivotProvider;
}
/// <summary>
/// Initializes the file system queue
/// </summary>
public FileSystemDispatcherQueueService(IConfigurationManager configurationManager, IPolicyEnforcementService pepService)
{
this.m_configuration = configurationManager.GetSection <FileSystemDispatcherQueueConfigurationSection>();
if (!Directory.Exists(this.m_configuration.QueuePath))
{
Directory.CreateDirectory(this.m_configuration.QueuePath);
}
this.m_pepService = pepService;
// Listener thread
this.m_listenerThread = new Thread(() =>
{
while (true)
{
this.m_resetEvent.Wait();
while (this.m_notificationQueue.TryDequeue(out var result))
{
if (this.m_watchers.TryGetValue(result.QueueName, out var callbacks))
{
foreach (var cb in callbacks)
{
cb(result);
}
}
}
this.m_resetEvent.Reset();
}
});
this.m_listenerThread.IsBackground = true;
this.m_listenerThread.Name = "FileSystemListener";
this.m_listenerThread.Start();
}
/// <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>
/// Security challenge child handler
/// </summary>
public SecurityPolicyChildHandler(IRepositoryService <SecurityDevice> deviceRepository, IRepositoryService <SecurityApplication> applicationRepository, IRepositoryService <SecurityRole> roleRepository, IPolicyEnforcementService pepService, IPolicyInformationService pipService)
{
this.m_pip = pipService;
this.m_pep = pepService;
this.m_roleRepository = roleRepository;
this.m_deviceRepository = deviceRepository;
this.m_applicationRepository = applicationRepository;
}
/// <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;
}
/// <summary>
/// Security challenge child handler
/// </summary>
public SecurityRoleUserChildHandler(IRepositoryService <SecurityRole> roleRepository,
IRepositoryService <SecurityUser> userRepository,
ISecurityRepositoryService securityRepository,
IRoleProviderService roleProvider,
IPolicyEnforcementService pepService)
{
this.m_userRepository = userRepository;
this.m_pep = pepService;
this.m_roleRepository = roleRepository;
this.m_securityRepository = securityRepository;
this.m_roleProvider = roleProvider;
}
/// <summary>
/// Creates a new entity merger service
/// </summary>
public MdmEntityMerger(IDataPersistenceService <Bundle> batchService, IThreadPoolService threadPool, IPolicyEnforcementService policyEnforcement, IStoredQueryDataPersistenceService <TEntity> persistenceService, IFastQueryDataPersistenceService <EntityRelationship> relationshipPersistence)
{
this.m_dataManager = MdmDataManagerFactory.GetDataManager <TEntity>();
this.m_batchPersistence = batchService;
this.m_pepService = policyEnforcement;
this.m_entityPersistence = persistenceService;
this.m_relationshipPersistence = relationshipPersistence;
this.m_threadPool = threadPool;
if (this.m_relationshipPersistence is IReportProgressChanged irpc)
{
irpc.ProgressChanged += (o, e) => this.ProgressChanged?.Invoke(o, e); // pass through progress reports
}
}
/// <summary>
/// Creates a new instance of this pub-sub manager
/// </summary>
public AdoPubSubManager(IServiceManager serviceManager,
IPolicyEnforcementService policyEnforcementService,
IConfigurationManager configurationManager,
ISecurityRepositoryService securityRepository,
IDataCachingService cachingService)
{
this.m_cache = cachingService;
this.m_configuration = configurationManager.GetSection <AdoPubSubConfigurationSection>();
this.m_policyEnforcementService = policyEnforcementService;
this.m_securityRepository = securityRepository;
this.m_serviceManager = serviceManager;
this.m_configuration.Provider.UpgradeSchema("SanteDB.Persistence.PubSub.ADO");
}
/// <summary>
/// Creates a new instance of the ADO cache
/// </summary>
public AdoPersistenceService(IServiceManager serviceManager, IPolicyEnforcementService policyEnforcementService)
{
this.m_policyEnforcementService = policyEnforcementService;
var tracer = new Tracer(AdoDataConstants.TraceSourceName);
// Apply the migrations
this.m_tracer.TraceInfo("Scanning for schema updates...");
// TODO: Refactor this to a common library within the ORM tooling
this.GetConfiguration().Provider.UpgradeSchema("SanteDB.Persistence.Data.ADO");
try
{
this.m_mapper = new ModelMapper(typeof(AdoPersistenceService).Assembly.GetManifestResourceStream(AdoDataConstants.MapResourceName));
List <IQueryBuilderHack> hax = new List <IQueryBuilderHack>()
{
new SecurityUserEntityQueryHack(), new RelationshipGuardQueryHack(), new CreationTimeQueryHack(this.m_mapper), new EntityAddressNameQueryHack()
};
if (this.GetConfiguration().DataCorrectionKeys.Any(k => k == "ConceptQueryHack"))
{
hax.Add(new ConceptQueryHack(this.m_mapper));
}
this.m_queryBuilder = new QueryBuilder(this.m_mapper, this.GetConfiguration().Provider,
hax.Where(o => o != null).ToArray()
);
// Bind subscription execution
serviceManager.AddServiceProvider(typeof(AdoSubscriptionExecutor));
}
catch (ModelMapValidationException ex)
{
tracer.TraceEvent(EventLevel.Error, "Error validating model map: {0}", ex);
throw ex;
}
catch (Exception ex)
{
tracer.TraceEvent(EventLevel.Error, "Error validating model map: {0}", ex);
throw ex;
}
}
/// <summary>
/// DI applet BI repository
/// </summary>
public AppletBiRepository(IAppletManagerService appletManager, IServiceManager serviceManager, IPolicyEnforcementService policyEnforcementService, IAppletSolutionManagerService solutionManagerService = null, IBiDataSource defaultDataSource = null)
{
this.m_appletManager = appletManager;
this.m_policyEnforcementService = policyEnforcementService;
this.m_solutionManagerService = solutionManagerService;
this.m_serviceManager = serviceManager;
this.m_defaultDataSource = defaultDataSource;
// Re-scans the loaded applets for definitions when the collection has changed
this.m_appletManager.Applets.CollectionChanged += (oa, ea) =>
{
this.LoadAllDefinitions();
};
if (this.m_solutionManagerService.Solutions is INotifyCollectionChanged notify)
{
notify.CollectionChanged += (oa, eo) =>
{
this.LoadAllDefinitions();
};
}
//this.LoadAllDefinitions();
}
/// <summary>
/// Create a new local metadata repository
/// </summary>
public GenericLocalMetadataRepository(IPolicyEnforcementService policyService, ILocalizationService localizationService, IPrivacyEnforcementService privacyService = null) : base(privacyService, policyService, localizationService) // No need for privacy on metadata
{
}
/// <summary>
/// DI constructor for persistent queue
/// </summary>
public DispatcherQueueEntryChildResource(IDispatcherQueueManagerService queueService, ILocalizationService localization, IPolicyEnforcementService pepService)
{
this.m_queueService = queueService;
this.m_localizationService = localization;
this.m_policyEnforcementService = pepService;
}
/// <summary>
/// CTOR for guard service
/// </summary>
public GenericSanteGuardRepository(IPrivacyEnforcementService privacyService, IPolicyEnforcementService policyService, ILocalizationService localizationService) : base(privacyService, policyService, localizationService)
{
}
/// <summary>
/// Creates a new DI injected policy manager
/// </summary>
public AdoRoleProvider(IConfigurationManager configurationManager, IPolicyEnforcementService pepService)
{
this.m_configuration = configurationManager.GetSection <AdoPersistenceConfigurationSection>();
this.m_policyService = pepService;
}
/// <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 generic local repository with specified privacy service
/// </summary>
public GenericLocalRepository(IPrivacyEnforcementService privacyService, IPolicyEnforcementService policyService, ILocalizationService localizationService)
{
this.m_privacyService = privacyService;
this.m_policyService = policyService;
this.m_localizationService = localizationService;
}
/// <summary>
/// DI constructor
/// </summary>
public FileSystemQueueService(IConfigurationManager configurationManager, IPolicyEnforcementService pepService) : base(configurationManager, pepService)
{
}
/// <summary>
/// Local AA
/// </summary>
public LocalAssigningAuthorityRepository(IPolicyEnforcementService policyService, ILocalizationService localizationService, IPrivacyEnforcementService privacyService = null) : base(policyService, localizationService, privacyService)
{
}
/// <summary>
/// DI constructor
/// </summary>
public SanteGuardSecurityAttributeRepository(IPrivacyEnforcementService privacyService, IPolicyEnforcementService policyService, ILocalizationService localizationService) : base(privacyService, policyService, localizationService)
{
}
/// <summary>
/// DI constructor
/// </summary>
public AdoIdentityProvider(IPolicyEnforcementService policyEnforcement)
{
this.m_policyEnforcement = policyEnforcement;
}
/// <summary>
/// Creates a new template repository
/// </summary>
public LocalTemplateDefinitionRepositoryService(IPolicyEnforcementService policyService, ILocalizationService localizationService, IPrivacyEnforcementService privacyService = null) : base(policyService, localizationService, privacyService)
{
}
/// <summary>
/// Local extension type repository
/// </summary>
public LocalExtensionTypeRepository(IPolicyEnforcementService policyService, ILocalizationService localizationService, IPrivacyEnforcementService privacyService = null) : base(policyService, localizationService, privacyService)
{
}
/// <summary>
/// DI constructor
/// </summary>
public AdoDeviceIdentityProvider(IConfigurationManager configurationManager, IPolicyEnforcementService pepService)
{
this.m_policyService = pepService;
this.m_configuration = ApplicationServiceContext.Current.GetService <IConfigurationManager>().GetSection <AdoPersistenceConfigurationSection>();
}
/// <summary>
/// Process the file directory
/// </summary>
public FileMatchConfigurationProvider(IConfigurationManager configurationManager, IPolicyEnforcementService pepService, ILocalizationService localizationService)
{
this.m_pepService = pepService;
this.m_configuration = configurationManager.GetSection <FileMatchConfigurationSection>();
this.m_localizationService = localizationService;
// When application has started
ApplicationServiceContext.Current.Started += (o, e) =>
{
try
{
if (this.m_configuration == null)
{
this.m_matchConfigurations = new ConcurrentDictionary <string, ConfigCacheObject>();
return;
}
this.m_matchConfigurations = new ConcurrentDictionary <string, ConfigCacheObject>();
this.m_tracer.TraceInfo("Loading match configurations...");
foreach (var configDir in this.m_configuration.FilePath)
{
if (!Path.IsPathRooted(configDir.Path))
{
configDir.Path = Path.Combine(Path.GetDirectoryName(this.GetType().Assembly.Location), configDir.Path);
}
if (!Directory.Exists(configDir.Path))
{
this.m_tracer.TraceWarning("Skipping {0} because it doesn't exist!", configDir.Path);
}
else
{
foreach (var fileName in Directory.GetFiles(configDir.Path, "*.xml"))
{
this.m_tracer.TraceInfo("Attempting load of {0}", fileName);
try
{
MatchConfiguration config = null;
using (var fs = System.IO.File.OpenRead(fileName))
{
config = MatchConfiguration.Load(fs);
}
var originalPath = fileName;
if (!Guid.TryParse(Path.GetFileNameWithoutExtension(fileName), out Guid uuid) || uuid != config.Uuid) // Migrate the config
{
originalPath = Path.Combine(configDir.Path, $"{config.Uuid}.xml");
File.Move(fileName, originalPath);
using (var fs = File.Create(originalPath))
{
config.Save(fs);
}
}
this.m_matchConfigurations.TryAdd(config.Id, new ConfigCacheObject()
{
OriginalFilePath = originalPath,
Configuration = config
});
}
catch (Exception ex)
{
this.m_tracer.TraceWarning("Could not load {0} - SKIPPING - {1}", fileName, ex.Message);
}
}
}
}
}
catch (Exception ex)
{
this.m_tracer.TraceError("Could not fully load configuration for matching : {0}", ex);
}
};
}
/// <summary>
/// Entity relationship repository
/// </summary>
public LocalEntityRelationshipRepository(IPolicyEnforcementService policyService, ILocalizationService localizationService, IPrivacyEnforcementService privacyService = null) : base(privacyService, policyService, localizationService)
{
}
/// <summary>
/// DI constructor
/// </summary>
public LocalManufacturedMaterialRepository(IPolicyEnforcementService policyService, ILocalizationService localizationService, IPrivacyEnforcementService privacyService = null) : base(policyService, localizationService, privacyService)
{
}
/// <summary>
/// Creates a new generic local concept repository
/// </summary>
public GenericLocalConceptRepository(IPolicyEnforcementService policyService, ILocalizationService localizationService, IPrivacyEnforcementService privacyService = null) : base(policyService, localizationService, privacyService)
{
}
/// <summary>
/// Local provider repository
/// </summary>
public LocalProviderRepository(IPolicyEnforcementService policyService, ILocalizationService localizationService, IPrivacyEnforcementService privacyService = null) : base(policyService, localizationService, privacyService)
{
}
/// <summary>
/// DI constructor
/// </summary>
public LocalSecurityApplicationRepository(IPolicyEnforcementService policyService, ILocalizationService localizationService, IPrivacyEnforcementService privacyService = null) : base(policyService, localizationService, privacyService)
{
}
/// <summary>
/// DI constructor for ADO CHallenge
/// </summary>
public AdoSecurityChallengeProvider(IConfigurationManager configurationManager, IPolicyEnforcementService pepService)
{
this.m_policyEnforcementService = pepService;
this.m_configuration = configurationManager.GetSection <AdoPersistenceConfigurationSection>();
this.m_securityConfiguration = configurationManager.GetSection <SecurityConfigurationSection>();
}
