Example #1
0
 public SystemConfigurationController(IAuthenticationService authenticationService, IGridConfigService gridConfigService,
                                      IDiagnosticService diagnosticService, ISystemConfigurationService systemConfigurationService)
     : base(authenticationService, diagnosticService, systemConfigurationService)
 {
     _systemConfigurationService = systemConfigurationService;
     _gridConfigService          = gridConfigService;
 }
Example #2
0
        /// <summary>
        /// Validate the message
        /// </summary>
        internal static void Validate(IMessage message, ISystemConfigurationService config, List <IResultDetail> dtls, IServiceProvider context)
        {
            // Structure validation
            PipeParser pp = new PipeParser()
            {
                ValidationContext = new DefaultValidation()
            };

            try
            {
                pp.Encode(message);
            }
            catch (Exception e)
            {
                dtls.Add(new ValidationResultDetail(ResultDetailType.Error, e.Message, e));
            }

            // Validation of sending application
            try
            {
                Terser msgTerser = new Terser(message);
                object obj       = msgTerser.getSegment("MSH") as NHapi.Model.V25.Segment.MSH;
                if (obj != null)
                {
                    var msh      = obj as NHapi.Model.V25.Segment.MSH;
                    var domainId = new ComponentUtility()
                    {
                        Context = context
                    }.CreateDomainIdentifier(msh.SendingApplication, dtls);
                    if (!config.IsRegisteredDevice(domainId))
                    {
                        dtls.Add(new UnrecognizedSenderResultDetail(domainId));
                    }
                }
                else
                {
                    obj = msgTerser.getSegment("MSH") as NHapi.Model.V231.Segment.MSH;
                    if (obj != null)
                    {
                        var msh      = obj as NHapi.Model.V231.Segment.MSH;
                        var domainId = new ComponentUtility()
                        {
                            Context = context
                        }.CreateDomainIdentifier(msh.SendingApplication, dtls);
                        if (!config.IsRegisteredDevice(domainId))
                        {
                            dtls.Add(new UnrecognizedSenderResultDetail(domainId));
                        }
                    }
                    else
                    {
                        dtls.Add(new MandatoryElementMissingResultDetail(ResultDetailType.Error, "Missing MSH", "MSH"));
                    }
                }
            }
            catch (Exception e)
            {
                dtls.Add(new ResultDetail(ResultDetailType.Error, e.Message, e));
            }
        }
Example #3
0
        /// <summary>
        /// Enrich the registration event
        /// </summary>
        internal void EnrichRegistrationEvent(IDbConnection conn, IDbTransaction tx, RegistrationEvent hsrEvent)
        {
            decimal tryDec;
            ISystemConfigurationService configService = ApplicationContext.ConfigurationService;

            // Create a query based on the person
            Person subject = hsrEvent.FindComponent(HealthServiceRecordSiteRoleType.SubjectOf) as Person;

            if (subject.AlternateIdentifiers.Exists(o => o.Domain == configService.OidRegistrar.GetOid(ClientRegistryOids.CLIENT_CRID).Oid))
            {
                subject = new Person()
                {
                    AlternateIdentifiers = new List <DomainIdentifier>(subject.AlternateIdentifiers.FindAll(o => o.Domain == configService.OidRegistrar.GetOid(ClientRegistryOids.CLIENT_CRID).Oid)),
                    Status = StatusType.Normal
                }
            }
            ;
            else if (subject.AlternateIdentifiers.Exists(o => o is AuthorityAssignedDomainIdentifier))
            {
                subject = new Person()
                {
                    AlternateIdentifiers = new List <DomainIdentifier>(subject.AlternateIdentifiers.FindAll(o => o is AuthorityAssignedDomainIdentifier)),
                    Status = StatusType.Normal
                }
            }
            ;
            else
            {
                subject = new Person()
                {
                    AlternateIdentifiers = new List <DomainIdentifier>(subject.AlternateIdentifiers),
                    Status = StatusType.Normal
                }
            };

            QueryEvent        query = new QueryEvent();
            RegistrationEvent evt   = new RegistrationEvent();

            query.Add(evt, "SUBJ", HealthServiceRecordSiteRoleType.SubjectOf, null);
            evt.Status = StatusType.Active | StatusType.Obsolete;
            evt.Add(subject, "SUBJ", HealthServiceRecordSiteRoleType.SubjectOf, null);
            query.Add(new QueryParameters()
            {
                MatchingAlgorithm = MatchAlgorithm.Exact,
                MatchStrength     = MatchStrength.Exact
            }, "FLTR", HealthServiceRecordSiteRoleType.FilterOf, null);
            var tRecordIds = QueryRecord(query);

            if (tRecordIds.Length != 1)
            {
                throw new MissingPrimaryKeyException(ApplicationContext.LocaleService.GetString("DBCF004"));
            }
            else if (tRecordIds[0].Domain != configService.OidRegistrar.GetOid(ClientRegistryOids.REGISTRATION_EVENT).Oid)
            {
                throw new MissingPrimaryKeyException(ApplicationContext.LocaleService.GetString("DBCF005"));
            }

            tryDec = Decimal.Parse(tRecordIds[0].Identifier);
            hsrEvent.AlternateIdentifier = tRecordIds[0];
        }
Example #4
0
        /// <summary>
        /// Persists the item
        /// </summary>
        public MARC.HI.EHRS.SVC.Core.DataTypes.VersionedDomainIdentifier Persist(System.Data.IDbConnection conn, System.Data.IDbTransaction tx, System.ComponentModel.IComponent data, bool isUpdate)
        {
            ISystemConfigurationService configSvc = ApplicationContext.ConfigurationService; //ApplicationContext.Current.GetService(typeof(ISystemConfigurationService)) as ISystemConfigurationService;

            // In order to persist we first must get the id of the hsr
            var componentRef = data as HealthServiceRecordComponentRef;

            if (componentRef.AlternateIdentifier.Domain.Equals(configSvc.OidRegistrar.GetOid(ClientRegistryOids.REGISTRATION_EVENT).Oid))
            {
                componentRef.Id = Decimal.Parse(componentRef.AlternateIdentifier.Identifier);
            }
            else
            {
                throw new ConstraintException("Referenced record cannot be found in this repository");
            }

            // Link the records if the record is a hard link
            if (!(componentRef.Site as HealthServiceRecordSite).IsSymbolic)
            {
                LinkHSRRecord(conn, tx, componentRef);
            }

            return(new MARC.HI.EHRS.SVC.Core.DataTypes.VersionedDomainIdentifier()
            {
                Domain = ClientRegistryOids.EVENT_OID,
                Identifier = componentRef.Id.ToString()
            });
        }
        /// <summary>
        /// De-persist the MI
        /// </summary>
        public System.ComponentModel.IComponent DePersist(System.Data.IDbConnection conn, decimal identifier, System.ComponentModel.IContainer container, HealthServiceRecordSiteRoleType?roleType, bool loadFast)
        {
            // De-persist the masking record
            ISystemConfigurationService sysConfig = ApplicationContext.ConfigurationService;

            // Load the observation event
            MaskingIndicator retVal = new MaskingIndicator();

            using (IDbCommand cmd = DbUtil.CreateCommandStoredProc(conn, null))
            {
                cmd.CommandText = "get_psn_msk_ind";
                cmd.Parameters.Add(DbUtil.CreateParameterIn(cmd, "msk_id_in", DbType.Decimal, identifier));

                // Execute the reader
                using (IDataReader rdr = cmd.ExecuteReader())
                {
                    if (rdr.Read())
                    {
                        retVal.MaskingCode = new MARC.HI.EHRS.SVC.Core.DataTypes.CodeValue(Convert.ToString(rdr["msk_cs"]));
                    }
                }

                // Append to the container
                if (container is Person)
                {
                    (container as Person).Add(retVal, Guid.NewGuid().ToString(), MARC.HI.EHRS.SVC.Core.ComponentModel.HealthServiceRecordSiteRoleType.FilterOf, null);
                }
            }

            return(retVal);
        }
        /// <summary>
        /// Create custodial data from either a RepositoryDevice or a HealthcareParticipant
        /// </summary>
        private Everest.RMIM.UV.NE2008.MFMI_MT700701UV01.Custodian CreateCustodian(RegistrationEvent registrationEvent, TargetConfiguration configuration)
        {
            ISystemConfigurationService sysConfig = this.Context.GetService(typeof(ISystemConfigurationService)) as ISystemConfigurationService;

            var subject = registrationEvent.FindComponent(SVC.Core.ComponentModel.HealthServiceRecordSiteRoleType.SubjectOf) as Person;
            var iiSet   = new List <II>(CreateIISet(subject.AlternateIdentifiers));

            iiSet.RemoveAll(ii => !configuration.NotificationDomain.Exists(o => o.Domain.Equals(ii.Root)));

            var oidData = sysConfig.OidRegistrar.FindData(iiSet[0].Root);

            if (oidData == null)
            {
                throw new InvalidOperationException("Cannot find notification settings for " + oidData);
            }

            var retVal = new Everest.RMIM.UV.NE2008.MFMI_MT700701UV01.Custodian(
                new Everest.RMIM.UV.NE2008.COCT_MT090003UV01.AssignedEntity()
                );

            // Device
            retVal.AssignedEntity.SetAssignedPrincipalChoiceList(
                new Everest.RMIM.UV.NE2008.COCT_MT090303UV01.Device(
                    SET <II> .CreateSET(new II(oidData.Attributes.Find(o => o.Key == "CustodialDeviceId").Value ?? oidData.Oid)),
                    null,
                    oidData.Attributes.Find(o => o.Key == "CustodialDeviceName").Value ?? oidData.Description
                    )
                );
            retVal.AssignedEntity.Id = SET <II> .CreateSET(new II(oidData.Oid));

            return(retVal);
        }
Example #7
0
        /// <summary>
        /// Handle HL7 message
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>
        public NHapi.Base.Model.IMessage HandleMessage(HL7.TransportProtocol.Hl7MessageReceivedEventArgs e)
        {
            ISystemConfigurationService config = this.Context.GetService(typeof(ISystemConfigurationService)) as ISystemConfigurationService;
            ILocalizationService        locale = this.Context.GetService(typeof(ILocalizationService)) as ILocalizationService;

            // Get the message type
            IMessage response = null;

            if (e.Message.Version == "2.5")
            {
                // Get the MSH segment
                var msh = e.Message.GetStructure("MSH") as MSH;
                switch (msh.MessageType.TriggerEvent.Value)
                {
                case "Q22":
                    response = HandlePdqQuery(e.Message as QBP_Q21, e);
                    break;

                default:
                    response = MessageUtil.CreateNack(e.Message, "AR", "201", locale.GetString("HL7201"), config);
                    break;
                }
            }

            // response still null?
            if (response == null)
            {
                response = MessageUtil.CreateNack(e.Message, "AR", "203", locale.GetString("HL7203"), config);
            }
            return(response);
        }
Example #8
0
        public void VisualiseSchemaAsMap_returns_viewcontroller_with_mapdefaultzoom_as_from_systemconfiguration_service()
        {
            //arrange
            IList <FilterCriteria> filter = null;
            DataSetSchema          schema = null;
            var ds = new DataSet();

            ds.Tables.Add(ReturnDataTable(null, 0)); //table1
            ds.Tables.Add(ReturnDataTable(null, 1)); //table2
            ds.Tables.Add(ReturnDataTable(null, 0)); //table3

            var mock = new Mock <IDataSetDetailSqlRepo>();

            mock.Setup(x => x.ExecuteQueryVisualiseSchemaMap(_repositoryDataSetDetail.DbConnectionString, null, null)).Returns(ds);
            _sqlRepo = mock.Object;
            var mock2 = new Mock <ISystemConfigurationService>();

            mock2.Setup(x => x.GetSystemConfigurations()).Returns(new SystemConfigurationObject()
            {
                MapDefaultZoom = "3"
            });
            _systemConfigurationService = mock2.Object;
            var sut = new DataSetDetailService(_systemConfigurationService, _repositoryDataSetDetail, _dataSetSchemaService, _sqlRepo, _sqlColumnTextFormatter);
            //act
            var result = sut.VisualiseSchemaAsMap(filter, schema);

            //assert
            Assert.AreEqual(3, result.MapDefaultZoom);
            //cleanup
            _sqlRepo = null;
            _systemConfigurationService = null;
        }
        /// <summary>
        /// Handle message
        /// </summary>
        public NHapi.Base.Model.IMessage HandleMessage(HL7.TransportProtocol.Hl7MessageReceivedEventArgs e)
        {
            // Get the config service
            ISystemConfigurationService config = Context.GetService(typeof(ISystemConfigurationService)) as ISystemConfigurationService;

            return(MessageUtil.CreateNack(e.Message, "AR", "200", "Unsupported message type", config));
        }
Example #10
0
        public void TestInit()
        {
            // ObjectFactory.Initialize(
            //x =>
            //{
            //    x.For<IUnitOfWorkFactory>().Use<MemoryUnitOfWorkFactory>();
            //    x.For(typeof(IRepository<>)).Use(typeof(MemoryRepository<>));
            //    x.For<ICategoryService>().Use<CategoryService>();
            //    x.For<ISystemConfigurationService>().Use<SystemConfigurationService>();
            //    x.For<>()

            //}

            //);

            //var mock2 = new Mock<ICategoryService>();
            //_categoryService = mock2.Object;
            var mock3 = new Mock <ISystemConfigurationService>();

            mock3.Setup(x => x.GetSystemConfigurations()).Returns(new SystemConfigurationObject());
            _systemConfigurationService = mock3.Object;

            _mockResponseBase    = new Mock <HttpResponseBase>();
            _mockHttpContextBase = new Mock <HttpContextBase>();
        }
Example #11
0
 public WildlifeClassController(IWildlifeCategoryService wildlifeCategoryService, ILogService logService,
                                ISystemConfigurationService systemConfigurationService)
 {
     _wildlifeCategoryService = wildlifeCategoryService;
     _logService = logService;
     _systemConfigurationService = systemConfigurationService;
 }
 public SystemConfigurationController(ILog log, ISystemConfigurationService systemConfigurationService, IFeatureService featureService, ILocalizationService localizationService, IUserService userService, ISiteService siteService)
     : base(log, localizationService, userService, siteService)
 {
     this.log = log;
      this.systemConfigurationService = systemConfigurationService;
      this.featureService = featureService;
 }
Example #13
0
 public TemplateController(ITemplateService templateService, ILogService logService,
                           ISystemConfigurationService systemConfigurationService, IArticleAttachService articleAttachService)
 {
     _templateService            = templateService;
     _logService                 = logService;
     _systemConfigurationService = systemConfigurationService;
     _articleAttachService       = articleAttachService;
 }
Example #14
0
 public RouteController(IRouteService routeService, ILogService logService,
                        ISystemConfigurationService systemConfigurationService, IRouteViewSpotService routeViewSpotService)
 {
     _routeService               = routeService;
     _routeViewSpotService       = routeViewSpotService;
     _logService                 = logService;
     _systemConfigurationService = systemConfigurationService;
 }
Example #15
0
        /// <summary>
        /// Persist the specified data
        /// </summary>
        public VersionedDomainIdentifier Persist(IDbConnection conn, IDbTransaction tx, System.ComponentModel.IComponent data, bool isUpdate)
        {
            ISystemConfigurationService configServce = ApplicationContext.ConfigurationService; //ApplicationContext.Current.GetService(typeof(ISystemConfigurationService)) as ISystemConfigurationService;
            // First, we must determine if we're going to be performing an update or a put
            RegistrationEvent hsr = data as RegistrationEvent;

            try
            {
                // Does this record have an identifier that is valid?
                if (hsr.AlternateIdentifier != null && !hsr.AlternateIdentifier.Domain.Equals(configServce.OidRegistrar.GetOid(ClientRegistryOids.REGISTRATION_EVENT).Oid))
                {
                    throw new InvalidOperationException(String.Format("Could not find an identifier for the event that falls in the custodian domain '{0}'", configServce.OidRegistrar.GetOid(ClientRegistryOids.REGISTRATION_EVENT).Oid));
                }
                else if (hsr.AlternateIdentifier != null)
                {
                    hsr.Id = Decimal.Parse(hsr.AlternateIdentifier.Identifier);
                }
                else if (isUpdate && hsr.Site == null)
                {
                    throw new ArgumentException("Cannot update an event that is not identified");
                }

                // Is there a parent that we can grab a language code from
                var parent = DbUtil.GetRegistrationEvent(data);

                // Default language code
                hsr.LanguageCode = hsr.LanguageCode ?? (parent != null ? parent.LanguageCode : configServce.JurisdictionData.DefaultLanguageCode);

                // Create an HSR event if this is not one
                if (!isUpdate || hsr.AlternateIdentifier == null)
                {
                    hsr.AlternateIdentifier = CreateHSRRecord(conn, tx, hsr);
                    hsr.Id = Convert.ToDecimal(hsr.AlternateIdentifier.Identifier);
                    hsr.VersionIdentifier = Convert.ToDecimal(hsr.AlternateIdentifier.Version);

                    // Is there any sort of linkage we need to create
                    if (hsr.Site != null && hsr.Site.Container != null &&
                        !(hsr.Site as HealthServiceRecordSite).IsSymbolic)
                    {
                        LinkHSRRecord(conn, tx, hsr);
                    }
                }
                else
                {
                    hsr.VersionIdentifier           = CreateHSRVersion(conn, tx, hsr);
                    hsr.AlternateIdentifier.Version = hsr.VersionIdentifier.ToString();
                }

                DbUtil.PersistComponents(conn, tx, isUpdate, this, hsr);
            }
            catch (Exception ex)
            {
                Trace.TraceError(ex.ToString());
                throw;
            }

            return(hsr.AlternateIdentifier);
        }
Example #16
0
 /// <summary>
 /// Create and initialize an instance of the LoginController class.
 /// </summary>
 /// <param name="log"></param>
 /// <param name="authenticationService"></param>
 /// <param name="systemConfigurationService"></param>
 /// <param name="messageService"></param>
 /// <param name="localizationService"></param>
 /// <param name="userService"></param>
 /// <param name="siteService"></param>
 public LoginController(ILog log, IAuthenticationService authenticationService, ISystemConfigurationService systemConfigurationService, 
                       IMessageService messageService, ILocalizationService localizationService, IUserService userService, ISiteService siteService)
     : base(log, localizationService, userService, siteService)
 {
     this.log = log;
      this.authenticationService = authenticationService;
      this.messageService = messageService;
      this.systemConfigurationService = systemConfigurationService;
 }
Example #17
0
        /// <summary>
        /// Get container
        /// </summary>
        public IContainer GetContainer(MARC.HI.EHRS.SVC.Core.DataTypes.VersionedDomainIdentifier containerId, bool loadFast)
        {
            // Get the persister that will handle the HealthServiceRecord type

            var persister = m_persisters.Values.FirstOrDefault(o => o is IQueryComponentPersister && (o as IQueryComponentPersister).ComponentTypeOid == containerId.Domain);

            if (persister == null)
            {
                persister = GetPersister(typeof(RegistrationEvent));
            }

            ISystemConfigurationService configService = Context.GetService(typeof(ISystemConfigurationService)) as ISystemConfigurationService;

            DbUtil.ClearPersistedCache();

            if (persister != null)
            {
                IDbConnection conn = null;
                try
                {
                    conn = DatabasePersistenceService.ReadOnlyConnectionManager.GetConnection();

                    // Is the record something that we have access to?
                    //if (containerId.Domain != null && !containerId.Domain.Equals(configService.OidRegistrar.GetOid(ClientRegistryOids.REGISTRATION_EVENT).Oid))
                    //    throw new ArgumentException(String.Format("The record OID '{0}' cannot be retrieved by this repository, expecting OID '{1}'",
                    //        containerId.Domain, configService.OidRegistrar.GetOid(ClientRegistryOids.REGISTRATION_EVENT).Oid));
                    if (persister == null)
                    {
                        throw new ArgumentException(String.Format("The record type OID '{0}' cannot be retrieved by this repository",
                                                                  containerId.Domain));
                    }
                    decimal tryDec = default(decimal);

                    if (Decimal.TryParse(containerId.Identifier, out tryDec))
                    {
                        return(persister.DePersist(conn, tryDec, null, null, loadFast) as IContainer);
                    }
                    else
                    {
                        throw new ArgumentException(String.Format("The identifier '{0}' is not a valid identifier for this repository", containerId.Identifier));
                    }
                }
                finally
                {
                    if (conn != null)
                    {
                        DatabasePersistenceService.ConnectionManager.ReleaseConnection(conn);
                    }
                }
            }
            else
            {
                Trace.TraceError("Can't find a persistence handler for type '{0}'", containerId.Domain);
                throw new DataException("Can't persist type HealthServiceRecordEvent");
            }
        }
Example #18
0
 public DownloadController(IDataSetSchemaService dataSetSchemaService,
                           IDataSetDetailService dataSetDetailService,
                           ICategoryService categoryService,
                           ISystemConfigurationService systemConfigurationService)
     : base(systemConfigurationService, categoryService)
 {
     _dataSetSchemaService = dataSetSchemaService;
     _dataSetDetailService = dataSetDetailService;
     _categoryService      = categoryService;
 }
 public WildlifeManagerController(IWildlifeManagerService wildlifeManagerService, ILogService logService,
                                  ISystemConfigurationService systemConfigurationService, IArticleAttachService articleAttachService,
                                  IWildlifeContentService wildlifeContentService)
 {
     _wildlifeManagerService     = wildlifeManagerService;
     _logService                 = logService;
     _systemConfigurationService = systemConfigurationService;
     _articleAttachService       = articleAttachService;
     _wildlifeContentService     = wildlifeContentService;
 }
Example #20
0
 public PublicityController(IPublicityContentService publicityContentService, ILogService logService, IPublicityTypesService publicityTypesService,
                            IPublicityCategoryService publicityCategoryService, ISystemConfigurationService systemConfigurationService, IArticleAttachService articleAttachService)
 {
     _PublicityContentService = publicityContentService;
     _logService                 = logService;
     _publicityTypesService      = publicityTypesService;
     _publicityCategoryService   = publicityCategoryService;
     _systemConfigurationService = systemConfigurationService;
     _articleAttachService       = articleAttachService;
 }
 public ArticleCategoryController(IArticleCategoryService articleCategoryService, ILogService logService,
                                  ISystemConfigurationService systemConfigurationService, IArticleAttachService articleAttachService,
                                  IArticleArticleCategoryService articleArticleCategoryService)
 {
     _articleCategoryService        = articleCategoryService;
     _logService                    = logService;
     _systemConfigurationService    = systemConfigurationService;
     _articleAttachService          = articleAttachService;
     _articleArticleCategoryService = articleArticleCategoryService;
 }
Example #22
0
        public void TestInit()
        {
            var mock = new Mock <ISystemConfigurationService>();

            mock.Setup(x => x.GetSystemConfigurations()).Returns(new SystemConfigurationObject());
            mock.Setup(x => x.AppSettingsInt("DefaultGraphPageSize")).Returns(10);
            mock.Setup(x => x.AppSettingsInt("DefaultViewPageSize")).Returns(103);

            _sysConfigService = mock.Object;
        }
Example #23
0
        /// <summary>
        /// Create an HSR record
        /// </summary>
        private VersionedDomainIdentifier CreateHSRRecord(IDbConnection conn, IDbTransaction tx, ChangeSummary hsr)
        {
            IDbCommand cmd = DbUtil.CreateCommandStoredProc(conn, tx);

            cmd.CommandText = "crt_hsr";

            // Get the terminology service
            ISystemConfigurationService iscs = ApplicationContext.ConfigurationService; //ApplicationContext.Current.GetService(typeof(ISystemConfigurationService)) as ISystemConfigurationService;

            // Parameters
            // classifier = 0x400 = Change Summary
            cmd.Parameters.Add(DbUtil.CreateParameterIn(cmd, "hsr_cls_in", DbType.Decimal, RegistrationEventType.ComponentEvent | RegistrationEventType.Revise));
            // event type code
            cmd.Parameters.Add(DbUtil.CreateParameterIn(cmd, "evt_typ_cd_id_in", DbType.Decimal, DbUtil.CreateCodedValue(conn, tx, hsr.ChangeType)));
            // refuted indicator
            cmd.Parameters.Add(DbUtil.CreateParameterIn(cmd, "refuted_ind_in", DbType.Boolean, false));

            decimal?efftTimeId = null;

            if (hsr.EffectiveTime != null)
            {
                efftTimeId = DbUtil.CreateTimeset(conn, tx, hsr.EffectiveTime);
            }

            cmd.Parameters.Add(DbUtil.CreateParameterIn(cmd, "efft_ts_set_id_in", DbType.Decimal, efftTimeId == null ? (object)DBNull.Value : efftTimeId.Value));
            // status code
            cmd.Parameters.Add(DbUtil.CreateParameterIn(cmd, "status_cs_in", DbType.Decimal, hsr.Status == null ? (object)DBNull.Value : (int)hsr.Status));
            // authored time
            cmd.Parameters.Add(DbUtil.CreateParameterIn(cmd, "aut_utc_in", DbType.DateTime, hsr.Timestamp == default(DateTime) ? (object)DBNull.Value : hsr.Timestamp));
            // language code
            cmd.Parameters.Add(DbUtil.CreateParameterIn(cmd, "lang_cs_in", DbType.String, hsr.LanguageCode));

            // Execute the command
            IDataReader resultRdr = cmd.ExecuteReader();

            try
            {
                // Create the return value
                VersionedDomainIdentifier id = new VersionedDomainIdentifier();
                if (!resultRdr.Read())
                {
                    return(null);
                }

                id.Version    = Convert.ToString(resultRdr["VRSN_ID"]);
                id.Identifier = Convert.ToString(resultRdr["ID"]);
                id.Domain     = iscs.OidRegistrar.GetOid(ClientRegistryOids.EVENT_OID).Oid;

                return(id);
            }
            finally
            {
                resultRdr.Close();
            }
        }
Example #24
0
 public ViewSpotController(IViewSpotService viewSpotService, ILogService logService,
                           ISystemConfigurationService systemConfigurationService, IArticleAttachService articleAttachService,
                           IViewSpotContentService ViewSpotContentService, IRouteViewSpotService routeViewSpotService)
 {
     _viewSpotService            = viewSpotService;
     _logService                 = logService;
     _systemConfigurationService = systemConfigurationService;
     _articleAttachService       = articleAttachService;
     _viewSpotContentService     = ViewSpotContentService;
     _routeViewSpotService       = routeViewSpotService;
 }
Example #25
0
 public BaseController(ISystemConfigurationService systemConfigurationService, ICategoryService categoryService)
 {
     _systemConfigurationService = systemConfigurationService;
     _categoryService            = categoryService;
     if (_systemConfigurationService != null)
     {
         ViewBag.CouncilTitle         = _systemConfigurationService.GetSystemConfigurations().CouncilName;//ConfigurationManager.AppSettings["CouncilName"];
         ViewBag.CouncilUrl           = _systemConfigurationService.GetSystemConfigurations().CouncilUrl;
         ViewBag.AnalyticsTrackingRef = _systemConfigurationService.GetSystemConfigurations().AnalyticsTrackingRef;
     }
 }
 public DataSetDetailService(ISystemConfigurationService systemConfigurationService
                             , IRepository <DataSetDetail> repository
                             , IDataSetSchemaService dataSetSchemaService
                             , IDataSetDetailSqlRepo dataSetDetailSqlRepo, ISqlOrderByColumnAndDirectionFormatter sqlOrderByTextFormatter)
 {
     _systemConfigurationService = systemConfigurationService;
     _repository              = repository;
     _dataSetSchemaService    = dataSetSchemaService;
     _dataSetDetailSqlRepo    = dataSetDetailSqlRepo;
     _sqlOrderByTextFormatter = sqlOrderByTextFormatter;
 }
Example #27
0
 public RoleController(IRoleService roleService, ILogService logService, ISystemConfigurationService systemConfigurationService,
                       INavgationService navgationService, IArticleCategoryService articleCategoryService, IActionService actionService, IUserRoleService userRoleService)
 {
     _navgationService           = navgationService;
     _roleService                = roleService;
     _logService                 = logService;
     _systemConfigurationService = systemConfigurationService;
     _articleCategoryService     = articleCategoryService;
     _actionService              = actionService;
     _userRoleService            = userRoleService;
 }
        /// <summary>
        /// Notify the operation
        /// </summary>
        public void Notify(NotificationQueueWorkItem workItem)
        {
            // configuration service
            ISystemConfigurationService config = this.Context.GetService(typeof(ISystemConfigurationService)) as ISystemConfigurationService;
            ILocalizationService        locale = this.Context.GetService(typeof(ILocalizationService)) as ILocalizationService;

            // Common message bits we need to update
            IMessage notificationMessage = null;
            MSH      msh = null;
            PID      pid = null;
            EVN      evn = null;
            PV1      pv1 = null;


            // Identify the work item action
            switch (workItem.Action)
            {
            case MARC.HI.EHRS.CR.Notification.PixPdq.Configuration.ActionType.Create:
            case MARC.HI.EHRS.CR.Notification.PixPdq.Configuration.ActionType.DuplicatesResolved:
            case MARC.HI.EHRS.CR.Notification.PixPdq.Configuration.ActionType.Update:
            {
                ADT_A05 message = new ADT_A05();
                msh = message.MSH;
                pid = message.PID;
                evn = message.EVN;
                pv1 = message.PV1;
                notificationMessage = message;
                msh.MessageType.TriggerEvent.Value = "A31";
                break;
            }
            }

            // Populate the MSH header first
            this.UpdateMSH(msh, config);

            // Populate the EVN segment
            evn.EventTypeCode.Value         = workItem.Event.Mode.ToString();
            evn.RecordedDateTime.Time.Value = (TS)workItem.Event.Timestamp;

            // Populate the PID segment
            Person subject = workItem.Event.FindComponent(SVC.Core.ComponentModel.HealthServiceRecordSiteRoleType.SubjectOf) as Person;

            this.UpdatePID(subject, pid, config);
            pv1.PatientClass.Value = "N";

            // Send
            var queueItem = new Hl7MessageQueue.MessageQueueWorkItem(this.Target, notificationMessage);

            if (!queueItem.TrySend())
            {
                Trace.TraceWarning(locale.GetString("NTFW005"));
                Hl7MessageQueue.Current.EnqueueMessageItem(queueItem);
            }
        }
        public void TestInit()
        {
            _mockResponseBase    = new Mock <HttpResponseBase>();
            _mockRequestBase     = new Mock <HttpRequestBase>();
            _mockHttpContextBase = new Mock <HttpContextBase>();
            var mock2 = new Mock <ICategoryService>();

            _categoryService = mock2.Object;
            var mock3 = new Mock <ISystemConfigurationService>();

            mock3.Setup(x => x.GetSystemConfigurations()).Returns(new SystemConfigurationObject());
            _systemConfigurationService = mock3.Object;
        }
Example #30
0
 public UserAuthorizationService(
     ISystemConfigurationService configurationService,
     IHttpContextAccessor httpContextAccessor,
     IUserService userService,
     IIdentityManager identityManager,
     IDateTimeProvider dateTimeProvider)
 {
     _configurationService = configurationService;
     _httpContextAccessor  = httpContextAccessor;
     _userService          = userService;
     _identityManager      = identityManager;
     _dateTimeProvider     = dateTimeProvider;
 }
Example #31
0
 public SchemaController(IEsdFunctionService esdFunctionService,
                         IDataShareSchemaImportService dataShareSchemaImportService,
                         IDataSetSchemaService dataSetSchemaService,
                         IDataSetSchemaColumnService dataSetSchemaColumnService,
                         ICategoryService categoryService, ISystemConfigurationService systemConfigurationService)
     : base(systemConfigurationService, categoryService)
 {
     _esdFunctionService           = esdFunctionService;
     _dataShareSchemaImportService = dataShareSchemaImportService;
     _dataSetSchemaService         = dataSetSchemaService;
     _dataSetSchemaColumnService   = dataSetSchemaColumnService;
     _categoryService = categoryService;
 }
        public static DataTable AppendBody(this DataTable table, ISystemConfigurationService systemConfigurationService)
        {
            var bodyName = String.Format("'{0}'", systemConfigurationService.GetSystemConfigurations().CouncilName);
            var bodyUri  = String.Format("'{0}'", systemConfigurationService.GetSystemConfigurations().CouncilUri);

            table = table ?? new DataTable();
            var colBody = table.Columns.Add("PublisherLabel", typeof(String), bodyName);

            colBody.SetOrdinal(0);
            var colUri = table.Columns.Add("PublisherURI", typeof(String), bodyUri);

            colUri.SetOrdinal(1);

            return(table);
        }