Esempio n. 1
0
        public AlertSummary GetAlertSummary(int[] facilityKeys)
        {
            if (facilityKeys == null)
            {
                throw new ArgumentNullException(nameof(facilityKeys));
            }
            if (facilityKeys.Length == 0)
            {
                throw new ArgumentException("Array should have at lease one element", nameof(facilityKeys));
            }

            using (log.Activity(m => m($"Getting AlertSummary for {nameof(facilityKeys)}[{string.Join(",", facilityKeys)}]")))
            {
                var query = HttpUtility.ParseQueryString(string.Empty);
                query["FacilityKeys"] = string.Join(",", facilityKeys);
                var queryString = query.ToString();
                var requestUri  = "v1/AlertSummary" + (queryString == string.Empty ? string.Empty : "?") + queryString;

                var client = httpClientResolver.Resolve();
                client.BaseAddress = options.Value.BaseAddress;
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                var token = this.accessTokenResolver.Resolve();
                if (!string.IsNullOrWhiteSpace(token))
                {
                    client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
                }

                var result = client.GetAsync(requestUri).Result;
                result.EnsureSuccessStatusCode();
                var value = result.Content.ReadAsAsync <AlertSummary>().Result;
                return(value);
            }
        }
Esempio n. 2
0
        public IQueryable <Access> Select(string expand = null, string filter = null)
        {
            using (log.Activity(m => m($"Selecting {nameof(Access)} with expand[{expand}] and filter[{filter}] by {Thread.CurrentPrincipal?.Identity?.Name}")))
            {
                var entities = null as IQueryable <Access>;
                using (log.Activity(m => m("Create Query")))
                {
                    entities = context.Accesses
                               .AsNoTracking()
                               .Expand(expand);

                    //TODO: KB: It must be one dynamic linq or odata or typed filter
                    if (!string.IsNullOrWhiteSpace(filter))
                    {
                        var principalNames = filter.Split(',').ToList();
                        entities = entities
                                   .Where(item => principalNames.Contains(item.Principal.Name));
                    }
                }

                using (log.Activity(m => m("Authorization")))
                {
                    try
                    {
                        entities = security.ValidateSelect(entities, expand);
                    }
                    catch (UnauthorizedAccessException)
                    {
                        log.Warn($"Authorization Denied");
                        throw;
                    }
                    catch (Exception e)
                    {
                        log.Error($"Authorization Error", e);
                        throw;
                    }
                }

                var values = null as IQueryable <Access>;
                using (log.Activity(m => m("Filtering")))
                {
                    try
                    {
                        values = entities.Filters(expand).AsQueryable();
                    }
                    catch (Exception e)
                    {
                        log.Error($"Filtering Error", e);
                        throw;
                    }
                }

                log.Info(m => m($"Selected {nameof(Access)}[{string.Join(",", values.Select(item => $"{item.PrincipalId}|{item.RealmId}|{item.PermissionId}"))}] with [{expand}] by {Thread.CurrentPrincipal?.Identity?.Name}"));
                return(values);
            }
        }
Esempio n. 3
0
        public IQueryable <Facility.Facility> Select(string expand = null)
        {
            using (log.Activity(m => m($"Selecting {nameof(Facility.Facility)} with [{expand}] by {Thread.CurrentPrincipal?.Identity?.Name}")))
            {
                var entities = null as IQueryable <Facility.Facility>;
                using (log.Activity(m => m("Create Query")))
                {
                    entities = this.context.Facilities
                               .AsNoTracking()
                               .Expand(expand);
                    //entities = new List<Facility.Facility> { new Facility.Facility { Id = 1, Name = "Name 1" }, new Facility.Facility { Id = 2, Name = "Name 2" } }.AsQueryable();
                }

                using (log.Activity(m => m("Authorization")))
                {
                    try
                    {
                        //entities = security.ValidateSelect(entities, expand);
                        entities = entities;
                    }
                    catch (UnauthorizedAccessException)
                    {
                        log.Warn($"Authorization Denied");
                        throw;
                    }
                    catch (Exception e)
                    {
                        log.Error($"Authorization Error", e);
                        throw;
                    }
                }

                var values = null as IQueryable <Facility.Facility>;
                using (log.Activity(m => m("Filtering")))
                {
                    try
                    {
                        values = entities.Filters(expand).AsQueryable();
                    }
                    catch (Exception e)
                    {
                        log.Error($"Filtering Error", e);
                        throw;
                    }
                }

                log.Info(m => m($"Selected {nameof(Facility.Facility)}[{string.Join(",", values.Select(item => item.Id))}] with [{expand}] by {Thread.CurrentPrincipal?.Identity?.Name}"));
                return(values);
            }
        }
Esempio n. 4
0
        public MedicalOrderSearchResult Search(MedicalOrderSearchQuery request)
        {
            using (log.Activity(m => m($"Searching")))
            {
                var query       = HttpUtility.ParseQueryString(string.Empty);
                var queryString = query.ToString();
                var requestUri  = "fhir/MedicationOrder/_search/" + (queryString == string.Empty ? string.Empty : "?") + queryString;

                var client = httpClientResolver.Resolve();
                client.BaseAddress = options.Value.BaseAddress;
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                var token = this.accessTokenResolver.Resolve();
                if (!string.IsNullOrWhiteSpace(token))
                {
                    client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
                }

                var result = client.PostAsJsonAsync(requestUri, request).Result;

                //Compensate 404 instead of enpty reply
                if (result.StatusCode == System.Net.HttpStatusCode.NotFound)
                {
                    return(new MedicalOrderSearchResult
                    {
                        resourceType = "Bundle",
                        type = "searchset",
                        entry = Enumerable.Empty <MedicalOrderSearchResult.Entry>().ToList()
                    });
                }
                result.EnsureSuccessStatusCode();
                var value = result.Content.ReadAsAsync <MedicalOrderSearchResult>().Result;
                return(value);
            }
        }
Esempio n. 5
0
 public ConfigurationService(ILog log, IContext context)
 {
     this.log     = log ?? throw new ArgumentNullException(nameof(log));
     this.context = context ?? throw new ArgumentNullException(nameof(context));
     if ((ConfigurationManager.AppSettings["ConfigurationService.Validate"] ?? ConfigurationManager.AppSettings["configuration.validate-on-load"]) == "true")
     {
         using (log.Activity(m => m($"Validating")))
         {
             try
             {
                 GetSecondaryDataServiceOptions();
                 GetHsvIntegrationServiceOptions();
                 GetOrderServiceOptions();
                 GetSqlServerCacheOptions();
                 GetGlobalPreferencesServiceOptions();
                 GetInfusionServiceUpdaterOptions();
                 GetConfigurationContextUpdaterOptions();
                 GetSilentProvisioningServiceOptions();
                 GetAttentionNoticeStatusesTrackerOptions();
                 GetIdentityServerBearerTokenAuthenticationOptions();
             }
             catch (Exception e)
             {
                 log.Error(m => m($"Validating failure", e));
                 throw;
             }
         }
     }
 }
Esempio n. 6
0
        public void Configuration(IAppBuilder app)
        {
            log.Info("Services Owin Startup started.");

            try
            {
                using (log.Activity(m => m($"Configuring Identity")))
                {
                    app.UseCors(CorsOptions.AllowAll);

                    JwtSecurityTokenHandler.InboundClaimTypeMap = new Dictionary <string, string>();

                    //app.UseCookieAuthentication(new CookieAuthenticationOptions
                    //{
                    //    AuthenticationType = "Cookies"
                    //});

                    //TODO: Fild how to resolve it
                    app.UseIdentityServerBearerTokenAuthentication(Services.ConfigurationService.IdentityServerBearerTokenAuthenticationOptions.Value);
                }

                using (log.Activity(m => m($"Configuring WebApi")))
                {
                    app.UseWebApi(WebApiConfig.Register());
                }

                using (log.Activity(m => m($"Configuring Shutdown")))
                {
                    var context = new OwinContext(app.Properties);
                    var token   = context.Get <CancellationToken>("host.OnAppDisposing");
                    if (token != CancellationToken.None)
                    {
                        token.Register(() =>
                        {
                            this.OnAppDisposing(app);
                        });
                    }
                }

                log.Info("BD.MedView.Services Startup succeded.");
            }
            catch (Exception ex)
            {
                log.Fatal("Error occured in BD.MedView.Services Startup.", ex);
            }
        }
Esempio n. 7
0
        public string Get(string key)
        {
            if (key == null)
            {
                throw new ArgumentNullException(nameof(key));
            }

            using (log.Activity(m => m($"Reading Cache[{key}] by {Thread.CurrentPrincipal?.Identity?.Name}")))
            {
                using (log.Activity(m => m("Authorization")))
                {
                    try
                    {
                        security.ValidateGet(key);
                    }
                    catch (UnauthorizedAccessException)
                    {
                        log.Warn($"Authorization Denied");
                        throw;
                    }
                    catch (Exception e)
                    {
                        log.Error($"Authorization Error", e);
                        throw;
                    }
                }

                var value = context.GetString(key);

                //TODO: KB: Should we throw key not found or null? We cannot put null back - so it should be key-not-found. Problem in IDistributed Cache: must have TryGet

                log.Info(m => m($"Read Cache[{key}] by {Thread.CurrentPrincipal?.Identity?.Name}"));
                return(value);
            }
        }
Esempio n. 8
0
 void IObserver <EntityEvent <Authorization.Principal> > .OnNext(EntityEvent <Authorization.Principal> value)
 {
     using (log.Activity(m => m($"Processing {nameof(EntityEvent<Authorization.Principal>)} event")))
     {
         if (value.OldValue == null && value.NewValue != null)
         {
             OnCreated(value.NewValue);
         }
         else if (value.OldValue == null && value.NewValue != null)
         {
             OnUpdated(value.NewValue, value.OldValue);
         }
         else if (value.OldValue != null && value.NewValue == null)
         {
             OnDeleted(value.OldValue);
         }
         else
         {
             log.Trace(m => m($"{nameof(EntityEvent<Authorization.Principal>)} event is ignored"));
         }
     }
 }
Esempio n. 9
0
        public static void Main()
        {
            using (Log.Activity("Demonstrate using a logging Stream decorator"))
            {
                var stream        = File.OpenRead("loremipsum.txt");
                var loggingStream = new LoggingStreamDecorator(stream);

                using (var reader = new StreamReader(loggingStream))
                {
                    reader.ReadToEnd();
                }
            }

            Console.ReadLine();
        }
Esempio n. 10
0
        public IHttpActionResult Post([FromBody] SecondaryData model)
        {
            using (log.Activity(m => m($"Executing Post by {Thread.CurrentPrincipal?.Identity?.Name}")))
            {
                using (log.Activity(m => m($"Validating Input")))
                {
                    if (!ModelState.IsValid)
                    {
                        log.Trace(m => m("Validation failed"));
                        return(BadRequest(ModelState));
                    }
                }

                using (log.Activity(m => m($"Executing Service Call")))
                {
                    try
                    {
                        service.Process(model);
                    }
                    catch (UnauthorizedAccessException e)
                    {
                        log.Warn(m => m("Authorization failed", e));
                        return(StatusCode(HttpStatusCode.Forbidden));
                    }
                    catch (Exception e)
                    {
                        log.Error(m => m("Process failed", e));
                        return(InternalServerError(e));
                    }
                }

                var value = null as object;
                using (log.Activity(m => m($"Formatting Result")))
                {
                    try
                    {
                        value = new
                        {
                            PageInfoList = new
                            {
                                PageInfo = model.PageInfoList.PageInfo
                                           //Filter elements without alerts
                                           .Where(item => item.MedMinedAlert != null)
                                           .Select(item => new {
                                    item.Id,
                                    item.MedMinedAlert
                                }).ToArray()
                            }
                        };
                    }
                    catch (Exception e)
                    {
                        log.Error(m => m("Formatting failed", e));
                        return(InternalServerError(e));
                    }
                }

                log.Info(m => m($"Executing Post by {Thread.CurrentPrincipal?.Identity?.Name} succeeded"));

                return(Ok(value));
            }
        }
Esempio n. 11
0
        public IQueryable <UserPreference> Select(string expand = null)
        {
            using (log.Activity(m => m($"Selecting {nameof(UserPreference)} with [{expand}] by {Thread.CurrentPrincipal?.Identity?.Name}")))
            {
                var entities = null as IQueryable <UserPreference>;
                using (log.Activity(m => m("Create Query")))
                {
                    entities = context.UserPreferences
                               .AsNoTracking()
                               .Expand(expand);
                }

                using (log.Activity(m => m("Authorization")))
                {
                    try
                    {
                        entities = security.ValidateSelect(entities, expand);
                    }
                    catch (UnauthorizedAccessException)
                    {
                        log.Warn($"Authorization Denied");
                        throw;
                    }
                    catch (Exception e)
                    {
                        log.Error($"Authorization Error", e);
                        throw;
                    }
                }

                var values = null as IQueryable <UserPreference>;
                using (log.Activity(m => m("Filtering")))
                {
                    try
                    {
                        values = entities.Filters(expand).AsQueryable();
                    }
                    catch (Exception e)
                    {
                        log.Error($"Filtering Error", e);
                        throw;
                    }
                }

                log.Info(m => m($"Selected {nameof(UserPreference)}[{string.Join(",", values.Select(item => item.Id))}] with [{expand}] by {Thread.CurrentPrincipal?.Identity?.Name}"));
                return(values);
            }
        }
Esempio n. 12
0
        public void Process(SecondaryData value)
        {
            value = value ?? throw new ArgumentNullException(nameof(value));

            using (log.Activity(m => m($"Process {nameof(SecondaryData)} by {Thread.CurrentPrincipal?.Identity?.Name}")))
            {
                using (log.Activity(m => m("Preparing PageInfo and Cache")))
                {
                    try
                    {
                        var refreshCacheTask   = Task.Run(() => Cache(value));
                        var enrichPageInfoTask = Task.Run(() => Enrich(value));
                        Task.WaitAll(refreshCacheTask, enrichPageInfoTask);
                    }
                    catch (Exception e)
                    {
                        log.Error($"Preparing PageInfo and Cache Error", e);
                        throw;
                    }
                }

                var pageInfoList = null as List <PageInfo>;
                using (log.Activity(m => m($"Filtering {nameof(PageInfo)} that cannot be matched")))
                {
                    pageInfoList = value.PageInfoList.PageInfo
                                   .Where(item => CanMatch(item))
                                   .ToList();

                    log.Trace(m => m($"Ignored {nameof(PageInfo)} [{string.Join(",", value.PageInfoList.PageInfo.Except(pageInfoList).Select(item => item.MedMinedfacilityId))}]"));
                }

                var alertList = null as List <Alert>;
                using (log.Activity(m => m($"Get {nameof(Alert)} from Cache")))
                {
                    alertList = pageInfoList
                                .Select(item => int.Parse(item.MedMinedfacilityId))
                                .Distinct()
                                .SelectMany(item => GetAlertsFromCache(item) ?? Enumerable.Empty <Alert>())
                                .ToList();

                    log.Trace(m => m($"Found {nameof(Alert)} for {nameof(Alert.facility_id)} [{string.Join(",", alertList.Select(item => item.facility_id).Distinct())}]"));
                }

                using (log.Activity(m => m($"Matching {nameof(PageInfo)} to {nameof(Alert)}")))
                {
                    var pageInfoAlerts = pageInfoList.Join(alertList,
                                                           (pageInfo) => pageInfo.MedMinedfacilityId,
                                                           (alert) => alert.facility_id.ToString(),
                                                           (pageInfo, alert) => Tuple.Create(pageInfo, alert));

                    foreach (var pageInfoAlert in pageInfoAlerts)
                    {
                        var pageInfo = pageInfoAlert.Item1;
                        var alert    = pageInfoAlert.Item2;

                        var isMatched = default(bool);
                        using (log.Activity(m => m($"Matching {nameof(PageInfo)}[{pageInfo.Id}] to {nameof(Alert)}[{alert.alert_id}]")))
                        {
                            isMatched = Match(pageInfo, alert);
                            log.Trace(m => m($"Match" + (isMatched ? " " : " not ") + $"found for {nameof(PageInfo)}[{pageInfo.Id}] to {nameof(Alert)}[{alert.alert_id}]"));
                        }

                        if (isMatched)
                        {
                            using (log.Activity(m => m($"Adding {nameof(Alert)}[{alert.alert_id}] to {nameof(PageInfo)}[{pageInfo.Id}].{nameof(PageInfo.MedMinedAlert)}")))
                            {
                                Fill(pageInfo, alert);
                                log.Trace(m => m($"Added {nameof(Alert)}[{alert.alert_id}] to {nameof(PageInfo)}[{pageInfo.Id}].{nameof(PageInfo.MedMinedAlert)}"));
                            }
                        }
                    }
                }

                log.Info(m => m($"Processed {nameof(SecondaryData)} by {Thread.CurrentPrincipal?.Identity?.Name}"));
            }
        }
Esempio n. 13
0
 public IEnumerable <WidgetState> GetMappings()
 {
     using (log.Activity(m => m($"{nameof(GetMappings)} by {Thread.CurrentPrincipal?.Identity?.Name}")))
     {
         using (log.Activity(m => m($"Read {nameof(WidgetState)}")))
         {
             return(context.WidgetStates.Include(x => x.ProviderStates));
         }
     }
 }
Esempio n. 14
0
        public void Provision(IPrincipal principal)
        {
            using (log.Activity(m => m($"Provisioning {Thread.CurrentPrincipal?.Identity?.Name}")))
            {
                var userName = null as string;
                using (log.Activity(m => m($"Validate {Thread.CurrentPrincipal?.Identity?.Name}")))
                {
                    var identity = Thread.CurrentPrincipal.Identity as ClaimsIdentity;
                    if (identity == null)
                    {
                        log.Info($"Identity is not ClaimsIdentity or null. Ignore Execution.");
                        return;
                    }
                    userName = identity.Claims.FirstOrDefault(x => x.Type == "user_id")?.Value ?? identity.Name;
                    if (userName == null)
                    {
                        log.Info($"UserName claim value is not found. Ignore Execution.");
                        return;
                    }
                    var isSuperByClaim = IsSuperByClaim(identity);
                    if (!isSuperByClaim)
                    {
                        log.Info($"Required claim value is not found. Ignore Execution.");
                        return;
                    }
                }

                using (log.Activity(m => m($"Impersonating Operation")))
                {
                    //TODO: KB: Do we need to secure operation that always must succeed?
                    using (new Impersonate(new GenericPrincipal(new GenericIdentity(systemIdentityName), new string[0])))
                    {
                        var relation = null as Role;
                        using (log.Activity(m => m($"Read {nameof(Role)}[\"{roleName}\"]")))
                        {
                            relation = context.Roles.Include(item => item.Realm).SingleOrDefault(item => item.Name == roleName);
                        }
                        if (relation == null)
                        {
                            log.Error($"{nameof(Role)}[\"{roleName}\"] is not found");
                            throw new KeyNotFoundException();
                        }

                        var entity = null as Principal;
                        using (log.Activity(m => m($"Read {nameof(Principal)}[\"{userName}\"]")))
                        {
                            entity = context.Principals.Include(item => item.Roles.Select(r => r.Realm)).SingleOrDefault(item => item.Name == userName);
                        }
                        if (entity == null)
                        {
                            log.Info($"{nameof(Principal)}[\"{userName}\"] is not found.");
                            using (log.Activity(m => m("Create Entity")))
                            {
                                try
                                {
                                    entity = context.Principals.Add(new Principal {
                                        Name = userName
                                    });
                                    context.SaveChanges();
                                }
                                //TODO: KB: Do this on index validation
                                //throw new DuplicateKeyException(value.Name)
                                catch (Exception e)
                                {
                                    log.Error($"Update Error", e);
                                    throw;
                                }
                            }

                            var newValue = entity.Filter();
                            using (log.Activity(m => m("Emit Event")))
                            {
                                try
                                {
                                    emitter.OnCreated(newValue);
                                }
                                catch (Exception e)
                                {
                                    log.Error($"Emit Event Error", e);
                                    throw;
                                }
                            }
                        }

                        if (entity.Roles.Any(item => item.Id == relation.Id))
                        {
                            log.Info($"{nameof(Principal)}[\"{userName}\"] already has role {nameof(Role)}[\"{roleName}\"]. Ignore Execution.");
                            return;
                        }

                        using (log.Activity(m => m("Update Entity")))
                        {
                            try
                            {
                                relation.Principals.Add(entity);
                                context.SaveChanges();
                            }
                            catch (Exception e)
                            {
                                log.Error($"Update Error", e);
                                throw;
                            }
                        }

                        using (log.Activity(m => m("Emit Event")))
                        {
                            try
                            {
                                var leftValue  = entity.Filter();
                                var rightValue = relation.Filter();
                                linkEmitter.OnAdded(leftValue, rightValue, item => item.Roles);
                            }
                            catch (Exception e)
                            {
                                log.Error($"Emit Event Error", e);
                                throw;
                            }
                        }

                        log.Info($"Provisioned {nameof(Role)}[\"{roleName}\"] to {nameof(Principal)}[\"{userName}\"].{nameof(Principal.Roles)} by {Thread.CurrentPrincipal?.Identity?.Name}");
                    }
                }
            }
        }
Esempio n. 15
0
 private SecondaryDataServiceOptions GetSecondaryDataServiceOptions()
 {
     using (log.Activity(m => m($"Executing {nameof(GetSecondaryDataServiceOptions)}")))
     {
         var option = new SecondaryDataServiceOptions();
         using (log.Activity(m => m($"Read {nameof(SecondaryDataServiceOptions.CacheAbsoluteExpiration)}")))
         {
             //TODO: KB: Fix This
             var pattern = ConfigurationManager.AppSettings["SecondaryDataServiceOptions.CacheAbsoluteExpiration"] ?? ConfigurationManager.AppSettings["secondary-data.cache.absolute-expiration"];
             option.CacheAbsoluteExpiration = string.IsNullOrWhiteSpace(pattern) ? (TimeSpan?)null : TimeSpan.Parse(pattern);
         }
         using (log.Activity(m => m($"Read {nameof(SecondaryDataServiceOptions.CacheSlidingExpiration)}")))
         {
             //TODO: KB: Fix This
             var pattern = ConfigurationManager.AppSettings["SecondaryDataServiceOptions.CacheSlidingExpiration"] ?? ConfigurationManager.AppSettings["secondary-data.cache.sliding-expiration"];
             option.CacheSlidingExpiration = string.IsNullOrWhiteSpace(pattern) ? (TimeSpan?)null : TimeSpan.Parse(pattern);
         }
         using (log.Activity(m => m($"Read {nameof(SecondaryDataServiceOptions.MaxLimit)}")))
         {
             //TODO: KB: Fix This
             var pattern = ConfigurationManager.AppSettings["SecondaryDataServiceOptions.MaxLimit"] ?? ConfigurationManager.AppSettings["secondary-data.alerts.max-limit"];
             option.MaxLimit = string.IsNullOrWhiteSpace(pattern) ? option.MaxLimit : int.Parse(pattern);
         }
         using (log.Activity(m => m($"Read {nameof(SecondaryDataServiceOptions.MaxDegreeOfParallelism)}")))
         {
             //TODO: KB: Fix This
             var pattern = ConfigurationManager.AppSettings["SecondaryDataServiceOptions.MaxDegreeOfParallelism"] ?? ConfigurationManager.AppSettings["secondary-data.alerts.max-degree-of-parallelism"];
             option.MaxDegreeOfParallelism = string.IsNullOrWhiteSpace(pattern) ? option.MaxDegreeOfParallelism : int.Parse(pattern);
         }
         using (log.Activity(m => m($"Read {nameof(SecondaryDataServiceOptions.Variance)}")))
         {
             //We cannot use context here
             var connectionString = ConfigurationManager.ConnectionStrings["BD.MedView.Services.Models.CacheContext"]?.ConnectionString;
             if (!string.IsNullOrWhiteSpace(connectionString))
             {
                 try
                 {
                     using (var connection = new System.Data.SqlClient.SqlConnection(connectionString))
                     {
                         connection.Open();
                         var command = new System.Data.SqlClient.SqlCommand("SELECT [Configurations] FROM [conf].[GlobalPreferences] WHERE [Name] = 'Infusion'", connection);
                         using (var reader = command.ExecuteReader())
                         {
                             if (reader.Read())
                             {
                                 var value = (string)reader[0];
                                 option.Variance = JsonConvert.DeserializeAnonymousType(value, new { OrderServiceVariance = 0 }).OrderServiceVariance;
                             }
                         }
                     }
                 }
                 catch (Exception e)
                 {
                     log.Error(m => m($"Read {nameof(SecondaryDataServiceOptions.Variance)} failure", e));
                     throw;
                 }
             }
         }
         using (log.Activity(m => m($"Read {nameof(SecondaryDataServiceOptions.IdKindMapping)}")))
         {
             //We cannot use context here
             var connectionString = ConfigurationManager.ConnectionStrings["BD.MedView.Services.Models.CacheContext"]?.ConnectionString;
             if (!string.IsNullOrWhiteSpace(connectionString))
             {
                 try
                 {
                     using (var connection = new System.Data.SqlClient.SqlConnection(connectionString))
                     {
                         connection.Open();
                         var command = new System.Data.SqlClient.SqlCommand("SELECT [PatientIdKind],[FhirServiceValue] FROM [conf].[PatientIdKindFhirServiceMappings]", connection);
                         using (var reader = command.ExecuteReader())
                         {
                             while (reader.Read())
                             {
                                 var key   = (string)reader[0];
                                 var value = (string)reader[0];
                                 option.IdKindMapping[key] = value;
                             }
                         }
                     }
                 }
                 catch (Exception e)
                 {
                     log.Error(m => m($"Read {nameof(SecondaryDataServiceOptions.IdKindMapping)} failure", e));
                     throw;
                 }
             }
         }
         return(option);
     }
 }
Esempio n. 16
0
 void IObserver <EntityEvent <AttentionNoticeStatus> > .OnNext(EntityEvent <AttentionNoticeStatus> value)
 {
     using (log.Activity(m => m($"Processing {nameof(EntityEvent<AttentionNoticeStatus>)} event")))
     {
         if (value.OldValue == null && value.NewValue != null)
         {
             OnCreated(value.NewValue);
         }
         else if (value.OldValue != null && value.NewValue != null)
         {
             OnUpdated(value.NewValue, value.OldValue);
         }
         else if (value.OldValue != null && value.NewValue == null)
         {
             OnDeleted(value.OldValue);
         }
         else
         {
             log.Trace(m => m($"{nameof(EntityEvent<Facility.Facility>)} event is ignored"));
         }
     }
 }